Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1793 lines
88 KiB

//=========== 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