1HEADmaster

1 files changed, 1793 insertions, 0 deletions

diff --git a/public/panorama/uievent.h b/public/panorama/uievent.h
new file mode 100644
index 0000000..d355fd6
--- /dev/null
+++ b/public/panorama/uievent.h
@@ -0,0 +1,1793 @@
+
+//=========== Copyright Valve Corporation, All rights reserved. ===============//
+//
+// Purpose: 
+//=============================================================================//
+
+#ifndef UIEVENT_H
+#define UIEVENT_H
+#pragma once
+
+#include "tier1/utlsymbol.h"
+#include "tier1/utldelegate.h"
+#include "controls/panelhandle.h"
+#include "controls/panelptr.h"
+#include "iuipanel.h"
+#include "iuipanelclient.h"
+#include "tier1/fmtstr.h"
+#include "panoramacxx.h"
+
+// Strict template usage is just a dev-time convenience
+// for finding missing template specializations.
+// It should never be enabled by default as there are
+// types that do not have or need template support by-design.
+#if 0
+#define PANORAMA_STRICT_EVENT_TEMPLATE_USAGE
+#endif
+#if 0
+#define PANORAMA_STRICT_V8_TEMPLATE_USAGE
+#endif
+#if defined(PANORAMA_STRICT_EVENT_TEMPLATE_USAGE) || defined(PANORAMA_STRICT_V8_TEMPLATE_USAGE)
+#define PANORAMA_ANY_STRICT_EVENT_TEMPLATE_USAGE
+#endif
+
+namespace panorama
+{
+
+
+extern void RegisterEventTypesWithEngine( IUIEngine *pEngine );
+
+#ifdef DBGFLAG_VALIDATE
+void ValidateGlobalEvents( CValidator &validator );
+#endif
+
+inline bool IsEndOfUIEventString( const char *pchEvent, const char **pchEndOfEvent )
+{
+	{
+		while( pchEvent[0] != '\0' && pchEvent[0] != ')' )
+		{
+			if( !V_isspace( pchEvent[0] ) )
+				return false;
+
+			pchEvent++;
+		}
+
+		if( pchEvent[0] == ')' )
+			++pchEvent;
+
+		*pchEndOfEvent = pchEvent;
+
+		return true;
+	}
+}
+class IUIEvent;
+
+inline v8::Isolate *GetV8Isolate() { return UIEngine()->GetV8Isolate(); }
+
+inline const char *GetPanelID( const panorama::IUIPanel *pPanel ) { return pPanel->GetID(); }
+
+//-----------------------------------------------------------------------------
+// Purpose: Helpers to create an event from string
+//-----------------------------------------------------------------------------
+template < typename T >
+bool ParseUIEventParam( T *pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam )
+{
+#ifdef PANORAMA_STRICT_EVENT_TEMPLATE_USAGE
+	TEMPLATE_USAGE_INVALID( T );
+#else
+	AssertMsg( false, "ParseUIEventParam not implemented for type" );
+	// Zero-fill so that the compiler doesn't complain about use
+	// of uninitialized data, even though this code path is not functional.
+	memset( pOut, 0, sizeof(*pOut) );
+	return false;
+#endif
+}
+
+template <> bool ParseUIEventParam< const char * >( const char **pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+template <> bool ParseUIEventParam< uint8 >( uint8 *pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+template <> bool ParseUIEventParam< uint16 >( uint16 *pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+template <> bool ParseUIEventParam< uint32 >( uint32 *pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+template <> bool ParseUIEventParam< uint64 >( uint64 *pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+template <> bool ParseUIEventParam< int32 >( int32 *pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+template <> bool ParseUIEventParam< int64 >( int64 *pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+template <> bool ParseUIEventParam< float >( float *pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+template <> bool ParseUIEventParam< bool >( bool *pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+template <> bool ParseUIEventParam< IUIEvent * >( IUIEvent **pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+template <> bool ParseUIEventParam< panorama::EPanelEventSource_t >( panorama::EPanelEventSource_t *pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+template <> bool ParseUIEventParam< panorama::ScrollBehavior_t >( panorama::ScrollBehavior_t *pOut, panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchNextParam );
+
+int CountUIEventParams( const char *pchParams );
+bool ParseUIEventParamHelper( CUtlBuffer &bufValue, const char *pchEvent, const char **pchNextParam );
+bool IsEndOfUIEventString( const char *pchEvent, const char **pchEndOfEvent );
+
+//-----------------------------------------------------------------------------
+// Purpose: Helpers to turn event params in JS params
+//-----------------------------------------------------------------------------
+
+// Default, complain not implemented!
+template < typename T > typename panorama_enable_if< !panorama_is_enum< T >::value, void>::type 
+PanoramaTypeToV8Param( T &pIn, v8::Handle<v8::Value> *pValueOut )
+{
+#ifdef PANORAMA_STRICT_V8_TEMPLATE_USAGE
+	TEMPLATE_USAGE_INVALID( T );
+#else
+	AssertMsg( false, "EventParamToV8Param not implemented for type" );
+#endif
+}
+
+// Default for enum types
+template < typename T > typename panorama_enable_if< panorama_is_enum< T >::value, void>::type
+PanoramaTypeToV8Param( T &pIn, v8::Handle<v8::Value> *pValueOut )
+{
+	COMPILE_TIME_ASSERT( sizeof( pIn ) <= sizeof( int32 ) );
+	int32 iVal = (int32)pIn;
+	return PanoramaTypeToV8Param<int32>( iVal, pValueOut );
+}
+
+// Basic non pointer specializations
+template <> void PanoramaTypeToV8Param< CUtlSymbol >( CUtlSymbol &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< panorama::CPanoramaSymbol >( panorama::CPanoramaSymbol &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< uint32 >( uint32 &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< uint64 >( uint64 &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< int32 >( int32 &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< int64 >( int64 &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< float >( float &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< double >( double &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< bool >( bool &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< CUtlVector< IUIPanel * > const >( CUtlVector< IUIPanel * > const &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< panorama::EPanelEventSource_t >( panorama::EPanelEventSource_t &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< v8::Local<v8::Value> >( v8::Local<v8::Value> &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< v8::Local<v8::Object> >( v8::Local<v8::Object> &pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param< v8::Local<v8::Array> >( v8::Local<v8::Array> &pIn, v8::Handle<v8::Value> *pValueOut );
+
+// Helper for specific pointer types we have special handling for via rules in the base T* specialization
+void PanoramaTypeToV8ParamJSObject( IUIJSObject *pJSObj, void *pIn, v8::Handle<v8::Value> *pValueOut );
+void PanoramaPanelTypeToV8Param( IUIPanel * &pIn, v8::Handle<v8::Value> *pValueOut );
+void PanoramaPanelStyleTypeToV8Param( IUIPanelStyle * &pIn, v8::Handle<v8::Value> *pValueOut );
+
+// Template overload for ptr types, so we can see if we should turn into base CPanel2D, or other special known types,
+// otherwise we'll call PanoramaPtrTypeToV8ParamJSObject and let the specialization rules figure it out
+template < typename T >
+void PanoramaTypeToV8Param( T * pIn, v8::Handle<v8::Value> *pValueOut )
+{
+	if( panorama_is_base_of< IUIPanelClient, T >::value )
+	{
+		IUIPanel *pPanel = pIn ? ( (IUIPanelClient*)pIn )->UIPanel() : NULL;
+		return PanoramaPanelTypeToV8Param( pPanel, pValueOut );
+	}
+	else if( panorama_is_base_of< IUIPanel, T >::value )
+	{
+		IUIPanel *pPanel = (IUIPanel*)pIn;
+		return PanoramaPanelTypeToV8Param( pPanel, pValueOut );
+	}
+	else if( panorama_is_base_of< IUIPanelStyle, T >::value )
+	{
+		IUIPanelStyle *pPanel = (IUIPanelStyle*)pIn;
+		return PanoramaPanelStyleTypeToV8Param( pPanel, pValueOut );
+	}
+	else if( panorama_is_base_of< IUIJSObject, T>::value )
+	{
+		IUIJSObject *pObject = (IUIJSObject*)pIn;
+		return PanoramaTypeToV8ParamJSObject( pObject, (void*)pIn, pValueOut );
+	}
+
+	AssertMsg( false, "PanoramaTypeToV8Param not implemented for type" );
+}
+
+// Specialization of above ptr overload
+template <> void PanoramaTypeToV8Param<const char>( const char * pIn, v8::Handle<v8::Value> *pValueOut );
+template <> void PanoramaTypeToV8Param<char>( char * pIn, v8::Handle<v8::Value> *pValueOut );
+
+// bugbug jmccaskey - add IUIEvent, panel source, panel2d? more?
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Helpers to turn JS params into native params
+//-----------------------------------------------------------------------------
+template < typename T >
+void V8ParamToPanoramaType( const v8::Handle<v8::Value> &pValueIn, T *out )
+{
+#ifdef PANORAMA_STRICT_V8_TEMPLATE_USAGE
+	TEMPLATE_USAGE_INVALID( T );
+#else
+	AssertMsg( false, "V8ParamToPanoramaType not implemented for type" );
+#endif
+}
+template <> void V8ParamToPanoramaType< const char *>( const v8::Handle<v8::Value> &pValueIn, const char ** out );
+template <> void V8ParamToPanoramaType< CUtlSymbol >( const v8::Handle<v8::Value> &pValueIn, CUtlSymbol* out );
+template <> void V8ParamToPanoramaType< panorama::CPanoramaSymbol >( const v8::Handle<v8::Value> &pValueIn, panorama::CPanoramaSymbol* out );
+template <> void V8ParamToPanoramaType< float >( const v8::Handle<v8::Value> &pValueIn, float *out );
+template <> void V8ParamToPanoramaType< double >( const v8::Handle<v8::Value> &pValueIn, double *out );
+template <> void V8ParamToPanoramaType< int >( const v8::Handle<v8::Value> &pValueIn, int *out );
+template <> void V8ParamToPanoramaType< uint >( const v8::Handle<v8::Value> &pValueIn, uint *out );
+template <> void V8ParamToPanoramaType< bool >( const v8::Handle<v8::Value> &pValueIn, bool *out );
+template <> void V8ParamToPanoramaType< IUIPanel * >( const v8::Handle<v8::Value> &pValueIn, IUIPanel **out );
+#ifndef PANORAMA_EXPORTS
+template <> void V8ParamToPanoramaType< CPanel2D * >( const v8::Handle<v8::Value> &pValueIn, CPanel2D **out );
+#endif
+template <> void V8ParamToPanoramaType< IUIPanelStyle * >( const v8::Handle<v8::Value> &pValueIn, IUIPanelStyle **out );
+#ifdef PANORAMA_EXPORTS
+template <> void V8ParamToPanoramaType< CPanelStyle * >( const v8::Handle<v8::Value> &pValueIn, CPanelStyle **out );
+#endif
+template <> void V8ParamToPanoramaType< v8::Persistent<v8::Function> * >( const v8::Handle<v8::Value> &pValueIn, v8::Persistent<v8::Function> **out );
+template <> void V8ParamToPanoramaType< CUtlVector< IUIPanel *> >( const v8::Handle<v8::Value> &pValueIn, CUtlVector< IUIPanel *>*out );
+template <> void V8ParamToPanoramaType< v8::Local<v8::Value> >( const v8::Handle<v8::Value> &pValueIn, v8::Local<v8::Value> *out );
+template <> void V8ParamToPanoramaType< v8::Local<v8::Object> >( const v8::Handle<v8::Value> &pValueIn, v8::Local<v8::Object> *out );
+template <> void V8ParamToPanoramaType< v8::Local<v8::Array> >( const v8::Handle<v8::Value> &pValueIn, v8::Local<v8::Array> *out );
+
+template <typename T> void FreeConvertedParam(T out) {  }
+template <> void FreeConvertedParam< const char *>( const char *out );
+template <> void FreeConvertedParam< v8::Persistent<v8::Function> *>( v8::Persistent<v8::Function> *out );
+
+//-----------------------------------------------------------------------------
+// Purpose: Wrappers to handle copying params. const char * is specialized to dup the string
+//-----------------------------------------------------------------------------
+template < class T >
+void UIEventSet( T* pTo, T &pFrom )
+{
+	*pTo = pFrom;
+}
+
+template <>
+void UIEventSet( const char** pTo, const char *&pFrom );
+
+
+template <>
+void UIEventSet( IUIEvent** pTo, IUIEvent *&pFrom );
+
+
+template <>
+void UIEventSet( v8::Persistent<v8::Function>** pTo, v8::Persistent<v8::Function> *&pFrom );
+
+template < class T >
+void UIEventFree( T &p )
+{
+}
+
+template <>
+void UIEventFree( const char *& p );
+
+
+template <>
+void UIEventFree( IUIEvent *& p );
+
+template <>
+void UIEventFree( v8::Persistent<v8::Function> *&p );
+
+#ifdef DBGFLAG_VALIDATE
+
+template < class T >
+void UIEventValidate( CValidator &validator, T &p )
+{
+}
+
+template <>
+void UIEventValidate( CValidator &validator, const char *& p );
+
+
+template <>
+void UIEventValidate( CValidator &validator, IUIEvent *& p );
+
+template <>
+void UIEventValidate( CValidator &validator, v8::Persistent<v8::Function> *& p );
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Macros to declare a event
+//			Includes Register/Unregister calls to enforce type safety
+//-----------------------------------------------------------------------------
+
+//
+// Events with 0 params
+//
+namespace UIEvent
+{
+	template < class T >
+	IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchEventEnd  )
+	{
+		if ( !IsEndOfUIEventString( pchEvent, &pchEvent ) )
+			return NULL;
+
+		*pchEventEnd = pchEvent;
+		IUIEvent *pEvent = T::MakeEvent( pPanel ? pPanel->ClientPtr() : NULL );
+		return pEvent;
+	}
+}
+
+
+#define DECLARE_PANORAMA_EVENT0( name ) \
+	class  name \
+	{ \
+	public: \
+		static const int cParams = 0; static const bool bPanelEvent = false; static panorama::CPanoramaSymbol symbol; static const char *pchEvent;\
+		static panorama::CPanoramaSymbol GetEventType() { Assert( symbol.IsValid() ); return symbol; } \
+		static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget ) { return new panorama::CUIEvent0( symbol, pTarget ? pTarget->UIPanel() : NULL ); } \
+		static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd  ) { return panorama::UIEvent::CreateEventFromString< name >( pPanel, pchEventCreate, pchEventEnd ); } \
+	}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T *pHandlerPanel, bool (U::*memberfunc)() ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pHandlerPanel, UtlMakeDelegate( pHandlerPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pHandlerPanel, bool (U::*memberfunc)() ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pHandlerPanel, UtlMakeDelegate( pHandlerPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)() ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)() ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pHandlerObj, bool (U::*memberfunc)() ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pHandlerObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pHandlerObj, bool (U::*memberfunc)() ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pHandlerObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool (PanelType::*memberfunc)() ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+#define DECLARE_PANEL_EVENT0( name ) \
+class  name \
+	{ \
+	public: \
+		static const int cParams = 0; static const bool bPanelEvent = true; static panorama::CPanoramaSymbol symbol; static const char *pchEvent;\
+		static panorama::CPanoramaSymbol GetEventType() { Assert( symbol.IsValid() ); return symbol; } \
+		static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget ) { return new panorama::CUIPanelEvent0( symbol, pTarget ? pTarget->UIPanel() : NULL ); } \
+		static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd  ) { return panorama::UIEvent::CreateEventFromString< name >( pPanel, pchEventCreate, pchEventEnd ); } \
+	}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T * pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > & ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > & ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T * pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > & ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > & ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > & ) ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > & ) ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool( PanelType::*memberfunc )( const panorama::CPanelPtr< panorama::IUIPanel > & ) ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+//
+// Events with 1 params
+//
+namespace UIEvent
+{
+	template < class T, typename param1 >
+	IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchEventEnd  )
+	{
+		param1 p1;
+		if ( !ParseUIEventParam< param1 >( &p1, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		if ( !IsEndOfUIEventString( pchEvent, &pchEvent ) )
+			return NULL;
+
+		*pchEventEnd  = pchEvent;
+
+		IUIEvent *pEvent = T::MakeEvent( pPanel ? pPanel->ClientPtr() : NULL, p1 );
+		UIEventFree( p1 );
+		return pEvent;
+	}
+}
+
+#define DECLARE_PANORAMA_EVENT1( name, param1 ) \
+	class  name \
+	{ \
+	public: \
+		typedef param1 TypenameParam1; static const int cParams = 1; static const bool bPanelEvent = false; static panorama::CPanoramaSymbol symbol; static const char *pchEvent;\
+		static panorama::CPanoramaSymbol GetEventType() { Assert( symbol.IsValid() ); return symbol; } \
+		static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget, param1 p1 ) { return new panorama::CUIEvent1< param1 >( symbol, pTarget ? pTarget->UIPanel() : NULL, p1 ); } \
+		static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd  ) { return panorama::UIEvent::CreateEventFromString< name, param1 >( pPanel, pchEventCreate, pchEventEnd ); } \
+	}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( param1 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( param1 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel->UIPanel(), UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( param1 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( param1 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( param1 ) ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( param1 ) ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool( PanelType::*memberfunc )( param1 ) ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+
+#define DECLARE_PANEL_EVENT1( name, param1 ) \
+class  name \
+	{ \
+	public: \
+		typedef param1 TypenameParam1; static const int cParams = 1; static const bool bPanelEvent = true; static panorama::CPanoramaSymbol symbol; static const char *pchEvent;\
+		static panorama::CPanoramaSymbol GetEventType() { Assert( symbol.IsValid() ); return symbol; } \
+		static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget, param1 p1 ) { return new panorama::CUIPanelEvent1< param1 >( symbol, pTarget ? pTarget->UIPanel() : NULL, p1 ); } \
+		static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd ) { return panorama::UIEvent::CreateEventFromString< name, param1 >( pPanel, pchEventCreate, pchEventEnd ); } \
+	}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel->UIPanel(), UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1 ) ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1 ) ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool( PanelType::*memberfunc )( const panorama::CPanelPtr< panorama::IUIPanel > &, param1 ) ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+
+//
+// Events with 2 params
+//
+namespace UIEvent
+{
+	template < class T, typename param1, typename param2 >
+	IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchEventEnd )
+	{
+		param1 p1;
+		if ( !ParseUIEventParam< param1 >( &p1, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		param2 p2;
+		if ( !ParseUIEventParam< param2 >( &p2, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		if ( !IsEndOfUIEventString( pchEvent, &pchEvent ) )
+			return NULL;
+
+		*pchEventEnd = pchEvent;
+		IUIEvent *pEvent = T::MakeEvent( pPanel ? pPanel->ClientPtr() : NULL, p1, p2 );
+		UIEventFree( p1 );
+		UIEventFree( p2 );
+		return pEvent;
+	}
+}
+
+#define DECLARE_PANORAMA_EVENT2( name, param1, param2 ) \
+	class  name \
+	{ \
+	public: \
+		typedef param1 TypenameParam1; typedef param2 TypenameParam2; static const int cParams = 2; static const bool bPanelEvent = false; static panorama::CPanoramaSymbol symbol; static const char *pchEvent;\
+		static panorama::CPanoramaSymbol GetEventType() { Assert( symbol.IsValid() ); return symbol; } \
+		static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget, param1 p1, param2 p2 ) { return new panorama::CUIEvent2< param1, param2 >( symbol, pTarget ? pTarget->UIPanel() : NULL, p1, p2 ); } \
+		static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd ) { return panorama::UIEvent::CreateEventFromString< name, param1, param2 >( pPanel, pchEventCreate, pchEventEnd ); } \
+	}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( param1, param2 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( param1, param2 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( param1, param2 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( param1, param2 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( param1, param2 ) ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( param1, param2 ) ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool( PanelType::*memberfunc )( param1, param2 ) ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+
+#define DECLARE_PANEL_EVENT2( name, param1, param2 ) \
+	class  name \
+	{ \
+	public: \
+		typedef param1 TypenameParam1; typedef param2 TypenameParam2; static const int cParams = 2; static const bool bPanelEvent = true; static panorama::CPanoramaSymbol symbol; static const char *pchEvent;\
+		static panorama::CPanoramaSymbol GetEventType() { Assert( symbol.IsValid() ); return symbol; } \
+		static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget, param1 p1, param2 p2 ) { return new panorama::CUIPanelEvent2< param1, param2 >( symbol, pTarget ? pTarget->UIPanel() : NULL, p1, p2 ); } \
+		static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd ) { return panorama::UIEvent::CreateEventFromString< name, param1, param2 >( pPanel, pchEventCreate, pchEventEnd ); } \
+	}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2 ) ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2 ) ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool( PanelType::*memberfunc )( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2 ) ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+//
+// Events with 3 params
+//
+namespace UIEvent
+{
+	template < class T, typename param1, typename param2, typename param3 >
+	IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchEventEnd )
+	{
+		param1 p1;
+		if ( !ParseUIEventParam< param1 >( &p1, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		param2 p2;
+		if ( !ParseUIEventParam< param2 >( &p2, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		param3 p3;
+		if ( !ParseUIEventParam< param3 >( &p3, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		if ( !IsEndOfUIEventString( pchEvent, &pchEvent ) )
+			return NULL;
+
+		*pchEventEnd = pchEvent;
+
+		IUIEvent *pEvent = T::MakeEvent( pPanel ? pPanel->ClientPtr() : NULL, p1, p2, p3 );
+		UIEventFree( p1 );
+		UIEventFree( p2 );
+		UIEventFree( p3 );
+		return pEvent;
+	}
+}
+
+#define DECLARE_PANORAMA_EVENT3( name, param1, param2, param3 ) \
+class  name \
+	{ \
+	public: \
+		typedef param1 TypenameParam1; typedef param2 TypenameParam2; typedef param3 TypenameParam3; static const int cParams = 3; static const bool bPanelEvent = false; static panorama::CPanoramaSymbol symbol; static const char *pchEvent; \
+		static panorama::CPanoramaSymbol GetEventType() { Assert( symbol.IsValid() ); return symbol; } \
+		static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget, param1 p1, param2 p2, param3 p3 ) { return new panorama::CUIEvent3< param1, param2, param3 >( symbol, pTarget ? pTarget->UIPanel() : NULL, p1, p2, p3 ); } \
+		static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd ) { return panorama::UIEvent::CreateEventFromString< name, param1, param2, param3 >( pPanel, pchEventCreate, pchEventEnd ); } \
+	}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( param1, param2, param3 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( param1, param2, param3 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( param1, param2, param3 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( param1, param2, param3 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( param1, param2, param3 ) ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( param1, param2, param3 ) ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool( PanelType::*memberfunc )( param1, param2, param3 ) ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+
+#define DECLARE_PANEL_EVENT3( name, param1, param2, param3 ) \
+	class  name \
+	{ \
+	public: \
+		typedef param1 TypenameParam1; typedef param2 TypenameParam2; typedef param3 TypenameParam3; static const int cParams = 3; static const bool bPanelEvent = true; static panorama::CPanoramaSymbol symbol; static const char *pchEvent;\
+		static panorama::CPanoramaSymbol GetEventType() { Assert( symbol.IsValid() ); return symbol; } \
+		static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget, param1 p1, param2 p2, param3 p3  ) { return new panorama::CUIPanelEvent3< param1, param2, param3 >( symbol, pTarget ? pTarget->UIPanel() : NULL, p1, p2, p3 ); } \
+		static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd ) { return panorama::UIEvent::CreateEventFromString< name, param1, param2, param3 >( pPanel, pchEventCreate, pchEventEnd ); } \
+	}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3 ) ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3 ) ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool( PanelType::*memberfunc )( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3 ) ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+
+//
+// Events with 4 params
+//
+namespace UIEvent
+{
+	template < class T, typename param1, typename param2, typename param3, typename param4 >
+	IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchEventEnd )
+	{
+		param1 p1;
+		if ( !ParseUIEventParam< param1 >( &p1, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		param2 p2;
+		if ( !ParseUIEventParam< param2 >( &p2, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		param3 p3;
+		if ( !ParseUIEventParam< param3 >( &p3, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		param4 p4;
+		if ( !ParseUIEventParam< param4 >( &p4, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		if ( !IsEndOfUIEventString( pchEvent, &pchEvent ) )
+			return NULL;
+
+		*pchEventEnd = pchEvent;
+		IUIEvent *pEvent = T::MakeEvent( pPanel ? pPanel->ClientPtr() : NULL, p1, p2, p3, p4 );
+		UIEventFree( p1 );
+		UIEventFree( p2 );
+		UIEventFree( p3 );
+		UIEventFree( p4 );
+		return pEvent;
+	}
+}
+
+#define DECLARE_PANORAMA_EVENT4( name, param1, param2, param3, param4 ) \
+	class  name \
+	{ \
+	public: \
+		typedef param1 TypenameParam1; typedef param2 TypenameParam2; typedef param3 TypenameParam3; typedef param4 TypenameParam4; static const int cParams = 4; static const bool bPanelEvent = false; static panorama::CPanoramaSymbol symbol; static const char *pchEvent;\
+		static panorama::CPanoramaSymbol GetEventType() { Assert( symbol.IsValid() ); return symbol; } \
+		static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget, param1 p1, param2 p2, param3 p3, param4 p4 ) { return new panorama::CUIEvent4< param1, param2, param3, param4 >( symbol, pTarget ? pTarget->UIPanel() : NULL, p1, p2, p3, p4 ); } \
+		static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd ) { return panorama::UIEvent::CreateEventFromString< name, param1, param2, param3, param4 >( pPanel, pchEventCreate, pchEventEnd ); } \
+	}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( param1, param2, param3, param4 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( param1, param2, param3, param4 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( param1, param2, param3, param4 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( param1, param2, param3, param4 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( param1, param2, param3, param4 ) ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( param1, param2, param3, param4 ) ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool( PanelType::*memberfunc )( param1, param2, param3, param4 ) ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+
+#define DECLARE_PANEL_EVENT4( name, param1, param2, param3, param4 ) \
+	class  name \
+	{ \
+	public: \
+		typedef param1 TypenameParam1; typedef param2 TypenameParam2; typedef param3 TypenameParam3; typedef param4 TypenameParam4; static const int cParams = 4; static const bool bPanelEvent = true; static panorama::CPanoramaSymbol symbol; static const char *pchEvent;\
+		static panorama::CPanoramaSymbol GetEventType() { Assert( symbol.IsValid() ); return symbol; } \
+		static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget, param1 p1, param2 p2, param3 p3, param4 p4 ) { return new panorama::CUIPanelEvent4< param1, param2, param3, param4 >( symbol, pTarget ? pTarget->UIPanel() : NULL, p1, p2, p3, p4 ); } \
+		static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd ) { return panorama::UIEvent::CreateEventFromString< name, param1, param2, param3, param4 >( pPanel, pchEventCreate, pchEventEnd ); } \
+	}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4 ) ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4 ) ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool( PanelType::*memberfunc )( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4 ) ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+
+//
+// Events with 5 params
+//
+namespace UIEvent
+{
+	template < class T, typename param1, typename param2, typename param3, typename param4, typename param5 >
+	IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEvent, const char **pchEventEnd )
+	{
+		param1 p1;
+		if ( !ParseUIEventParam< param1 >( &p1, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		param2 p2;
+		if ( !ParseUIEventParam< param2 >( &p2, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		param3 p3;
+		if ( !ParseUIEventParam< param3 >( &p3, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		param4 p4;
+		if ( !ParseUIEventParam< param4 >( &p4, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		param5 p5;
+		if ( !ParseUIEventParam< param5 >( &p5, pPanel, pchEvent, &pchEvent ) )
+			return NULL;
+
+		if ( !IsEndOfUIEventString( pchEvent, &pchEvent ) )
+			return NULL;
+
+		*pchEventEnd = pchEvent;
+
+		IUIEvent *pEvent = T::MakeEvent( pPanel ? pPanel->ClientPtr() : NULL, p1, p2, p3, p4, p5 );
+		UIEventFree( p1 );
+		UIEventFree( p2 );
+		UIEventFree( p3 );
+		UIEventFree( p4 );
+		UIEventFree( p5 );
+		return pEvent;
+	}
+}
+
+#define DECLARE_PANORAMA_EVENT5( name, param1, param2, param3, param4, param5 ) \
+class  name \
+{ \
+public: \
+	typedef param1 TypenameParam1; typedef param2 TypenameParam2; typedef param3 TypenameParam3; typedef param4 TypenameParam4; typedef param5 TypenameParam5; static const int cParams = 5; static const bool bPanelEvent = false; static panorama::CPanoramaSymbol symbol; static const char *pchEvent;\
+	static panorama::CPanoramaSymbol GetEventType() { Assert( symbol.IsValid() ); return symbol; } \
+	static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget, param1 p1, param2 p2, param3 p3, param4 p4, param5 p5 ) { return new panorama::CUIEvent5< param1, param2, param3, param4, param5 >( symbol, pTarget ? pTarget->UIPanel() : NULL, p1, p2, p3, p4, p5 ); } \
+	static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd ) { return panorama::UIEvent::CreateEventFromString< name, param1, param2, param3, param4, param5 >( pPanel, pchEventCreate, pchEventEnd ); } \
+}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool( PanelType::*memberfunc )( param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+
+#define DECLARE_PANEL_EVENT5( name, param1, param2, param3, param4, param5 ) \
+class  name \
+{ \
+public: \
+	typedef param1 TypenameParam1; typedef param2 TypenameParam2; typedef param3 TypenameParam3; typedef param4 TypenameParam4; typedef param5 TypenameParam5; static const int cParams = 5; static const bool bPanelEvent = true; static panorama::CPanoramaSymbol symbol; static const char *pchEvent;\
+	static panorama::CPanoramaSymbol GetEventType() { return symbol; } \
+	static panorama::IUIEvent *MakeEvent( const panorama::IUIPanelClient *pTarget, param1 p1, param2 p2, param3 p3, param4 p4, param5 p5 ) { return new panorama::CUIPanelEvent5< param1, param2, param3, param4, param5 >( symbol, pTarget ? pTarget->UIPanel() : NULL, p1, p2, p3, p4, p5 ); } \
+	static panorama::IUIEvent *CreateEventFromString( panorama::IUIPanel *pPanel, const char *pchEventCreate, const char **pchEventEnd ) { return panorama::UIEvent::CreateEventFromString< name, param1, param2, param3, param4, param5 >( pPanel, pchEventCreate, pchEventEnd ); } \
+}; \
+	template< class T, class U > void RegisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandler( const name &t, T *pPanel, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pPanel, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->RegisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterEventHandlerOnPanel( const name &t, panorama::IUIPanel *pPanel, T *pHandler, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->UnregisterEventHandler( t.GetEventType(), pPanel, UtlMakeDelegate( pHandler, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void RegisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->RegisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class T, class U > void UnregisterForUnhandledEvent( const name &t, T *pObj, bool (U::*memberfunc)( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->UnregisterForUnhandledEvent( t.GetEventType(), UtlMakeDelegate( pObj, memberfunc ).GetAbstractDelegate() ); } \
+	template< class PanelType > void RegisterEventHandlerOnPanelType( const name &t, bool( PanelType::*memberfunc )( const panorama::CPanelPtr< panorama::IUIPanel > &, param1, param2, param3, param4, param5 ) ) { panorama::UIEngine()->RegisterPanelTypeEventHandler( t.GetEventType(), PanelType::GetPanelSymbol(), UtlMakeDelegate( (PanelType*)NULL, memberfunc ).GetAbstractDelegate() ); }
+
+
+#define DEFINE_PANORAMA_EVENT( name ) \
+	panorama::CPanoramaSymbol name::symbol; \
+	const char *name::pchEvent = #name; \
+	panorama::CAutoRegisterUIEvent< name, name::cParams > g_##name##_EventAutoRegister( #name );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Class to automatically register events at startup
+//-----------------------------------------------------------------------------
+void RegisterUIEvent( panorama::CPanoramaSymbol *pSymEvent, const char *pchEventType, int cParams, bool bPanelEvent, 
+	PFN_ParseUIEvent pfnParseUIEvent, PFN_MakeUIEvent0 pfnMakeUIEvent0, PFN_MakeUIEvent1Repeats pfnMakeUIEvent1Repeats, PFN_MakeUIEvent1Source pfnMakeUIEvent1Source );
+
+
+template < class T, int N >
+class CAutoRegisterUIEvent
+{
+public:
+	CAutoRegisterUIEvent( const char *pch )
+	{
+		RegisterUIEvent( &T::symbol, T::pchEvent, T::cParams, T::bPanelEvent, T::CreateEventFromString, NULL, NULL, NULL );
+	}
+};
+
+template < class T >
+class CAutoRegisterUIEvent<T, 0>
+{
+public:
+	CAutoRegisterUIEvent( const char *pch )
+	{
+		RegisterUIEvent( &T::symbol, T::pchEvent, T::cParams, T::bPanelEvent, T::CreateEventFromString, T::MakeEvent, NULL, NULL );
+	}
+};
+
+template < class T, typename TParam1 >
+class CAutoRegisterUIEventWithParam1
+{
+public:
+	CAutoRegisterUIEventWithParam1( const char *pch )
+	{
+		RegisterUIEvent( &T::symbol, T::pchEvent, T::cParams, T::bPanelEvent, T::CreateEventFromString, NULL, NULL, NULL );
+	}
+};
+
+template < class T >
+class CAutoRegisterUIEventWithParam1< T, panorama::EPanelEventSource_t >
+{
+public:
+	CAutoRegisterUIEventWithParam1( const char *pch )
+	{
+		RegisterUIEvent( &T::symbol, T::pchEvent, T::cParams, T::bPanelEvent, T::CreateEventFromString, NULL, NULL, T::MakeEvent );
+	}
+};
+
+template < class T >
+class CAutoRegisterUIEventWithParam1< T, int >
+{
+public:
+	CAutoRegisterUIEventWithParam1( const char *pch )
+	{
+		RegisterUIEvent( &T::symbol, T::pchEvent, T::cParams, T::bPanelEvent, T::CreateEventFromString, NULL, T::MakeEvent, NULL );
+	}
+};
+
+template < class T >
+class CAutoRegisterUIEvent<T, 1>
+{
+public:
+	typedef typename T::TypenameParam1 TTypenameParam1;
+	CAutoRegisterUIEventWithParam1< T, TTypenameParam1 > m_autoregister;
+	CAutoRegisterUIEvent( const char *pch ) : m_autoregister( pch )
+	{
+	}
+};
+
+
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Event interface
+//-----------------------------------------------------------------------------
+class IUIEvent
+{
+public:
+	virtual ~IUIEvent() {}
+
+	virtual const CPanelPtr< const IUIPanel > &GetTargetPanel() const = 0;
+	virtual void SetTargetPanel( const IUIPanel *pTarget ) = 0;
+	virtual panorama::CPanoramaSymbol GetEventType() const = 0;
+	virtual bool CanBubble() const { return false; }
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc ) = 0;
+	virtual IUIEvent *Copy() const = 0;
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs ) = 0;
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName ) = 0;
+#endif
+
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Event base class
+//-----------------------------------------------------------------------------
+class CUIEventBase : public IUIEvent
+{
+public:
+	CUIEventBase( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel )
+	{
+		m_symEvent = symEvent;
+		m_pTargetPanel = pTargetPanel;
+	}
+
+	virtual const CPanelPtr< const IUIPanel > &GetTargetPanel() const
+	{
+		return m_pTargetPanel;
+	}
+
+	virtual void SetTargetPanel( const IUIPanel *pTarget )
+	{
+		m_pTargetPanel = pTarget;
+	}
+
+	virtual panorama::CPanoramaSymbol GetEventType() const
+	{
+		return m_symEvent;
+	}
+
+private:
+	panorama::CPanoramaSymbol m_symEvent;
+	CPanelPtr< const IUIPanel > m_pTargetPanel;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: UI Event types
+//-----------------------------------------------------------------------------
+class CUIEvent0 : public CUIEventBase
+{
+public:
+	CUIEvent0( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+	}
+
+	virtual ~CUIEvent0()
+	{
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool ( void ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del();
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIEvent0( GetEventType(), GetTargetPanel().Get() );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 0;
+		*pArgs = NULL;
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+
+	}
+#endif
+};
+
+class CUIPanelEvent0 : public CUIEventBase
+{
+public:
+	CUIPanelEvent0( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+	}
+
+	virtual ~CUIPanelEvent0()
+	{
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool( const CPanelPtr< const IUIPanel > & ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del( GetTargetPanel() );
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIPanelEvent0( GetEventType(), GetTargetPanel().Get() );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 1;
+		*pArgs = new v8::Handle< v8::Value >[1];
+		*pArgs[0] = v8::String::NewFromUtf8( GetV8Isolate(), GetPanelID( GetTargetPanel().Get() ) );
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+		
+	}
+#endif
+};
+
+
+
+template < typename PARAM1_TYPE >
+class CUIEvent1 : public CUIEventBase
+{
+public:
+	CUIEvent1( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel, PARAM1_TYPE param1 ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+		UIEventSet( &m_param1, param1 );
+	}
+
+	virtual ~CUIEvent1()
+	{
+		UIEventFree( m_param1 );
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool ( PARAM1_TYPE ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del( m_param1 );
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIEvent1( GetEventType(), GetTargetPanel().Get(), m_param1 );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 1;
+		*pArgs = new v8::Handle< v8::Value>[1];	
+		PanoramaTypeToV8Param( m_param1, *pArgs );
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+		UIEventValidate( validator, m_param1 );
+	}
+#endif
+
+	const PARAM1_TYPE &GetParam1() const { return m_param1; }
+
+private:
+	PARAM1_TYPE m_param1;
+};
+
+template < typename PARAM1_TYPE >
+class CUIPanelEvent1 : public CUIEventBase
+{
+public:
+	CUIPanelEvent1( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel, PARAM1_TYPE param1 ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+		UIEventSet( &m_param1, param1 );
+	}
+
+	virtual ~CUIPanelEvent1()
+	{
+		UIEventFree( m_param1 );
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool( const CPanelPtr< const IUIPanel > &, PARAM1_TYPE ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del( GetTargetPanel(), m_param1 );
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIPanelEvent1( GetEventType(), GetTargetPanel().Get(), m_param1 );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 2;
+		*pArgs = new v8::Handle< v8::Value >[2];
+		*pArgs[0] = v8::String::NewFromUtf8( GetV8Isolate(), GetPanelID( GetTargetPanel().Get() ) );
+		PanoramaTypeToV8Param( m_param1, *pArgs+1 );
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+		UIEventValidate( validator, m_param1 );
+	}
+#endif
+
+	const PARAM1_TYPE &GetParam1() const { return m_param1; }
+
+private:
+	PARAM1_TYPE m_param1;
+};
+
+template < typename PARAM1_TYPE, typename PARAM2_TYPE >
+class CUIPanelEvent2 : public CUIEventBase
+{
+public:
+	CUIPanelEvent2( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel, PARAM1_TYPE param1, PARAM2_TYPE param2 ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+		UIEventSet( &m_param1, param1 );
+		UIEventSet( &m_param2, param2 );
+	}
+
+	virtual ~CUIPanelEvent2()
+	{
+		UIEventFree( m_param1 );
+		UIEventFree( m_param2 );
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool( const CPanelPtr< const IUIPanel > &, PARAM1_TYPE, PARAM2_TYPE ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del( GetTargetPanel(), m_param1, m_param2 );
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIPanelEvent2( GetEventType(), GetTargetPanel().Get(), m_param1, m_param2 );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 3;
+		*pArgs = new v8::Handle< v8::Value >[3];
+		*pArgs[0] = v8::String::NewFromUtf8( GetV8Isolate(), GetPanelID( GetTargetPanel().Get() ) );
+		PanoramaTypeToV8Param( m_param1, *pArgs+1 );
+		PanoramaTypeToV8Param( m_param2, *pArgs+2 );
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+		UIEventValidate( validator, m_param1 );
+		UIEventValidate( validator, m_param2 );
+	}
+#endif
+
+	const PARAM1_TYPE &GetParam1() const { return m_param1; }
+	const PARAM2_TYPE &GetParam2() const { return m_param2; }
+
+private:
+	PARAM1_TYPE m_param1;
+	PARAM2_TYPE m_param2;
+};
+
+
+template < typename PARAM1_TYPE, typename PARAM2_TYPE >
+class CUIEvent2 : public CUIEventBase
+{
+public:
+	CUIEvent2( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel, PARAM1_TYPE param1, PARAM2_TYPE param2 ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+		UIEventSet( &m_param1, param1 );
+		UIEventSet( &m_param2, param2 );
+	}
+
+	virtual ~CUIEvent2()
+	{
+		UIEventFree( m_param1 );
+		UIEventFree( m_param2 );
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool ( PARAM1_TYPE, PARAM2_TYPE ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del( m_param1, m_param2 );
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIEvent2( GetEventType(), GetTargetPanel().Get(), m_param1, m_param2 );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 2;
+		*pArgs = new v8::Handle< v8::Value >[2];
+		PanoramaTypeToV8Param( m_param1, *pArgs+0 );
+		PanoramaTypeToV8Param( m_param2, *pArgs+1 );
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+		UIEventValidate( validator, m_param1 );
+		UIEventValidate( validator, m_param2 );
+	}
+#endif
+
+	const PARAM1_TYPE &GetParam1() const { return m_param1; }
+	const PARAM2_TYPE &GetParam2() const { return m_param2; }
+
+private:
+	PARAM1_TYPE m_param1;
+	PARAM2_TYPE m_param2;
+};
+
+template < typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE >
+class CUIEvent3 : public CUIEventBase
+{
+public:
+	CUIEvent3( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3 ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+		UIEventSet( &m_param1, param1 );
+		UIEventSet( &m_param2, param2 );
+		UIEventSet( &m_param3, param3 );
+	}
+
+	virtual ~CUIEvent3()
+	{
+		UIEventFree( m_param1 );
+		UIEventFree( m_param2 );
+		UIEventFree( m_param3 );
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool ( PARAM1_TYPE, PARAM2_TYPE, PARAM3_TYPE ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del( m_param1, m_param2, m_param3 );
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIEvent3( GetEventType(), GetTargetPanel().Get(), m_param1, m_param2, m_param3 );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 3;
+		*pArgs = new v8::Handle< v8::Value >[3];
+		PanoramaTypeToV8Param( m_param1, *pArgs+0 );
+		PanoramaTypeToV8Param( m_param2, *pArgs+1 );
+		PanoramaTypeToV8Param( m_param3, *pArgs+2 );
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+		UIEventValidate( validator, m_param1 );
+		UIEventValidate( validator, m_param2 );
+		UIEventValidate( validator, m_param3 );
+	}
+#endif
+
+	const PARAM1_TYPE &GetParam1() const { return m_param1; }
+	const PARAM2_TYPE &GetParam2() const { return m_param2; }
+	const PARAM3_TYPE &GetParam3() const { return m_param3; }
+
+private:
+	PARAM1_TYPE m_param1;
+	PARAM2_TYPE m_param2;
+	PARAM3_TYPE m_param3;
+};
+
+template < typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE >
+class CUIPanelEvent3 : public CUIEventBase
+{
+public:
+	CUIPanelEvent3( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3 ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+		UIEventSet( &m_param1, param1 );
+		UIEventSet( &m_param2, param2 );
+		UIEventSet( &m_param3, param3 );
+	}
+
+	virtual ~CUIPanelEvent3()
+	{
+		UIEventFree( m_param1 );
+		UIEventFree( m_param2 );
+		UIEventFree( m_param3 );
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool( const CPanelPtr< const IUIPanel > &, PARAM1_TYPE, PARAM2_TYPE, PARAM3_TYPE ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del( GetTargetPanel(), m_param1, m_param2, m_param3 );
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIPanelEvent3( GetEventType(), GetTargetPanel().Get(), m_param1, m_param2, m_param3 );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 4;
+		*pArgs = new v8::Handle< v8::Value >[4];
+		*pArgs[0] = v8::String::NewFromUtf8( GetV8Isolate(), GetPanelID( GetTargetPanel().Get() ) );
+		PanoramaTypeToV8Param( m_param1, *pArgs+1 );
+		PanoramaTypeToV8Param( m_param2, *pArgs+2 );
+		PanoramaTypeToV8Param( m_param3, *pArgs+3 );
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+		UIEventValidate( validator, m_param1 );
+		UIEventValidate( validator, m_param2 );
+		UIEventValidate( validator, m_param3 );
+	}
+#endif
+
+	const PARAM1_TYPE &GetParam1() const { return m_param1; }
+	const PARAM2_TYPE &GetParam2() const { return m_param2; }
+	const PARAM3_TYPE &GetParam3() const { return m_param3; }
+
+private:
+	PARAM1_TYPE m_param1;
+	PARAM2_TYPE m_param2;
+	PARAM3_TYPE m_param3;
+};
+
+template < typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE >
+class CUIEvent4 : public CUIEventBase
+{
+public:
+	CUIEvent4( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4 ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+		UIEventSet( &m_param1, param1 );
+		UIEventSet( &m_param2, param2 );
+		UIEventSet( &m_param3, param3 );
+		UIEventSet( &m_param4, param4 );
+	}
+
+	virtual ~CUIEvent4()
+	{
+		UIEventFree( m_param1 );
+		UIEventFree( m_param2 );
+		UIEventFree( m_param3 );
+		UIEventFree( m_param4 );
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool ( PARAM1_TYPE, PARAM2_TYPE, PARAM3_TYPE, PARAM4_TYPE ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del( m_param1, m_param2, m_param3, m_param4 );
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIEvent4( GetEventType(), GetTargetPanel().Get(), m_param1, m_param2, m_param3, m_param4 );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 4;
+		*pArgs = new v8::Handle< v8::Value >[4];
+		PanoramaTypeToV8Param( m_param1, *pArgs+0 );
+		PanoramaTypeToV8Param( m_param2, *pArgs+1 );
+		PanoramaTypeToV8Param( m_param3, *pArgs+2 );
+		PanoramaTypeToV8Param( m_param4, *pArgs+3 );
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+		UIEventValidate( validator, m_param1 );
+		UIEventValidate( validator, m_param2 );
+		UIEventValidate( validator, m_param3 );
+		UIEventValidate( validator, m_param4 );
+	}
+#endif
+
+	const PARAM1_TYPE &GetParam1() const { return m_param1; }
+	const PARAM2_TYPE &GetParam2() const { return m_param2; }
+	const PARAM3_TYPE &GetParam3() const { return m_param3; }
+	const PARAM4_TYPE &GetParam4() const { return m_param4; }
+
+private:
+	PARAM1_TYPE m_param1;
+	PARAM2_TYPE m_param2;
+	PARAM3_TYPE m_param3;
+	PARAM4_TYPE m_param4;
+};
+
+
+template < typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE >
+class CUIPanelEvent4 : public CUIEventBase
+{
+public:
+	CUIPanelEvent4( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4 ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+		UIEventSet( &m_param1, param1 );
+		UIEventSet( &m_param2, param2 );
+		UIEventSet( &m_param3, param3 );
+		UIEventSet( &m_param4, param4 );
+	}
+
+	virtual ~CUIPanelEvent4()
+	{
+		UIEventFree( m_param1 );
+		UIEventFree( m_param2 );
+		UIEventFree( m_param3 );
+		UIEventFree( m_param4 );
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool( const CPanelPtr< const IUIPanel > &, PARAM1_TYPE, PARAM2_TYPE, PARAM3_TYPE, PARAM4_TYPE ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del( GetTargetPanel(), m_param1, m_param2, m_param3, m_param4 );
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIPanelEvent4( GetEventType(), GetTargetPanel().Get(), m_param1, m_param2, m_param3, m_param4 );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 5;
+		*pArgs = new v8::Handle< v8::Value >[5];
+		*pArgs[0] = v8::String::NewFromUtf8( GetV8Isolate(), GetPanelID( GetTargetPanel().Get() ) );
+		PanoramaTypeToV8Param( m_param1, *pArgs+1 );
+		PanoramaTypeToV8Param( m_param2, *pArgs+2 );
+		PanoramaTypeToV8Param( m_param3, *pArgs+3 );
+		PanoramaTypeToV8Param( m_param4, *pArgs+4 );
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+		UIEventValidate( validator, m_param1 );
+		UIEventValidate( validator, m_param2 );
+		UIEventValidate( validator, m_param3 );
+		UIEventValidate( validator, m_param4 );
+	}
+#endif
+
+	const PARAM1_TYPE &GetParam1() const { return m_param1; }
+	const PARAM2_TYPE &GetParam2() const { return m_param2; }
+	const PARAM3_TYPE &GetParam3() const { return m_param3; }
+	const PARAM4_TYPE &GetParam4() const { return m_param4; }
+
+private:
+	PARAM1_TYPE m_param1;
+	PARAM2_TYPE m_param2;
+	PARAM3_TYPE m_param3;
+	PARAM4_TYPE m_param4;
+};
+
+
+template < typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE, typename PARAM5_TYPE >
+class CUIEvent5 : public CUIEventBase
+{
+public:
+	CUIEvent5( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4, PARAM5_TYPE param5 ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+		UIEventSet( &m_param1, param1 );
+		UIEventSet( &m_param2, param2 );
+		UIEventSet( &m_param3, param3 );
+		UIEventSet( &m_param4, param4 );
+		UIEventSet( &m_param5, param5 );
+	}
+
+	virtual ~CUIEvent5()
+	{
+		UIEventFree( m_param1 );
+		UIEventFree( m_param2 );
+		UIEventFree( m_param3 );
+		UIEventFree( m_param4 );
+		UIEventFree( m_param5 );
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool ( PARAM1_TYPE, PARAM2_TYPE, PARAM3_TYPE, PARAM4_TYPE, PARAM5_TYPE ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del( m_param1, m_param2, m_param3, m_param4, m_param5  );
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIEvent5( GetEventType(), GetTargetPanel().Get(), m_param1, m_param2, m_param3, m_param4, m_param5 );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 5;
+		*pArgs = new v8::Handle< v8::Value >[5];
+		PanoramaTypeToV8Param( m_param1, *pArgs+0 );
+		PanoramaTypeToV8Param( m_param2, *pArgs+1 );
+		PanoramaTypeToV8Param( m_param3, *pArgs+2 );
+		PanoramaTypeToV8Param( m_param4, *pArgs+3 );
+		PanoramaTypeToV8Param( m_param5, *pArgs+4 );
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+		UIEventValidate( validator, m_param1 );
+		UIEventValidate( validator, m_param2 );
+		UIEventValidate( validator, m_param3 );
+		UIEventValidate( validator, m_param4 );
+		UIEventValidate( validator, m_param5 );
+	}
+#endif
+
+	const PARAM1_TYPE &GetParam1() const { return m_param1; }
+	const PARAM2_TYPE &GetParam2() const { return m_param2; }
+	const PARAM3_TYPE &GetParam3() const { return m_param3; }
+	const PARAM4_TYPE &GetParam4() const { return m_param4; }
+	const PARAM5_TYPE &GetParam5() const { return m_param5; }
+
+private:
+	PARAM1_TYPE m_param1;
+	PARAM2_TYPE m_param2;
+	PARAM3_TYPE m_param3;
+	PARAM4_TYPE m_param4;
+	PARAM5_TYPE m_param5;
+};
+
+
+template < typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE, typename PARAM5_TYPE >
+class CUIPanelEvent5 : public CUIEventBase
+{
+public:
+	CUIPanelEvent5( panorama::CPanoramaSymbol symEvent, const IUIPanel *pTargetPanel, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4, PARAM5_TYPE param5 ) : CUIEventBase( symEvent, pTargetPanel )
+	{
+		UIEventSet( &m_param1, param1 );
+		UIEventSet( &m_param2, param2 );
+		UIEventSet( &m_param3, param3 );
+		UIEventSet( &m_param4, param4 );
+		UIEventSet( &m_param5, param5 );
+	}
+
+	virtual ~CUIPanelEvent5()
+	{
+		UIEventFree( m_param1 );
+		UIEventFree( m_param2 );
+		UIEventFree( m_param3 );
+		UIEventFree( m_param4 );
+		UIEventFree( m_param5 );
+	}
+
+	virtual bool Dispatch( CUtlAbstractDelegate pFunc )
+	{
+		CUtlDelegate< bool( const CPanelPtr< const IUIPanel > &, PARAM1_TYPE, PARAM2_TYPE, PARAM3_TYPE, PARAM4_TYPE, PARAM5_TYPE ) > del;
+		del.SetAbstractDelegate( pFunc );
+		return del( GetTargetPanel(), m_param1, m_param2, m_param3, m_param4, m_param5 );
+	}
+
+	virtual IUIEvent *Copy() const
+	{
+		return new CUIPanelEvent5( GetEventType(), GetTargetPanel().Get(), m_param1, m_param2, m_param3, m_param4, m_param5 );
+	}
+
+	virtual void GetJavaScriptArgs( int *pCount, v8::Handle<v8::Value> **pArgs )
+	{
+		*pCount = 6;
+		*pArgs = new v8::Handle< v8::Value >[6];
+		*pArgs[0] = v8::String::NewFromUtf8( GetV8Isolate(), GetPanelID( GetTargetPanel().Get() ) );
+		PanoramaTypeToV8Param( m_param1, *pArgs+1 );
+		PanoramaTypeToV8Param( m_param2, *pArgs+2 );
+		PanoramaTypeToV8Param( m_param3, *pArgs+3 );
+		PanoramaTypeToV8Param( m_param4, *pArgs+4 );
+		PanoramaTypeToV8Param( m_param5, *pArgs+5 );
+	}
+
+#ifdef DBGFLAG_VALIDATE
+	virtual void Validate( CValidator &validator, const tchar *pchName )
+	{
+		UIEventValidate( validator, m_param1 );
+		UIEventValidate( validator, m_param2 );
+		UIEventValidate( validator, m_param3 );
+		UIEventValidate( validator, m_param4 );
+		UIEventValidate( validator, m_param5 );
+	}
+#endif
+
+	const PARAM1_TYPE &GetParam1() const { return m_param1; }
+	const PARAM2_TYPE &GetParam2() const { return m_param2; }
+	const PARAM3_TYPE &GetParam3() const { return m_param3; }
+	const PARAM4_TYPE &GetParam4() const { return m_param4; }
+	const PARAM5_TYPE &GetParam5() const { return m_param5; }
+
+private:
+	PARAM1_TYPE m_param1;
+	PARAM2_TYPE m_param2;
+	PARAM3_TYPE m_param3;
+	PARAM4_TYPE m_param4;
+	PARAM5_TYPE m_param5;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Dispatch synchronous event helpers
+//-----------------------------------------------------------------------------
+#ifdef PANORAMA_EXPORTS
+template < typename T >
+bool DispatchEvent( T t, const IUIPanel *pTarget )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL ) );
+}
+
+template < typename T, typename PARAM1_TYPE >
+bool DispatchEvent( T t, const IUIPanel *pTarget, PARAM1_TYPE param1 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE >
+bool DispatchEvent( T t, const IUIPanel *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1, param2 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE >
+bool DispatchEvent( T t, const IUIPanel *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1, param2, param3 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE >
+bool DispatchEvent( T t, const IUIPanel *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1, param2, param3, param4 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE, typename PARAM5_TYPE >
+bool DispatchEvent( T t, const IUIPanel *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4, PARAM5_TYPE param5 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1, param2, param3, param4, param5 ) );
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Dispatch synchronous event helpers
+//-----------------------------------------------------------------------------
+template < typename T >
+bool DispatchEvent( T t, const IUIPanelClient *pTarget )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget ) );
+}
+
+template < typename T, typename PARAM1_TYPE >
+bool DispatchEvent( T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget, param1 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE >
+bool DispatchEvent( T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget, param1, param2 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE >
+bool DispatchEvent( T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget, param1, param2, param3 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE >
+bool DispatchEvent( T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget, param1, param2, param3, param4 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE, typename PARAM5_TYPE >
+bool DispatchEvent( T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4, PARAM5_TYPE param5 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return false;
+
+	return UIEngine()->DispatchEvent( t.MakeEvent( pTarget, param1, param2, param3, param4, param5 ) );
+}
+
+#ifdef PANORAMA_EXPORTS
+//-----------------------------------------------------------------------------
+// Purpose: Dispatch asynchronous event helpers
+//-----------------------------------------------------------------------------
+template < typename T >
+void DispatchEventAsync( T t, const IUIPanel *pTarget )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return;
+
+	UIEngine()->DispatchEventAsync( 0.0f, t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL ) );
+}
+
+template < typename T >
+void DispatchEventAsync( float flDelay, T t, const IUIPanel *pTarget )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL ) );
+}
+
+
+template < typename T, typename PARAM1_TYPE >
+void DispatchEventAsync( T t, const IUIPanel *pTarget, PARAM1_TYPE param1 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return;
+
+	UIEngine()->DispatchEventAsync( 0.0f, t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1 ) );
+}
+
+template < typename T, typename PARAM1_TYPE >
+void DispatchEventAsync( float flDelay, T t, const IUIPanel *pTarget, PARAM1_TYPE param1 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE  >
+void DispatchEventAsync( T t, const IUIPanel *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return;
+
+	UIEngine()->DispatchEventAsync( 0.0f, t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1, param2 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE >
+void DispatchEventAsync( T t, const IUIPanel *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return;
+
+	UIEngine()->DispatchEventAsync( 0.0f, t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1, param2, param3 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE  >
+void DispatchEventAsync( float flDelay, T t, const IUIPanel *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1, param2 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE >
+void DispatchEventAsync( float flDelay, T t, const IUIPanel *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1, param2, param3 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE >
+void DispatchEventAsync( float flDelay, T t, const IUIPanel *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1, param2, param3, param4 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE, typename PARAM5_TYPE >
+void DispatchEventAsync( float flDelay, T t, const IUIPanel *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4, PARAM5_TYPE param5 )
+{
+	if ( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) ) 
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget ? pTarget->ClientPtr() : NULL, param1, param2, param3, param4, param5 ) );
+}
+#endif
+
+template < typename T >
+void DispatchEventAsync( T t, const IUIPanelClient *pTarget )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return;
+
+	UIEngine()->DispatchEventAsync( 0.0f, t.MakeEvent( pTarget ) );
+}
+
+template < typename T >
+void DispatchEventAsync( float flDelay, T t, const IUIPanelClient *pTarget )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget ) );
+}
+
+
+template < typename T, typename PARAM1_TYPE >
+void DispatchEventAsync( T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return;
+
+	UIEngine()->DispatchEventAsync( 0.0f, t.MakeEvent( pTarget, param1 ) );
+}
+
+template < typename T, typename PARAM1_TYPE >
+void DispatchEventAsync( float flDelay, T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget, param1 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE  >
+void DispatchEventAsync( T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return;
+
+	UIEngine()->DispatchEventAsync( 0.0f, t.MakeEvent( pTarget, param1, param2 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE >
+void DispatchEventAsync( T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return;
+
+	UIEngine()->DispatchEventAsync( 0.0f, t.MakeEvent( pTarget, param1, param2, param3 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE  >
+void DispatchEventAsync( float flDelay, T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget, param1, param2 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE >
+void DispatchEventAsync( float flDelay, T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget, param1, param2, param3 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE >
+void DispatchEventAsync( float flDelay, T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget, param1, param2, param3, param4 ) );
+}
+
+template < typename T, typename PARAM1_TYPE, typename PARAM2_TYPE, typename PARAM3_TYPE, typename PARAM4_TYPE, typename PARAM5_TYPE >
+void DispatchEventAsync( float flDelay, T t, const IUIPanelClient *pTarget, PARAM1_TYPE param1, PARAM2_TYPE param2, PARAM3_TYPE param3, PARAM4_TYPE param4, PARAM5_TYPE param5 )
+{
+	if( !UIEngine()->BAnyHandlerRegisteredForEvent( T::symbol ) )
+		return;
+
+	UIEngine()->DispatchEventAsync( flDelay, t.MakeEvent( pTarget, param1, param2, param3, param4, param5 ) );
+}
+
+
+/*
+IUIEvent *CreateEventFromSymbol( panorama::CPanoramaSymbol symEvent, IUIPanel *pPanel );
+template <typename PARAM1> IUIEvent *CreateEventFromSymbol( panorama::CPanoramaSymbol symEvent, IUIPanel *pPanel, PARAM1 p1 );
+template <typename PARAM1, typename PARAM2> IUIEvent *CreateEventFromSymbol( panorama::CPanoramaSymbol symEvent, IUIPanel *pPanel, PARAM1 p1, PARAM2 p2 );
+template <typename PARAM1, typename PARAM2, typename PARAM3> IUIEvent *CreateEventFromSymbol( panorama::CPanoramaSymbol symEvent, IUIPanel *pPanel, PARAM1 p1, PARAM2 p2, PARAM3 p3 );
+*/
+} // namespace panorama 
+
+#endif // UIEVENT_H