initial

game/client/cstrike15/uicomponents/uicomponent_common.cpp

@@ -0,0 +1,271 @@
+//========= Copyright (C) Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Helper for UI components - used for binding to both Scaleform ActionScript and 
+//          Panorama Javascript.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "uicomponent_common.h"
+
+#if defined ( USE_PANORAMA_BINDINGS )
+static CPanoramaMarshallHelper g_PanoramaMarshallHelper;
+CPanoramaMarshallHelper* GetPanoramaMarshallHelper( void )
+{
+	return &g_PanoramaMarshallHelper;
+}
+
+SFVALUEARRAY CPanoramaMarshallHelper::Params_GetArgs( SFPARAMS params )
+{
+	Assert( 0 ); // IMPLEMENT ME OR REFACTOR CALLING CODE
+	return SFVALUEARRAY();
+}
+
+unsigned int CPanoramaMarshallHelper::Params_GetNumArgs( SFPARAMS params )
+{
+	const v8::FunctionCallbackInfo<v8::Value> &args = *reinterpret_cast< const v8::FunctionCallbackInfo<v8::Value> * >( params );
+	return args.Length();
+}
+
+bool CPanoramaMarshallHelper::Params_ArgIs( SFPARAMS params, unsigned int index, _ValueType v )
+{
+	return ( Params_GetArgType( params, index ) == v );
+}
+
+SFVALUE CPanoramaMarshallHelper::Params_GetArg( SFPARAMS params, int index /*= 0 */ )
+{
+	Assert( 0 ); // IMPLEMENT ME OR REFACTOR CALLING CODE
+	return NULL;
+}
+
+IUIMarshalHelper::_ValueType CPanoramaMarshallHelper::Params_GetArgType( SFPARAMS params, int index /*= 0 */ )
+{
+	const v8::FunctionCallbackInfo<v8::Value> &args = *reinterpret_cast< const v8::FunctionCallbackInfo<v8::Value> * >( params );
+	if ( args[ index ]->IsBoolean() )
+		return VT_Boolean;
+	else if ( args[ index ]->IsNumber() )
+		return VT_Number;
+	else if ( args[ index ]->IsInt32() )
+		return VT_Int;
+	else if ( args[ index ]->IsUint32() )
+		return VT_UInt;
+	else if ( args[ index ]->IsString() )
+		return VT_String;
+	else if ( args[ index ]->IsUndefined() )
+		return VT_Undefined;
+	else if ( args[ index ]->IsNull() )
+		return VT_Null;
+
+
+	Assert( 0 ); 
+	return VT_Undefined;
+}
+
+double CPanoramaMarshallHelper::Params_GetArgAsNumber( SFPARAMS params, int index /*= 0 */ )
+{
+	const v8::FunctionCallbackInfo<v8::Value> &args = *reinterpret_cast< const v8::FunctionCallbackInfo<v8::Value> * >( params );
+	Assert( args[ index ]->IsNumber() );
+	return args[ index ]->NumberValue();
+}
+
+bool CPanoramaMarshallHelper::Params_GetArgAsBool( SFPARAMS params, int index /*= 0 */ )
+{
+	const v8::FunctionCallbackInfo<v8::Value> &args = *reinterpret_cast< const v8::FunctionCallbackInfo<v8::Value> * >( params );
+	Assert( args[ index ]->IsBoolean() );
+	return args[ index ]->BooleanValue();
+}
+
+const char* CPanoramaMarshallHelper::Params_GetArgAsString( SFPARAMS params, int index /*= 0 */ )
+{
+	const v8::FunctionCallbackInfo<v8::Value> &args = *reinterpret_cast< const v8::FunctionCallbackInfo<v8::Value> * >( params );
+	m_vecStringStorage.EnsureCount( index + 1 );
+	Assert( args[ index ]->IsString() );
+	v8::String::Utf8Value str( args[ index ] );
+	m_vecStringStorage[ index ].Set( *str );
+	return m_vecStringStorage[ index ];
+}
+
+const wchar_t* CPanoramaMarshallHelper::Params_GetArgAsStringW( SFPARAMS params, int index /*= 0 */ )
+{
+	Assert( 0 ); // IMPLEMENT ME OR REFACTOR CALLING CODE
+	return NULL;
+}
+
+void CPanoramaMarshallHelper::Params_DebugSpew( SFPARAMS params )
+{
+	Assert( 0 );
+}
+
+void CPanoramaMarshallHelper::Params_SetResult( SFPARAMS params, SFVALUE value )
+{
+	Assert( 0 );
+}
+
+void CPanoramaMarshallHelper::Params_SetResult( SFPARAMS params, int value )
+{
+	const v8::FunctionCallbackInfo<v8::Value> &args = *reinterpret_cast< const v8::FunctionCallbackInfo<v8::Value> * >( params );
+	args.GetReturnValue().Set( v8::Integer::New( args.GetIsolate(), value ) );
+}
+
+void CPanoramaMarshallHelper::Params_SetResult( SFPARAMS params, float value )
+{
+	const v8::FunctionCallbackInfo<v8::Value> &args = *reinterpret_cast< const v8::FunctionCallbackInfo<v8::Value> * >( params );
+	args.GetReturnValue().Set( v8::Number::New( args.GetIsolate(), value ) );
+}
+
+void CPanoramaMarshallHelper::Params_SetResult( SFPARAMS params, bool value )
+{
+	const v8::FunctionCallbackInfo<v8::Value> &args = *reinterpret_cast< const v8::FunctionCallbackInfo<v8::Value> * >( params );
+	args.GetReturnValue().Set( v8::Boolean::New( args.GetIsolate(), value ) );
+}
+
+void CPanoramaMarshallHelper::Params_SetResult( SFPARAMS params, const char* value, bool bMakeNewValue /*=false*/ )
+{
+	const v8::FunctionCallbackInfo<v8::Value> &args = *reinterpret_cast< const v8::FunctionCallbackInfo<v8::Value> * >( params );
+	args.GetReturnValue().Set( v8::String::NewFromOneByte( args.GetIsolate(), (uint8*)value ) );
+}
+
+void CPanoramaMarshallHelper::Params_SetResult( SFPARAMS params, const wchar_t* value, bool bMakeNewValue /*=false*/ )
+{
+	const v8::FunctionCallbackInfo<v8::Value> &args = *reinterpret_cast< const v8::FunctionCallbackInfo<v8::Value> * >( params );
+	args.GetReturnValue().Set(  v8::String::NewFromTwoByte( args.GetIsolate(), (uint16*)value ) );
+}
+
+SFVALUE CPanoramaMarshallHelper::Params_CreateNewObject( SFPARAMS params )
+{
+	Assert( 0 );
+	return NULL;
+}
+
+SFVALUE CPanoramaMarshallHelper::Params_CreateNewString( SFPARAMS params, const char* value )
+{
+	Assert( 0 );
+	return NULL;
+}
+
+SFVALUE CPanoramaMarshallHelper::Params_CreateNewString( SFPARAMS params, const wchar_t* value )
+{
+	Assert( 0 );
+	return NULL;
+}
+
+SFVALUE CPanoramaMarshallHelper::Params_CreateNewArray( SFPARAMS params, int size /*= -1 */ )
+{
+	Assert( 0 );
+	return NULL;
+}
+#endif // USE_PANORAMA_BINDINGS
+
+// Using this from webapi_response to reuse some code.
+extern void EmitJSONString( CUtlBuffer &outputBuffer, const char *pchValue );
+
+// Convert keyvalues to a json object.
+bool Helper_RecursiveKeyValuesToJSONString( const KeyValues* pKV, CUtlBuffer &outBuffer )
+{
+	outBuffer.PutChar( '{' );
+	for ( KeyValues *dat = pKV->GetFirstSubKey(); dat != NULL; dat = dat->GetNextKey() )
+	{
+		if ( !dat->GetName() )
+		{
+			Assert( 0 ); // Unhandled
+			return false;
+		}
+
+		EmitJSONString( outBuffer, dat->GetName() );
+		outBuffer.PutChar( ':' );
+
+		if ( dat->GetFirstSubKey() )
+		{
+			Helper_RecursiveKeyValuesToJSONString( dat, outBuffer );
+		}
+		else 
+		{
+			switch ( dat->GetDataType() )
+			{
+				case KeyValues::TYPE_NONE:
+				{
+					Helper_RecursiveKeyValuesToJSONString( dat, outBuffer );
+					break;
+				}
+				case KeyValues::TYPE_STRING:
+				{
+					if ( dat->GetString() )
+						EmitJSONString( outBuffer, dat->GetString() );
+					else
+						outBuffer.Put( "null", 4 );
+
+					break;
+				}
+				case KeyValues::TYPE_INT:
+				{
+					CNumStr numStr( dat->GetInt() );
+					outBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
+					break;
+				}
+
+				case KeyValues::TYPE_UINT64:
+				{
+					CNumStr numStr( dat->GetUint64() );
+					outBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
+					break;
+				}
+
+				case KeyValues::TYPE_FLOAT:
+				{
+					CNumStr numStr( dat->GetFloat() );
+					outBuffer.Put( numStr.String(), Q_strlen( numStr.String() ) );
+					break;
+				}
+
+				default:
+				{
+					Assert( 0 ); // Unhandled
+					return false;
+				}
+			}
+		}
+
+		if ( dat->GetNextKey() )
+		{
+			outBuffer.PutChar( ',' );
+		}
+	}
+	outBuffer.PutChar( '}' );
+	return true;
+}
+
+void Helper_TrackedCachedGcValueAcrossRuns( ConVar &cv, int &nValue, bool bValueObtainedThisSession, RTime32 rtNow )
+{
+	if ( !rtNow )
+		return;
+	
+	bool bUpdateCachedValue = false;
+	RTime32 const rtCached = cv.GetInt();
+
+	if ( !bValueObtainedThisSession )
+	{
+		if ( ( int( rtCached - 24 * 3600 ) < int( rtNow ) ) &&
+			( int( rtNow - rtCached ) < 7 * 24 * 3600 ) )
+		{
+			nValue = rtCached & 0xFF; // Return a cached number
+		}
+		else
+		{
+			nValue = RandomInt( 4, 19 ); // Fake number of teammates to lure user
+			bUpdateCachedValue = true;
+		}
+	}
+	else
+	{
+		bUpdateCachedValue = true;
+	}
+
+	if ( bUpdateCachedValue )
+	{
+		rtNow &= ~0xFF; // vacate room for caching 0..255
+		rtNow |= nValue & 0xFF; // store the count in there too
+		if ( rtNow != rtCached )
+			cv.SetValue( int( rtNow ) );
+	}
+}

