1794 lines
88 KiB
C++
1794 lines
88 KiB
C++
|
|
//=========== 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
|