game/client/cstrike15/uicomponents/uicomponent_common.h

@@ -0,0 +1,741 @@
+//========= Copyright (C) 1996-2013, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Helper for UI components - used for binding to both Scaleform ActionScript and 
+//          Panorama Javascript.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef UICOMPONENT_COMMON_H
+#define UICOMPONENT_COMMON_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define USE_SCALEFORM_BINDINGS
+
+#if defined ( PANORAMA_ENABLE )
+#define USE_PANORAMA_BINDINGS
+#endif // PANORAMA_ENABLE
+
+// Scaleform events are simply KeyValue objects, so it's possible to test defining, declaring and broadcasting events 
+// in isolation without including Scaleform headers using the define below.
+//#define TEST_SCALEFORM_EVENTS
+
+#ifndef CSGO_PORT
+// In Source1 the pointers_to_members pragma is used within Scaleform and VGUI headers to ensure member function pointers
+// are maximum size. This affects the panorama javascript bindings (see uijsregistration.h).
+// We also add the pragma here so that we always assume the larger size pointers in source 1 for consistency, regardless
+// of the order of includes. 
+#define MEMBER_FUNCPTRS_MAXSIZE
+#pragma pointers_to_members( full_generality, virtual_inheritance )
+#endif
+
+#ifdef USE_SCALEFORM_BINDINGS
+#include "scaleformui/scaleformui.h"
+#endif
+
+#ifdef USE_PANORAMA_BINDINGS
+
+#include "panorama/uijsregistration.h"
+#include "panorama/iuiengine.h"
+#define DECLARE_PANORAMA_JSREGISTERFUNC void JSRegisterFunc();
+#else
+#define DECLARE_PANORAMA_JSREGISTERFUNC
+#endif
+
+#include "bannedwords.h"
+
+class IUiComponentGlobalInstanceBase
+{
+public:
+	virtual void Tick() {}
+	virtual void Shutdown() = 0;
+	virtual void InstallScaleformBindings( int iSlot ) = 0;
+	virtual void InstallPanoramaBindings() = 0;
+	virtual void ShutdownComponentApiDef(int iSlot) = 0;
+};
+
+template < class T >
+class CUiComponentGlobalInstanceHelper : public IUiComponentGlobalInstanceBase
+{
+protected:
+	static T* & InternalInstancePtr() { static T* s_pInstance = NULL; return s_pInstance; }
+
+public:
+	static T* GetInstance()
+	{
+		if ( !InternalInstancePtr() )
+		{
+			InternalInstancePtr() = new T();
+		}
+		return InternalInstancePtr();
+	}
+
+	void Shutdown() OVERRIDE
+	{
+		T *pInstance = InternalInstancePtr();
+		Assert( pInstance && (pInstance == this) );
+		if ( pInstance && (pInstance == this) )
+		{
+			InternalInstancePtr() = NULL;
+			delete pInstance;
+		}
+	}
+};
+
+#define UI_COMPONENT_DECLARE_GLOBAL_INSTANCE_ONLY( classname ) \
+	protected: \
+		friend class CUiComponentGlobalInstanceHelper< classname >; \
+		void InstallScaleformBindings( int iSlot ) OVERRIDE; \
+		void InstallPanoramaBindings( ) OVERRIDE; \
+		void ShutdownComponentApiDef( int iSlot ) OVERRIDE; \
+		classname(); \
+		~classname(); \
+	private: \
+		classname( const classname & other ); \
+		classname & operator = ( const classname & other ); \
+		DECLARE_PANORAMA_JSREGISTERFUNC
+
+
+#if defined (USE_SCALEFORM_BINDINGS) || defined (TEST_SCALEFORM_EVENTS)
+
+//-----------------------------------------------------------------------------
+// Purpose: Helpers for Scaleform events
+// The following macros and template functions allow Scaleform events to be declared
+// and broadcast using Panorama-style macros, so a single UI_COMPONENT_BROADCAST_EVENT
+// macro can broadcast both Panorama and Scaleform events.
+//-----------------------------------------------------------------------------
+namespace sfevents
+{
+	template < typename T >
+	void SetSFParam(KeyValues * pKv, const char* pName)
+	{
+		// Fallback for non-specialized types.
+		pKv->SetInt(pName, 0);
+	}
+
+	template <> inline void SetSFParam< const char * >(KeyValues * pKv, const char* pName)	{ pKv->SetString(pName, ""); }
+	template <> inline void SetSFParam< uint8 >(KeyValues * pKv, const char* pName)			{ pKv->SetInt(pName, 0); }
+	template <> inline void SetSFParam< uint16 >(KeyValues * pKv, const char* pName)		{ pKv->SetInt(pName, 0); }
+	template <> inline void SetSFParam< uint32 >(KeyValues * pKv, const char* pName)		{ pKv->SetInt(pName, 0); }
+	template <> inline void SetSFParam< uint64 >(KeyValues * pKv, const char* pName)		{ pKv->SetUint64(pName, 0); }
+	template <> inline void SetSFParam< int32 >(KeyValues * pKv, const char* pName)			{ pKv->SetInt(pName, 0); }
+	template <> inline void SetSFParam< int64 >(KeyValues * pKv, const char* pName)			{ pKv->SetUint64(pName, 0); }
+	template <> inline void SetSFParam< float >(KeyValues * pKv, const char* pName)			{ pKv->SetFloat(pName, 0.0f); }
+	template <> inline void SetSFParam< bool >(KeyValues * pKv, const char* pName)			{ pKv->SetBool(pName, false); }
+	template <> inline void SetSFParam< void* >(KeyValues * pKv, const char* pName)			{ pKv->SetPtr(pName, NULL); }
+
+	inline void SetSFParamValues(KeyValues * pKv, ...)
+	{
+		va_list args;
+		va_start(args, pKv);
+
+		FOR_EACH_SUBKEY(pKv, pSubkey)
+		{
+			switch (pSubkey->GetDataType()) {
+			case KeyValues::TYPE_STRING:
+				pKv->SetString(pSubkey->GetName(), va_arg(args, const char*));
+				break;
+			case KeyValues::TYPE_INT:
+				pKv->SetInt(pSubkey->GetName(), va_arg(args, int));
+				break;
+			case KeyValues::TYPE_FLOAT:
+				pKv->SetFloat(pSubkey->GetName(), va_arg(args, double));
+				break;
+			case KeyValues::TYPE_UINT64:
+				pKv->SetUint64(pSubkey->GetName(), va_arg(args, uint64));
+				break;
+			case KeyValues::TYPE_PTR:
+				pKv->SetPtr(pSubkey->GetName(), va_arg(args, void*));
+				break;
+			default:
+				Plat_FatalError("Invalid SF Event param type\n");
+				break;
+			}
+		}
+	}
+}
+
+#define SF_COMPONENT_EVENT_NAME( category, eventname ) "ScaleformComponent_" #category "_" #eventname
+#define SF_COMPONENT_EVENT_OBJECT_NAME( category, eventname ) g_ScaleformComponent_##category##_##eventname##_event
+
+#define SF_COMPONENT_DECLARE_EVENT0( category, eventname ) \
+class ScaleformComponent_##category##_##eventname##_event \
+		{ public: \
+			ScaleformComponent_##category##_##eventname##_event() { m_pKv = new KeyValues(SF_COMPONENT_EVENT_NAME(category, eventname)); } \
+			 KeyValues* m_pKv; \
+		}; \
+extern ScaleformComponent_##category##_##eventname##_event SF_COMPONENT_EVENT_OBJECT_NAME( category, eventname );
+
+#define SF_COMPONENT_DECLARE_EVENT1( category, eventname, param1_name, param1 ) \
+class ScaleformComponent_##category##_##eventname##_event \
+		{ public: \
+			ScaleformComponent_##category##_##eventname##_event() { \
+				m_pKv = new KeyValues(SF_COMPONENT_EVENT_NAME(category, eventname)); \
+				sfevents::SetSFParam<param1>(m_pKv, param1_name); \
+			} \
+			KeyValues* m_pKv; \
+		}; \
+extern ScaleformComponent_##category##_##eventname##_event SF_COMPONENT_EVENT_OBJECT_NAME( category, eventname );
+
+#define SF_COMPONENT_DECLARE_EVENT2(category, eventname, param1_name, param1, param2_name, param2) \
+class ScaleformComponent_##category##_##eventname##_event \
+		{ public: \
+			ScaleformComponent_##category##_##eventname##_event() { \
+				m_pKv = new KeyValues(SF_COMPONENT_EVENT_NAME(category, eventname)); \
+				sfevents::SetSFParam<param1>(m_pKv, param1_name); \
+				sfevents::SetSFParam<param2>(m_pKv, param2_name); \
+			} \
+			KeyValues* m_pKv; \
+		}; \
+extern ScaleformComponent_##category##_##eventname##_event SF_COMPONENT_EVENT_OBJECT_NAME( category, eventname );
+
+#define SF_COMPONENT_DECLARE_EVENT3(category, eventname, param1_name, param1, param2_name, param2, param3_name, param3) \
+class ScaleformComponent_##category##_##eventname##_event \
+		{ public: \
+			ScaleformComponent_##category##_##eventname##_event() { \
+				m_pKv = new KeyValues(SF_COMPONENT_EVENT_NAME(category, eventname)); \
+				sfevents::SetSFParam<param1>(m_pKv, param1_name); \
+				sfevents::SetSFParam<param2>(m_pKv, param2_name); \
+				sfevents::SetSFParam<param3>(m_pKv, param3_name); \
+			} \
+			KeyValues* m_pKv; \
+		}; \
+extern ScaleformComponent_##category##_##eventname##_event SF_COMPONENT_EVENT_OBJECT_NAME( category, eventname );
+
+#define SF_COMPONENT_DECLARE_EVENT4(category, eventname, param1_name, param1, param2_name, param2, param3_name, param3, param4_name, param4) \
+class ScaleformComponent_##category##_##eventname##_event \
+		{ public: \
+			ScaleformComponent_##category##_##eventname##_event() { \
+				m_pKv = new KeyValues(SF_COMPONENT_EVENT_NAME(category, eventname)); \
+				sfevents::SetSFParam<param1>(m_pKv, param1_name); \
+				sfevents::SetSFParam<param2>(m_pKv, param2_name); \
+				sfevents::SetSFParam<param3>(m_pKv, param3_name); \
+				sfevents::SetSFParam<param4>(m_pKv, param4_name); \
+			} \
+			KeyValues* m_pKv; \
+		}; \
+extern ScaleformComponent_##category##_##eventname##_event SF_COMPONENT_EVENT_OBJECT_NAME( category, eventname );
+
+#define SF_COMPONENT_DECLARE_EVENT5(category, eventname, param1_name, param1, param2_name, param2, param3_name, param3, param4_name, param4, param5_name, param5) \
+class ScaleformComponent_##category##_##eventname##_event \
+		{ public: \
+			ScaleformComponent_##category##_##eventname##_event() { \
+				m_pKv = new KeyValues(SF_COMPONENT_EVENT_NAME(category, eventname)); \
+				sfevents::SetSFParam<param1>(m_pKv, param1_name); \
+				sfevents::SetSFParam<param2>(m_pKv, param2_name); \
+				sfevents::SetSFParam<param3>(m_pKv, param3_name); \
+				sfevents::SetSFParam<param4>(m_pKv, param4_name); \
+				sfevents::SetSFParam<param5>(m_pKv, param5_name); \
+			} \
+			KeyValues* m_pKv; \
+		}; \
+extern ScaleformComponent_##category##_##eventname##_event SF_COMPONENT_EVENT_OBJECT_NAME( category, eventname );
+
+#define SF_COMPONENT_DEFINE_EVENT(category, eventname) \
+ScaleformComponent_##category##_##eventname##_event SF_COMPONENT_EVENT_OBJECT_NAME( category, eventname );
+
+#define SF_COMPONENT_BROADCAST_EVENT( category, eventname, ... ) \
+	{ \
+		KeyValues* pKv = SF_COMPONENT_EVENT_OBJECT_NAME( category, eventname ).m_pKv->MakeCopy(); \
+		sfevents::SetSFParamValues(pKv, ##__VA_ARGS__); \
+		if(g_pMatchFramework) g_pMatchFramework->GetEventsSubscription()->BroadcastEvent(pKv); \
+	}
+#else  // if defined (USE_SCALEFORM_BINDINGS) || defined (TEST_SCALEFORM_EVENTS)
+
+#define SF_COMPONENT_EVENT_NAME( category, eventname ) "ScaleformComponent_" #category "_" #eventname
+#define SF_COMPONENT_EVENT_OBJECT_NAME( category, eventname ) g_ScaleformComponent_##category##_##eventname##_event
+#define SF_COMPONENT_DECLARE_EVENT0( category, eventname )
+#define SF_COMPONENT_DECLARE_EVENT1( category, eventname, param1_name, param1 )
+#define SF_COMPONENT_DECLARE_EVENT2(category, eventname, param1_name, param1, param2_name, param2)
+#define SF_COMPONENT_DECLARE_EVENT3(category, eventname, param1_name, param1, param2_name, param2, param3_name, param3)
+#define SF_COMPONENT_DECLARE_EVENT4(category, eventname, param1_name, param1, param2_name, param2, param3_name, param3, param4_name, param4)
+#define SF_COMPONENT_DECLARE_EVENT5(category, eventname, param1_name, param1, param2_name, param2, param3_name, param3, param4_name, param4, param5_name, param5)
+#define SF_COMPONENT_DEFINE_EVENT(category, eventname)
+#define SF_COMPONENT_BROADCAST_EVENT( category, eventname, ... )
+
+#endif // if defined (USE_SCALEFORM_BINDINGS) || defined (TEST_SCALEFORM_EVENTS)
+
+
+#ifdef USE_SCALEFORM_BINDINGS
+#define SF_COMPONENT_FUNCTION_NAME( fnname ) UiComponentFunction_##fnname
+
+// Should match SCALEFORM_CALLBACK_ARGS_DECL in uiscaleform.h
+#define SF_DEFAULT_PARAMS_DECL IUIMarshalHelper* pui, SFPARAMS obj
+#define SF_DEFAULT_PARAMS_PASS pui, obj
+
+#define SF_COMPONENT_FUNCTION( returntype, fnname ) \
+	void SF_COMPONENT_FUNCTION_NAME(fnname)( SF_DEFAULT_PARAMS_DECL )
+
+#define SF_COMPONENT_FUNCTION_IMPL( classname, fnname ) \
+	void classname::SF_COMPONENT_FUNCTION_NAME(fnname)( SF_DEFAULT_PARAMS_DECL )
+
+#define SF_COMPONENT_FUNCTION_DELEGATE( ptrcomponent, fnname ) \
+	( ptrcomponent )->SF_COMPONENT_FUNCTION_NAME( fnname )( SF_DEFAULT_PARAMS_PASS )
+
+#define SF_COMPONENT_API_DEF_BEGIN( componentclass ) \
+	class componentclass##_Table : public IScaleformUIFunctionHandlerDefinitionTable \
+	{ \
+	public: \
+		virtual const ScaleformUIFunctionHandlerDefinition* GetTable( void ) const \
+		{ \
+			static const ScaleformUIFunctionHandlerDefinition fnTable[] = { 
+
+#define SF_COMPONENT_FUNCTION_API_DEF( returntype, fnname, componentclass ) \
+	{ #fnname, reinterpret_cast<ScaleformUIFunctionHandler>( &componentclass::SF_COMPONENT_FUNCTION_NAME( fnname ) ) }, 
+
+#define SF_COMPONENT_FUNCTION_API_DEF_NOPREFIX( returntype, fnname, componentclass ) \
+	{ #fnname, reinterpret_cast<ScaleformUIFunctionHandler>( &componentclass::fnname ) } 
+
+#define SF_COMPONENT_API_DEF_END( componentclass ) \
+					{ NULL, NULL } \
+			}; \
+			return fnTable; \
+		} \
+	}; \
+	static componentclass##_Table g_##componentclass##_Table; \
+	static SFVALUE g_##componentclass##_SFVALUE[SF_SLOT_IDS_COUNT];
+
+#define SF_COMPONENT_API_INSTALL( iSlot, componentclass, ptrInstance, componentname ) \
+	do { \
+		Assert( ( iSlot >= 0 ) && ( iSlot < SF_SLOT_IDS_COUNT ) ); \
+		g_pScaleformUI->InstallGlobalObject( iSlot, "CScaleformComponent_" #componentname, \
+		reinterpret_cast<ScaleformUIFunctionHandlerObject*>(static_cast<componentclass *>(ptrInstance)), \
+		&g_##componentclass##_Table, \
+			&g_##componentclass##_SFVALUE[iSlot] ); \
+		} while( 0 )
+
+#define SF_COMPONENT_API_REMOVE( iSlot, componentclass ) \
+	do { \
+		Assert( ( iSlot >= 0 ) && ( iSlot < SF_SLOT_IDS_COUNT ) ); \
+		g_pScaleformUI->RemoveGlobalObject( iSlot, g_##componentclass##_SFVALUE[iSlot] ); g_##componentclass##_SFVALUE[iSlot] = NULL; \
+		} while( 0 )
+
+#define SF_INTEGRATION_XUID_PARAM( xuidVarName, iParam ) const char * xuidVarName = 0; { \
+	if ( pui->Params_GetArgType( obj, iParam ) != IUIMarshalHelper::VT_String ) \
+		{ \
+		AssertMsg( 0, __FUNCTION__ "ActionScript passed a non string param for xuid!\n" ); \
+		return;\
+		} \
+	xuidVarName = ( pui->Params_GetArgAsString( obj, iParam ) ); \
+	}
+
+#define SF_INTEGRATION_ITEMID_PARAM( itemidVarName, iParam ) itemid_t itemidVarName = 0; { \
+	if ( pui->Params_GetArgType( obj, iParam ) != IUIMarshalHelper::VT_String ) \
+		{ \
+		AssertMsg( 0, __FUNCTION__ " ActionScript passed a non string param for item id!\n" ); \
+		return;\
+		} \
+	const char *pItemID = ( pui->Params_GetArgAsString( obj, iParam ) ); \
+	if ( !pItemID ) \
+		return; \
+	itemidVarName = (uint64) Q_atoi64( pItemID ) ; \
+			}
+
+#define SF_COMPONENT_NOTIFY_FLASH( category, eventname ) \
+	if ( FlashAPIIsValid() ) \
+				{ \
+		WITH_SLOT_LOCKED \
+																{ \
+			m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, SF_COMPONENT_EVENT_NAME( category, eventname ), NULL, 0 ); \
+																} \
+				}
+
+#define SF_COMPONENT_FORWARD_EVENT( szEvent ) \
+	if ( StringHasPrefix( szEvent, "ScaleformComponent_" ) ) \
+			{ \
+		if ( FlashAPIIsValid() ) \
+						{ \
+			WITH_SLOT_LOCKED \
+												{ \
+				m_pScaleformUI->Value_InvokeWithoutReturn( m_FlashAPI, szEvent, NULL, 0 ); \
+												} \
+						} \
+			}
+
+#define SF_COMPONENT_HOST_DECL() \
+	public: \
+		CScaleformComponentHostSupport_ImageCacheHelper m_CScaleformComponentHostSupport_ImageCacheHelper; \
+		void ScaleformComponentHost_EnsureAvatarCached( SF_DEFAULT_PARAMS_DECL ) \
+						{ \
+			SF_INTEGRATION_XUID_PARAM( xuidUser, 0 ); \
+			m_CScaleformComponentHostSupport_ImageCacheHelper.EnsureAvatarCached( xuidUser ); \
+						} \
+		void ScaleformComponentHost_EnsureInventoryImageCached( SF_DEFAULT_PARAMS_DECL ) \
+						{ \
+			SF_INTEGRATION_ITEMID_PARAM( itemID, 0 ); \
+			m_CScaleformComponentHostSupport_ImageCacheHelper.EnsureInventoryImageCached( itemID ); \
+						} \
+		void ScaleformComponentHost_EnsureItemDataImageCached( SF_DEFAULT_PARAMS_DECL ) \
+						{ \
+			uint16 iDefIndex = ( uint16 ) pui->Params_GetArgAsNumber( obj, 0 ); \
+			uint16 iPaintIndex = ( uint16 ) pui->Params_GetArgAsNumber( obj, 1 ); \
+			m_CScaleformComponentHostSupport_ImageCacheHelper.EnsureItemDataImageCached( iDefIndex, iPaintIndex ); \
+						} \
+		void ScaleformComponentHost_GetScaleformComponentEventParamString( SF_DEFAULT_PARAMS_DECL ) \
+						{ \
+			const char *pEventName = ( pui->Params_GetArgAsString( obj, 0 ) ); \
+			const char *pParamName = ( pui->Params_GetArgAsString( obj, 1 ) ); \
+			if ( !pEventName || !pParamName ) \
+				return; \
+			KeyValues *kvEventData = g_pMatchFramework->GetEventsSubscription()->GetEventData( pEventName ); \
+			if ( !kvEventData ) \
+				return; \
+			pui->Params_SetResult( obj, kvEventData->GetString( pParamName, "" ) ); \
+						} \
+
+#define SF_COMPONENT_HOST_IMAGE_CACHE_ENABLE( bEnable ) m_CScaleformComponentHostSupport_ImageCacheHelper.EnableCaching( bEnable )
+
+#define SF_COMPONENT_HOST_API_DEF() \
+					{ "EnsureAvatarCached", reinterpret_cast<ScaleformUIFunctionHandler>( &T::ScaleformComponentHost_EnsureAvatarCached )}, \
+					{ "EnsureInventoryImageCached", reinterpret_cast<ScaleformUIFunctionHandler>( &T::ScaleformComponentHost_EnsureInventoryImageCached )}, \
+					{ "EnsureItemDataImageCached", reinterpret_cast<ScaleformUIFunctionHandler>( &T::ScaleformComponentHost_EnsureItemDataImageCached )}, \
+					{ "GetScaleformComponentEventParamString", reinterpret_cast<ScaleformUIFunctionHandler>( &T::ScaleformComponentHost_GetScaleformComponentEventParamString )} \
+
+
+		// Registration of GC job handler for scaleform components
+#define SF_COMPONENT_GC_REG_JOB( gcclientclass, cjobclass, cmsgclass, gcmsgid, ccomponentclass, ccomponentfn ) \
+class cjobclass : public GCSDK::CGCClientJob \
+				{ \
+public: \
+	cjobclass( GCSDK::CGCClient *pGCClient ) : GCSDK::CGCClientJob( pGCClient ) { } \
+	virtual bool BYieldingRunJobFromMsg( GCSDK::IMsgNetPacket *pNetPacket ) \
+					{ \
+	GCSDK::CProtoBufMsg<cmsgclass> msg( pNetPacket ); \
+	ccomponentclass::GetInstance()->ccomponentfn( msg.Body() ); \
+	return true; \
+					} \
+				}; \
+GC_REG_CLIENT_JOB( cjobclass, gcmsgid );
+
+inline char const * HelperSfGetStringParamSafe(SF_DEFAULT_PARAMS_DECL, int iParam, char const *szDefault = NULL)
+{
+	if ((iParam >= 0)
+		&& (int(pui->Params_GetNumArgs(obj)) > iParam)
+		&& ( pui->Params_GetArgType( obj, iParam ) == IUIMarshalHelper::VT_String ) )
+		return pui->Params_GetArgAsString(obj, iParam);
+	else
+		return szDefault;
+}
+
+#else // USE_SCALEFORM_BINDINGS
+
+#define SF_COMPONENT_FUNCTION_NAME( fnname )
+#define SF_DEFAULT_PARAMS_DECL
+#define SF_DEFAULT_PARAMS_PASS
+#define SF_COMPONENT_FUNCTION( returntype, fnname )
+#define SF_COMPONENT_FUNCTION_IMPL( classname, fnname )
+#define SF_COMPONENT_FUNCTION_DELEGATE( ptrcomponent, fnname )
+#define SF_COMPONENT_API_DEF_BEGIN( componentclass )
+#define SF_COMPONENT_FUNCTION_API_DEF( returntype, fnname, componentclass )
+#define SF_COMPONENT_FUNCTION_API_DEF_NOPREFIX( returntype, fnname, componentclass )
+#define SF_COMPONENT_API_DEF_END( componentclass )
+#define SF_COMPONENT_API_INSTALL( iSlot, componentclass, ptrInstance )
+#define SF_COMPONENT_API_REMOVE( iSlot, componentclass )
+#define SF_INTEGRATION_XUID_PARAM( xuidVarName, iParam )
+#define SF_INTEGRATION_ITEMID_PARAM( itemidVarName, iParam ) 
+#define SF_COMPONENT_NOTIFY_FLASH( category, eventname )
+#define SF_COMPONENT_FORWARD_EVENT( szEvent )
+#define SF_COMPONENT_HOST_DECL()
+#define SF_COMPONENT_HOST_IMAGE_CACHE_ENABLE( bEnable )
+#define SF_COMPONENT_HOST_API_DEF()
+#define SF_COMPONENT_GC_REG_JOB( gcclientclass, cjobclass, cmsgclass, gcmsgid, ccomponentclass, ccomponentfn )
+
+#endif  // USE_SCALEFORM_BINDINGS
+
+
+#ifdef USE_PANORAMA_BINDINGS
+
+#define PANORAMA_COMPONENT_API_DEF_BEGIN( componentclass ) \
+void componentclass::JSRegisterFunc() \
+{ \
+
+#define PANORAMA_COMPONENT_FUNCTION_API_DEF_DOC( returntype, fnname, componentclass, argNames, description ) \
+	panorama::RegisterJSMethod( #fnname, &componentclass::fnname, description, argNames );
+
+#define PANORAMA_COMPONENT_FUNCTION_API_DEF( returntype, fnname, componentclass ) \
+	PANORAMA_COMPONENT_FUNCTION_API_DEF_DOC( returntype, fnname, componentclass, "", "" )
+
+#define PANORAMA_COMPONENT_FUNCTION_RAW_API_DEF_DOC( returntype, fnname, componentclass, description ) \
+	panorama::RegisterJSMethodRaw( #fnname, &componentclass::fnname, description );
+
+#define PANORAMA_COMPONENT_FUNCTION_RAW_API_DEF( returntype, fnname, componentclass ) \
+	PANORAMA_COMPONENT_FUNCTION_RAW_API_DEF_DOC( returntype, fnname, componentclass, "" )
+
+#define PANORAMA_COMPONENT_API_DEF_END( componentclass ) \
+}; \
+
+#define PANORAMA_COMPONENT_API_INSTALL( componentclass, ptrInstance, scriptVarName, description ) \
+	do { \
+		panorama::UIEngine()->StartRegisterJSScope( scriptVarName, description ); \
+		CUtlDelegate< void() > del( ptrInstance, &componentclass::JSRegisterFunc ); \
+		CUtlAbstractDelegate absDel = del.GetAbstractDelegate(); \
+		panorama::UIEngine()->ExposeObjectTypeToJavaScript( #componentclass, absDel ); \
+		panorama::UIEngine()->ExposeGlobalObjectToJavaScript(scriptVarName, ptrInstance, #componentclass, true); \
+		panorama::UIEngine()->EndRegisterJSScope(); \
+	} while (0)
+
+#define PANORAMA_COMPONENT_API_REMOVE( componentclass )
+
+#define PANORAMA_COMPONENT_EVENT_NAME( category, eventname ) PanoramaComponent_##category##_##eventname
+
+#define PANORAMA_COMPONENT_BROADCAST_EVENT( category, eventname, ... ) \
+	panorama::DispatchEvent(PANORAMA_COMPONENT_EVENT_NAME(category, eventname)(), NULL, ##__VA_ARGS__);
+
+#define PANORAMA_COMPONENT_BROADCAST_EVENT_WITH_PARAMS( category, eventname, ... ) \
+	panorama::DispatchEvent(PANORAMA_COMPONENT_EVENT_NAME(category, eventname)(), NULL, ##__VA_ARGS__);
+
+#define PANORAMA_COMPONENT_DECLARE_EVENT0( category, eventname ) \
+	DECLARE_PANORAMA_EVENT0(PANORAMA_COMPONENT_EVENT_NAME( category, eventname ))
+
+#define PANORAMA_COMPONENT_DECLARE_EVENT1( category, eventname, param1 ) \
+	DECLARE_PANORAMA_EVENT1(PANORAMA_COMPONENT_EVENT_NAME( category, eventname ), param1)
+
+#define PANORAMA_COMPONENT_DECLARE_EVENT2(category, eventname, param1, param2) \
+	DECLARE_PANORAMA_EVENT2(PANORAMA_COMPONENT_EVENT_NAME( category, eventname ), param1, param2)
+
+#define PANORAMA_COMPONENT_DECLARE_EVENT3(category, eventname, param1, param2, param3) \
+	DECLARE_PANORAMA_EVENT3(PANORAMA_COMPONENT_EVENT_NAME( category, eventname ), param1, param2, param3)
+
+#define PANORAMA_COMPONENT_DECLARE_EVENT4(category, eventname, param1, param2, param3, param4) \
+	DECLARE_PANORAMA_EVENT4(PANORAMA_COMPONENT_EVENT_NAME( category, eventname ), param1, param2, param3, param4)
+
+#define PANORAMA_COMPONENT_DECLARE_EVENT5(category, eventname, param1, param2, param3, param4, param5) \
+	DECLARE_PANORAMA_EVENT5(PANORAMA_COMPONENT_EVENT_NAME( category, eventname ), param1, param2, param3, param4, param5)
+
+#define PANORAMA_COMPONENT_DEFINE_EVENT(category, eventname)\
+	DEFINE_PANORAMA_EVENT(PANORAMA_COMPONENT_EVENT_NAME(category, eventname))
+
+#define PANORAMA_COMPONENT_MARSHALL_HELPER_FUNCTION_API_DEF( returntype, fnname, componentclass ) \
+	RegisterJSMethodWithMarshallHelper( #fnname, &componentclass::SF_COMPONENT_FUNCTION_NAME( fnname ) );
+
+#define PANORAMA_COMPONENT_MARSHALL_HELPER_FUNCTION_API_DEF_NOPREFIX( returntype, fnname, componentclass ) \
+	RegisterJSMethodWithMarshallHelper( #fnname, &componentclass::fnname );
+
+// Helper class to allow the existing component functions to take a common object for param/return val handling
+// Allows existing SF component code which expects multiple return types or to sometimes not return a value to remain unchanged and be
+// called by new panorama js code if needed.
+class CPanoramaMarshallHelper : public IUIMarshalHelper
+{
+public:
+	virtual SFVALUEARRAY Params_GetArgs( SFPARAMS params ) OVERRIDE;
+	virtual unsigned int Params_GetNumArgs( SFPARAMS params ) OVERRIDE;
+	virtual bool Params_ArgIs( SFPARAMS params, unsigned int index, _ValueType v ) OVERRIDE;
+	virtual SFVALUE Params_GetArg( SFPARAMS params, int index = 0 ) OVERRIDE;
+	virtual _ValueType Params_GetArgType( SFPARAMS params, int index = 0 ) OVERRIDE;
+	virtual double Params_GetArgAsNumber( SFPARAMS params, int index = 0 ) OVERRIDE;
+	virtual bool Params_GetArgAsBool( SFPARAMS params, int index = 0 ) OVERRIDE;
+	virtual const char* Params_GetArgAsString( SFPARAMS params, int index = 0 ) OVERRIDE;
+	virtual const wchar_t* Params_GetArgAsStringW( SFPARAMS params, int index = 0 ) OVERRIDE;
+
+	virtual void Params_DebugSpew( SFPARAMS params ) OVERRIDE;
+
+	virtual void Params_SetResult( SFPARAMS params, SFVALUE value ) OVERRIDE;
+	virtual void Params_SetResult( SFPARAMS params, int value ) OVERRIDE;
+	virtual void Params_SetResult( SFPARAMS params, float value ) OVERRIDE;
+	virtual void Params_SetResult( SFPARAMS params, bool value ) OVERRIDE;
+	virtual void Params_SetResult( SFPARAMS params, const char* value, bool bMakeNewValue = true ) OVERRIDE;
+	virtual void Params_SetResult( SFPARAMS params, const wchar_t* value, bool bMakeNewValue = true ) OVERRIDE;
+
+	virtual SFVALUE Params_CreateNewObject( SFPARAMS params ) OVERRIDE;
+	virtual SFVALUE Params_CreateNewString( SFPARAMS params, const char* value ) OVERRIDE;
+	virtual SFVALUE Params_CreateNewString( SFPARAMS params, const wchar_t* value ) OVERRIDE;
+	virtual SFVALUE Params_CreateNewArray( SFPARAMS params, int size = -1 ) OVERRIDE;
+private:
+	// Scratch storage for returning v8 string params. Grows to high water mark of param count. 
+	CUtlVector< CUtlString > m_vecStringStorage;
+};
+CPanoramaMarshallHelper *GetPanoramaMarshallHelper( void );
+
+template< typename ObjType >
+void JSMethodCallTupleWithMarshallHelper( const v8::FunctionCallbackInfo<v8::Value>& args )
+{
+	v8::Isolate::Scope isolate_scope( args.GetIsolate() );
+	v8::HandleScope handle_scope( args.GetIsolate() );
+
+	ObjType *pPanel = panorama::GetThisPtrForJSCall<ObjType>( args.Holder() );
+	if ( !pPanel )
+		return;
+
+	v8::Local<v8::Array> callbackArray = v8::Local<v8::Array>::Cast( args.Data() );
+
+	panorama::HACKY_FUNC_PTR_CASTER< void ( ObjType::* )( IUIMarshalHelper* pui, SFPARAMS obj ) > caster;
+	panorama::RestoreFuncPtr( caster, callbackArray, 0 );
+
+	( pPanel->*caster.funcPtr )( GetPanoramaMarshallHelper(), ( SFPARAMS ) &args );
+}
+
+template < typename ObjType >
+void RegisterJSMethodWithMarshallHelper( const char *pchMethodName, void ( ObjType::*mf )( IUIMarshalHelper* pui, SFPARAMS obj ), const char *pDesc = NULL )
+{
+	v8::Isolate::Scope isolate_scope( panorama::GetV8Isolate() );
+	v8::HandleScope handle_scope( panorama::GetV8Isolate() );
+
+	v8::Handle<v8::Array> callbackArray = v8::Array::New( panorama::GetV8Isolate(), V8_CALLBACK_ARRAY_SIZE );
+	panorama::GetPtrToCallbackArray( mf, callbackArray );
+
+	v8::Handle<v8::ObjectTemplate> objTemplate = panorama::UIEngine()->GetCurrentV8ObjectTemplateToSetup();
+	objTemplate->Set( v8::String::NewFromUtf8( panorama::GetV8Isolate(), pchMethodName ), v8::FunctionTemplate::New( panorama::GetV8Isolate(), &JSMethodCallTupleWithMarshallHelper<ObjType>, callbackArray ) );
+
+	int nEntry = panorama::UIEngine()->NewRegisterJSEntry( pchMethodName, panorama::RegisterJSEntryInfo_t::k_EMethod, pDesc, panorama::k_ERegisterJSTypeVoid );
+	panorama::RegisterJSType_t pParamTypes[ 1 ] = { panorama::k_ERegisterJSTypeRawV8Args };
+	panorama::UIEngine()->SetRegisterJSEntryParams( nEntry, 1, pParamTypes, NULL );
+}
+
+#else  // USE_PANORAMA_BINDINGS
+
+#define PANORAMA_COMPONENT_API_DEF_BEGIN( componentclass )
+#define PANORAMA_COMPONENT_FUNCTION_API_DEF( returntype, fnname, componentclass )
+#define PANORAMA_COMPONENT_FUNCTION_API_DEF_DOC( returntype, fnname, componentclass, argNames, description )
+#define PANORAMA_COMPONENT_FUNCTION_RAW_API_DEF( returntype, fnname, componentclass )
+#define PANORAMA_COMPONENT_FUNCTION_RAW_API_DEF_DOC( returntype, fnname, componentclass, description )
+#define PANORAMA_COMPONENT_API_DEF_END( componentclass )
+#define PANORAMA_COMPONENT_API_INSTALL( componentclass, ptrInstance, scriptVarName, description )
+#define PANORAMA_COMPONENT_API_REMOVE( componentclass )
+#define PANORAMA_COMPONENT_EVENT_NAME( category, eventname ) 
+#define PANORAMA_COMPONENT_BROADCAST_EVENT( category, eventname, ... )
+#define PANORAMA_COMPONENT_BROADCAST_EVENT_WITH_PARAMS( category, eventname, ... )
+#define PANORAMA_COMPONENT_DECLARE_EVENT0( category, eventname )
+#define PANORAMA_COMPONENT_DECLARE_EVENT1( category, eventname, param1 )
+#define PANORAMA_COMPONENT_DECLARE_EVENT2(category, eventname, param1, param2)
+#define PANORAMA_COMPONENT_DECLARE_EVENT3(category, eventname, param1, param2, param3)
+#define PANORAMA_COMPONENT_DECLARE_EVENT4(category, eventname, param1, param2, param3, param4)
+#define PANORAMA_COMPONENT_DECLARE_EVENT5(category, eventname, param1, param2, param3, param4, param5)
+#define PANORAMA_COMPONENT_DEFINE_EVENT(category, eventname)
+#define PANORAMA_COMPONENT_MARSHALL_HELPER_FUNCTION_API_DEF( returntype, fnname, componentclass )
+#define PANORAMA_COMPONENT_MARSHALL_HELPER_FUNCTION_API_DEF_NOPREFIX( returntype, fnname, componentclass )
+
+#endif  // USE_PANORAMA_BINDINGS
+
+// 7ls - revisit shutdown code
+#define UI_COMPONENT_API_DEF_COMMON_DOC( componentclass, scriptVarName, description ) \
+	void componentclass::InstallScaleformBindings(int iSlot) \
+	{ \
+		SF_COMPONENT_API_INSTALL(iSlot, componentclass, this, scriptVarName); \
+	} \
+	void componentclass::InstallPanoramaBindings() \
+	{ \
+		PANORAMA_COMPONENT_API_INSTALL(componentclass, this, #scriptVarName, description); \
+	} \
+	void componentclass::ShutdownComponentApiDef(int iSlot) \
+	{ \
+		SF_COMPONENT_API_REMOVE(iSlot, componentclass); \
+		PANORAMA_COMPONENT_API_REMOVE(componentclass); \
+	}
+
+#define UI_COMPONENT_API_DEF_COMMON( componentclass, scriptVarName ) \
+	UI_COMPONENT_API_DEF_COMMON_DOC( componentclass, scriptVarName, "" )
+
+#define UI_COMPONENT_BROADCAST_EVENT( category, eventname, ... ) \
+SF_COMPONENT_BROADCAST_EVENT( category, eventname, ##__VA_ARGS__ ) \
+PANORAMA_COMPONENT_BROADCAST_EVENT( category, eventname, ##__VA_ARGS__ )
+
+#define UI_COMPONENT_DECLARE_EVENT0( category, eventname ) \
+PANORAMA_COMPONENT_DECLARE_EVENT0( category, eventname ) \
+SF_COMPONENT_DECLARE_EVENT0( category, eventname )
+
+#define UI_COMPONENT_DECLARE_EVENT1( category, eventname, param1_name, param1 ) \
+PANORAMA_COMPONENT_DECLARE_EVENT1( category, eventname, param1 ) \
+SF_COMPONENT_DECLARE_EVENT1( category, eventname, param1_name, param1 )
+
+#define UI_COMPONENT_DECLARE_EVENT2( category, eventname, param1_name, param1, param2_name, param2 ) \
+PANORAMA_COMPONENT_DECLARE_EVENT2( category, eventname, param1, param2 ) \
+SF_COMPONENT_DECLARE_EVENT2( category, eventname, param1_name, param1, param2_name, param2 )
+
+#define UI_COMPONENT_DECLARE_EVENT3( category, eventname, param1_name, param1, param2_name, param2, param3_name, param3 ) \
+PANORAMA_COMPONENT_DECLARE_EVENT3( category, eventname, param1, param2, param3 ) \
+SF_COMPONENT_DECLARE_EVENT3( category, eventname, param1_name, param1, param2_name, param2, param3_name, param3 )
+
+#define UI_COMPONENT_DECLARE_EVENT4( category, eventname, param1_name, param1, param2_name, param2, param3_name, param3, param4_name, param4 ) \
+PANORAMA_COMPONENT_DECLARE_EVENT4( category, eventname, param1, param2, param3, param4 ) \
+SF_COMPONENT_DECLARE_EVENT4( category, eventname, param1_name, param1, param2_name, param2, param3_name, param3, param4_name, param4 )
+
+#define UI_COMPONENT_DECLARE_EVENT5( category, eventname, param1_name, param1, param2_name, param2, param3_name, param3, param4_name, param4, param5_name, param5 ) \
+PANORAMA_COMPONENT_DECLARE_EVENT5( category, eventname, param1, param2, param3, param4, param5 ) \
+SF_COMPONENT_DECLARE_EVENT5( category, eventname, param1_name, param1, param2_name, param2, param3_name, param3, param4_name, param4, param5_name, param5 )
+
+#define UI_COMPONENT_DEFINE_EVENT( category, eventname )\
+PANORAMA_COMPONENT_DEFINE_EVENT( category, eventname )\
+SF_COMPONENT_DEFINE_EVENT( category, eventname )
+
+
+// Only register Panorama cplusplus event handlers if not using Scaleform
+// (Otherwise handlers will be called twice) 
+#if (defined (USE_PANORAMA_BINDINGS ) && !(defined (USE_SCALEFORM_BINDINGS) || defined (TEST_SCALEFORM_EVENTS)))
+
+#define UI_COMPONENT_REGISTER_EVENT_HANDLER(category, eventname, pObj, methodptr) \
+	RegisterForUnhandledEvent( PANORAMA_COMPONENT_EVENT_NAME(category, eventname)(), pObj, methodptr );
+
+#else
+
+#define UI_COMPONENT_REGISTER_EVENT_HANDLER(category, eventname, pObj, methodptr)
+
+#endif
+
+#define UI_INTEGRATION_XUID_PARAM( xuidVarName, iParam ) XUID xuidVarName = 0; { \
+	if ( pui->Params_GetArgType( obj, iParam ) != IScaleformUI::VT_String ) \
+					{ \
+		AssertMsg1( 0, "%s UI code passed a non string param for xuid!\n", __FUNCTION__ ); \
+		DevMsg( " error: Passed non-string param to %s for param %d.\n", __FUNCTION__, iParam ); \
+		pui->Params_DebugSpew( obj ); \
+		return;\
+			} \
+	const char *pFriendXuid = ( pui->Params_GetArgAsString( obj, iParam ) ); \
+	if ( !pFriendXuid ) \
+			{ \
+		/*AssertMsg( 0, __FUNCTION__ " passed an invalid xuid!\n" );*/ \
+			} \
+	CSteamID friendId( (uint64) Q_atoi64( pFriendXuid ) ); \
+	if ( !friendId.IsValid() || !friendId.BIndividualAccount() ) \
+			{ \
+		/*AssertMsg( 0, __FUNCTION__ " passed an invalid xuid!\n" );*/ \
+		xuidVarName = 0; \
+			} \
+				else \
+				{ \
+		xuidVarName = friendId.ConvertToUint64(); \
+				} \
+				}
+
+// Registration of GC job handler for ui component
+#define UI_COMPONENT_GC_REG_JOB( gcclientclass, cjobclass, cmsgclass, gcmsgid, ccomponentclass, ccomponentfn ) \
+class cjobclass : public GCSDK::CGCClientJob \
+{ \
+public: \
+	explicit cjobclass( GCSDK::CGCClient *pGCClient ) : GCSDK::CGCClientJob( pGCClient ) { } \
+	virtual bool BYieldingRunJobFromMsg( GCSDK::IMsgNetPacket *pNetPacket ) \
+				{ \
+	GCSDK::CProtoBufMsg<cmsgclass> msg( pNetPacket ); \
+	ccomponentclass::GetInstance()->ccomponentfn( msg.Body() ); \
+	return true; \
+				} \
+}; \
+GC_REG_CLIENT_JOB( cjobclass, gcmsgid );
+
+
+// Function decl/impl helpers for ui component code that will be called by scaleform and/or javascript
+#define UI_COMPONENT_FUNCTION_NAME( fnname ) UiComponentFunction_##fnname
+#define UI_DEFAULT_PARAMS_DECL IUIMarshalHelper* pui, SFPARAMS obj
+#define UI_DEFAULT_PARAMS_PASS pui, obj
+
+#define UI_COMPONENT_FUNCTION( returntype, fnname ) \
+	void UI_COMPONENT_FUNCTION_NAME(fnname)( UI_DEFAULT_PARAMS_DECL )
+
+#define UI_COMPONENT_FUNCTION_IMPL( classname, fnname ) \
+	void classname::UI_COMPONENT_FUNCTION_NAME(fnname)( UI_DEFAULT_PARAMS_DECL )
+
+inline char const * HelperUiGetStringParamSafe( UI_DEFAULT_PARAMS_DECL, int iParam, char const *szDefault = NULL )
+{
+	if ( ( iParam >= 0 )
+		&& ( int( pui->Params_GetNumArgs( obj ) ) > iParam )
+		&& ( pui->Params_GetArgType( obj, iParam ) == IScaleformUI::VT_String ) )
+		return pui->Params_GetArgAsString( obj, iParam );
+	else
+		return szDefault;
+}
+
+// Convert keyvalues to a json formatted string
+bool Helper_RecursiveKeyValuesToJSONString( const KeyValues* pKV, CUtlBuffer &outBuffer );
+
+#endif // UICOMPONENT_COMMON_H