d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
195 Commits
25 Branches
6 Tags
221 MiB
Tree: 5e1ed3bd26
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5e1ed3bd26'
${ noResults }
source-engine/public/panorama/uijsregistration.h

725 lines
29 KiB
Raw Normal View History Unescape

1
5 years ago
//=========== Copyright Valve Corporation, All rights reserved. ===============//
//
// Purpose:
//=============================================================================//
#ifndef UIJSREGISTRATION_H
#define UIJSREGISTRATION_H
#pragma once
#include "../panorama/uiengine.h"
#if defined( OSX ) && !defined( SOURCE2_PANORAMA )
#include <tr1/tuple>
#include <tr1/utility>
#define STDTR1 std::tr1
#else
#define STDTR1 std
#endif
#if _GNUC
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
#endif // _GNUC
#ifdef None
#undef None // X11 defines None breaking the ability to use v8::None down below, so remove the preprocessor macro here
#endif
#pragma warning(push)
//warning C4700 : uninitialized local variable 'getcaster' used -- we'll do a lot of this, but its ok
#pragma warning( disable : 4700 )
namespace panorama
{
template<typename T> struct RegisterJSTypeDeducer_t { static RegisterJSType_t Type() { return k_ERegisterJSTypeUnknown; } };
#define PANORAMA_DECLARE_DEDUCE_JSTYPE( _JSType, _T ) template<> struct RegisterJSTypeDeducer_t<_T> { static RegisterJSType_t Type() { return k_ERegisterJSType##_JSType; } };
PANORAMA_DECLARE_DEDUCE_JSTYPE( Void, void )
PANORAMA_DECLARE_DEDUCE_JSTYPE( Bool, bool )
PANORAMA_DECLARE_DEDUCE_JSTYPE( Int8, int8 )
PANORAMA_DECLARE_DEDUCE_JSTYPE( Uint8, uint8 )
PANORAMA_DECLARE_DEDUCE_JSTYPE( Int16, int16 )
PANORAMA_DECLARE_DEDUCE_JSTYPE( Uint16, uint16 )
PANORAMA_DECLARE_DEDUCE_JSTYPE( Int32, int32 )
PANORAMA_DECLARE_DEDUCE_JSTYPE( Uint32, uint32 )
PANORAMA_DECLARE_DEDUCE_JSTYPE( Int64, int64 )
PANORAMA_DECLARE_DEDUCE_JSTYPE( Uint64, uint64 )
PANORAMA_DECLARE_DEDUCE_JSTYPE( Float, float )
PANORAMA_DECLARE_DEDUCE_JSTYPE( Double, double )
PANORAMA_DECLARE_DEDUCE_JSTYPE( ConstString, const char * )
PANORAMA_DECLARE_DEDUCE_JSTYPE( PanoramaSymbol, CPanoramaSymbol )
PANORAMA_DECLARE_DEDUCE_JSTYPE( RawV8Args, const v8::FunctionCallbackInfo<v8::Value>& )
inline void JSCheckObjectValidity( const v8::FunctionCallbackInfo<v8::Value>& args )
{
// Don't use helper for getting panel, as it will throw exception, which we don't want in just this function
v8::Local<v8::Object> obj = args.Holder();
if( obj->InternalFieldCount() != 1 )
{
v8::Handle< v8::Boolean > value = v8::Boolean::New( args.GetIsolate(), false );
args.GetReturnValue().Set( value );
}
v8::Local<v8::External> wrap = v8::Local<v8::External>::Cast( obj->GetInternalField( 0 ) );
void *pPanel = (void*)wrap->Value();
if( !pPanel )
{
v8::Handle< v8::Boolean > value = v8::Boolean::New( args.GetIsolate(), false );
args.GetReturnValue().Set( value );
}
else
{
v8::Handle< v8::Boolean > value = v8::Boolean::New( args.GetIsolate(), true );
args.GetReturnValue().Set( value );
}
}
// Register special IsValid(), which makes the JS obj like a safe handle where you can use this
// to check if the obj has been deleted in C++ and is gone. You must still track all objects that are
// created and set their internal value to 0 so they point at nothing to make this work.
inline void RegisterJSIsValid()
{
v8::Isolate::Scope isolate_scope( GetV8Isolate() );
v8::HandleScope handle_scope( GetV8Isolate() );
v8::Handle<v8::ObjectTemplate> objTemplate = UIEngine()->GetCurrentV8ObjectTemplateToSetup();
objTemplate->Set( v8::String::NewFromUtf8( GetV8Isolate(), "IsValid" ), v8::FunctionTemplate::New( GetV8Isolate(), &JSCheckObjectValidity ) );
}
// Register a member to expose to JavaScript as read/write
template< typename ObjType, typename MemberType >
void RegisterJSAccessor( const char *jsMemberName, MemberType( ObjType::*pGetFunc )() const, void(ObjType::*pSetFunc)(MemberType), const char *pDesc = NULL );
// Register a read-only member to expose to JavaScript
template< typename ObjType, typename MemberType >
void RegisterJSAccessorReadOnly( const char *jsMemberName, MemberType( ObjType::*pGetFunc )() const, const char *pDesc = NULL );
template < typename ObjType, typename RetType, typename ...Args>
void RegisterJSMethod( const char *pchMethodName, RetType( ObjType::*mf )(Args...) const, const char *pDesc = NULL );
template <typename T>
void RegisterJSConstantValue( const char *pchJSMemberName, T value, const char *pDesc = NULL );
template < typename RetType, typename ...Args>
void RegisterJSGlobalFunction( const char *pchJSFunctionName, RetType(*pFunc)(Args...), bool bTrueGlobal = false, const char *pDesc = NULL );
//
// Everything below here is internals, and should be ignored if you aren't adding additional type
// support inside panorama itself.
//
template< typename ObjType> ObjType* GetThisPtrForJSCall( v8::Local<v8::Object> self )
{
v8::Local<v8::External> wrap = v8::Local<v8::External>::Cast( self->GetInternalField( 0 ) );
ObjType *pPanel = (ObjType*)wrap->Value();
if( pPanel && panorama_is_base_of< IUIPanelClient, ObjType >::value )
{
IUIPanel *pUIPanel = (IUIPanel*)(pPanel);
pPanel = (ObjType*)(pUIPanel->ClientPtr());
}
if( !pPanel )
{
GetV8Isolate()->ThrowException( v8::String::NewFromUtf8( GetV8Isolate(), "Underlying object is deleted!" ) );
return NULL;
}
return pPanel;
}
template < typename T > void GetPtrToCallbackArray( T pGetFunc, v8::Handle<v8::Array> &callbackArray );
template < typename T > void SetPtrToCallbackArray( T pSetFunc, v8::Handle<v8::Array> &callbackArray );
struct funcbytes
{
void * v1;
void * v2;
void * v3;
};
template< typename T> union HACKY_FUNC_PTR_CASTER
{
T funcPtr;
funcbytes funcBytes;
};
template< typename T> void RestoreFuncPtr( HACKY_FUNC_PTR_CASTER< T > &caster, v8::Local<v8::Array> &callbackArray, int iOffset )
{
Assert( (int)callbackArray->Length() >= iOffset + 3 );
caster.funcBytes.v1 = v8::Local<v8::External>::Cast( callbackArray->Get( iOffset++ ) )->Value();
caster.funcBytes.v2 = v8::Local<v8::External>::Cast( callbackArray->Get( iOffset++ ) )->Value();
caster.funcBytes.v3 = v8::Local<v8::External>::Cast( callbackArray->Get( iOffset++ ) )->Value();
}
template <typename T>
void RegisterJSConstantValue( const char *pchJSMemberName, T value, const char *pDesc )
{
v8::Isolate::Scope isolate_scope( GetV8Isolate() );
v8::HandleScope handle_scope( GetV8Isolate() );
v8::Handle<v8::ObjectTemplate> objTemplate = UIEngine()->GetCurrentV8ObjectTemplateToSetup();
v8::Handle<v8::Value> val;
PanoramaTypeToV8Param( value, &val );
objTemplate->Set( v8::String::NewFromUtf8( GetV8Isolate(), pchJSMemberName ), val, v8::PropertyAttribute( v8::ReadOnly | v8::DontDelete ) );
UIEngine()->NewRegisterJSEntry( pchJSMemberName, RegisterJSEntryInfo_t::k_EConstantValue, pDesc, RegisterJSTypeDeducer_t<T>::Type() );
}
//-----------------------------------------------------------------------------
// Purpose: More heavily templated helper for registering accessors of various types. We'll
// expose explicit more strongly typed versions, but this avoids duplicating setup code in each.
//-----------------------------------------------------------------------------
template <typename JSGetterCallback, typename JSSetterCallback, typename ObjGetMethod, typename ObjSetMethod>
void RegisterJSAccessorInternal( const char *pchJSMemberName, ObjGetMethod pGetFunc, ObjSetMethod pSetFunc, JSGetterCallback pGetCallback, JSSetterCallback pSetCallback, const char *pDesc = NULL, RegisterJSType_t eDataType = k_ERegisterJSTypeUnknown )
{
v8::Isolate::Scope isolate_scope( GetV8Isolate() );
v8::HandleScope handle_scope( GetV8Isolate() );
v8::Handle<v8::Array> callbackArray = v8::Array::New( GetV8Isolate(), 6 );
GetPtrToCallbackArray( pGetFunc, callbackArray );
SetPtrToCallbackArray( pSetFunc, callbackArray );
v8::Handle<v8::ObjectTemplate> objTemplate = UIEngine()->GetCurrentV8ObjectTemplateToSetup();
if( pSetFunc )
objTemplate->SetAccessor( v8::String::NewFromUtf8( GetV8Isolate(), pchJSMemberName ), pGetCallback, pSetCallback, callbackArray, v8::DEFAULT, v8::None );
else
objTemplate->SetAccessor( v8::String::NewFromUtf8( GetV8Isolate(), pchJSMemberName ), pGetCallback, 0, callbackArray, v8::DEFAULT, v8::ReadOnly );
UIEngine()->NewRegisterJSEntry( pchJSMemberName, pSetFunc ? RegisterJSEntryInfo_t::k_EAccessor : RegisterJSEntryInfo_t::k_EAccessorReadOnly, pDesc, eDataType );
}
template < class ObjType, class T > class CJSPropGetter
{
public:
static void GetProp( v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value>& info )
{
v8::Isolate::Scope isolate_scope( GetV8Isolate() );
v8::HandleScope handle_scope( GetV8Isolate() );
ObjType *pPanel = GetThisPtrForJSCall<ObjType>( info.Holder() );
if( !pPanel )
return;
v8::Local<v8::Array> callbackArray = v8::Local<v8::Array>::Cast( info.Data() );
HACKY_FUNC_PTR_CASTER< T( ObjType::* )() const > caster;
RestoreFuncPtr( caster, callbackArray, 0 );
v8::Handle< v8::Value > val;
T nativeval = (pPanel->*caster.funcPtr)();
PanoramaTypeToV8Param( nativeval, &val );
info.GetReturnValue().Set( val );
}
static void SetProp( v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info )
{
v8::Isolate::Scope isolate_scope( GetV8Isolate() );
v8::HandleScope handle_scope( GetV8Isolate() );
ObjType *pPanel = GetThisPtrForJSCall<ObjType>( info.Holder() );
if( !pPanel )
return;
v8::Local<v8::Array> callbackArray = v8::Local<v8::Array>::Cast( info.Data() );
HACKY_FUNC_PTR_CASTER< void (ObjType::*)(T) > caster;
RestoreFuncPtr( caster, callbackArray, 3 );
T val;
V8ParamToPanoramaType( value, &val );
(pPanel->*caster.funcPtr)(val);
FreeConvertedParam( val );
}
};
//-----------------------------------------------------------------------------
// Purpose: Register a float member to expose to JavaScript, can pass NULL for pSetFunc if this is only able to be read not written
//-----------------------------------------------------------------------------
template< typename ObjType, typename MemberType >
void RegisterJSAccessor( const char *jsMemberName, MemberType( ObjType::*pGetFunc )() const, void(ObjType::*pSetFunc)(MemberType), const char *pDesc )
{
RegisterJSAccessorInternal( jsMemberName, pGetFunc, pSetFunc, &CJSPropGetter<ObjType, MemberType>::GetProp, &CJSPropGetter<ObjType, MemberType>::SetProp, pDesc, RegisterJSTypeDeducer_t<MemberType>::Type() );
}
// Register a read-only member to expose to JavaScript
template< typename ObjType, typename MemberType >
void RegisterJSAccessorReadOnly( const char *jsMemberName, MemberType( ObjType::*pGetFunc )() const, const char *pDesc )
{
RegisterJSAccessorInternal( jsMemberName, pGetFunc, 0, &CJSPropGetter<ObjType, MemberType>::GetProp, &CJSPropGetter<ObjType, MemberType>::SetProp, pDesc, RegisterJSTypeDeducer_t<MemberType>::Type() );
}
//-----------------------------------------------------------------------------
// Purpose: Convert a v8 argument to native panorama type
//-----------------------------------------------------------------------------
template< typename T> bool BConvertV8ArgToPanorama( const v8::Handle<v8::Value> &val, T *pNativeVal )
{
v8::TryCatch try_catch;
V8ParamToPanoramaType( val, pNativeVal );
if( try_catch.HasCaught() )
{
UIEngine()->OutputJSExceptionToConsole( try_catch, UIEngine()->GetPanelForJavaScriptContext( *(GetV8Isolate()->GetCurrentContext()) ) );
return false;
}
return true;
}
void JSCheckObjectValidity( const v8::FunctionCallbackInfo<v8::Value>& args );
//-----------------------------------------------------------------------------
// Purpose: Helper for passing function pointers into js data callback
//-----------------------------------------------------------------------------
template < typename T > void GetPtrToCallbackArray( T pGetFunc, v8::Handle<v8::Array> &callbackArray )
{
COMPILE_TIME_ASSERT( sizeof( T ) <= sizeof( funcbytes ) );
Assert( callbackArray->Length() >= 3 );
HACKY_FUNC_PTR_CASTER< T > getcaster;
// single a legit GCC warning when our func pointers are 2 bytes, not 3
getcaster.funcBytes.v3 = NULL;
getcaster.funcPtr = pGetFunc;
callbackArray->Set( 0, v8::External::New( GetV8Isolate(), getcaster.funcBytes.v1 ) );
callbackArray->Set( 1, v8::External::New( GetV8Isolate(), getcaster.funcBytes.v2 ) );
callbackArray->Set( 2, v8::External::New( GetV8Isolate(), getcaster.funcBytes.v3 ) );
}
//-----------------------------------------------------------------------------
// Purpose: Helper for passing function pointers into js data callback
//-----------------------------------------------------------------------------
template < typename T > void SetPtrToCallbackArray( T pSetFunc, v8::Handle<v8::Array> &callbackArray )
{
COMPILE_TIME_ASSERT( sizeof( T ) <= sizeof( funcbytes ) );
Assert( callbackArray->Length() >= 6 );
if( pSetFunc )
{
HACKY_FUNC_PTR_CASTER< T > setcaster;
// single a legit GCC warning when our func pointers are 2 bytes, not 3
setcaster.funcBytes.v3 = NULL;
setcaster.funcPtr = pSetFunc;
callbackArray->Set( 3, v8::External::New( GetV8Isolate(), setcaster.funcBytes.v1 ) );
callbackArray->Set( 4, v8::External::New( GetV8Isolate(), setcaster.funcBytes.v2 ) );
callbackArray->Set( 5, v8::External::New( GetV8Isolate(), setcaster.funcBytes.v3 ) );
}
}
//-----------------------------------------------------------------------------
// Purpose: Handler for JS method call callbacks
//-----------------------------------------------------------------------------
// two JSMethodCallbackWrappers to handle void callbacks & callbacks with return values
template< typename RetType, typename ObjType, typename ...Args >
struct JSMethodCallbackWrapper
{
static void Call( ObjType *pObject, RetType( ObjType::*mf )(Args...), const v8::FunctionCallbackInfo<v8::Value>& v8Args, Args... args )
{
RetType ret = (pObject->*mf)(panorama_forward< Args >( args )...);
v8::Handle< v8::Value > value;
PanoramaTypeToV8Param( ret, &value );
v8Args.GetReturnValue().Set( value );
}
};
template< typename ObjType, typename ...Args >
struct JSMethodCallbackWrapper< void, ObjType, Args... >
{
static void Call( ObjType *pObject, void(ObjType::*mf)(Args...), const v8::FunctionCallbackInfo<v8::Value>& v8Args, Args... args )
{
(pObject->*mf)(panorama_forward< Args >( args )...);
}
};
template< typename RetType, typename ...Args >
struct JSFunctionCallbackWrapper
{
static void Call( RetType( *mf )(Args...), const v8::FunctionCallbackInfo<v8::Value>& v8Args, Args... args )
{
RetType ret = mf(panorama_forward< Args >( args )... );
v8::Handle< v8::Value > value;
PanoramaTypeToV8Param( ret, &value );
v8Args.GetReturnValue().Set( value );
}
};
template< typename ...Args >
struct JSFunctionCallbackWrapper < void, Args... >
{
static void Call( void(*mf)(Args...), const v8::FunctionCallbackInfo<v8::Value>& v8Args, Args... args )
{
mf(panorama_forward< Args >( args )...);
}
};
// helper to generate a sequences of index to iterate
template<int...> struct index_tuple {};
template<int I, typename IndexTuple, typename... Types>
struct make_indexes_impl;
template<int I, int... Indexes, typename T, typename ... Types>
struct make_indexes_impl < I, index_tuple<Indexes...>, T, Types... >
{
typedef typename make_indexes_impl<I + 1, index_tuple<Indexes..., I>, Types...>::type type;
};
template<int I, int... Indexes>
struct make_indexes_impl < I, index_tuple<Indexes...> >
{
typedef index_tuple<Indexes...> type;
};
template<typename ... Types>
struct make_indexes : make_indexes_impl < 0, index_tuple<>, Types... >
{
};
// Expands values in tuple into a single function call
template< typename ObjType, typename RetType, typename TupleType, class... Args, int... Indexes >
void JSMethodCallTuple_Helper( ObjType *pPanel, RetType( ObjType::*mf )(Args...), const v8::FunctionCallbackInfo<v8::Value> &args, index_tuple< Indexes... >, TupleType &tup )
{
JSMethodCallbackWrapper< RetType, ObjType, Args... >::Call( pPanel, mf, args, panorama_forward<Args>( STDTR1::get<Indexes>( tup ) )... );
}
// Expands values in tuple into a single function call
template< typename RetType, typename TupleType, class... Args, int... Indexes >
void JSFunctionCallTuple_Helper( RetType( *pFunc )(Args...), const v8::FunctionCallbackInfo<v8::Value> &args, index_tuple< Indexes... >, TupleType &tup )
{
JSFunctionCallbackWrapper< RetType, Args... >::Call( pFunc, args, panorama_forward<Args>( STDTR1::get<Indexes>( tup ) )... );
}
// converts all v8 args into a tuple
template< int Index, typename T >
struct ConvertV8ArgsToTuple
{
static void Call( T &tup, const v8::FunctionCallbackInfo<v8::Value> &args, bool *pbSucceeded )
{
bool bSucceeded = BConvertV8ArgToPanorama( args[Index - 1], &STDTR1::get< Index - 1>( tup ) );
if ( pbSucceeded )
pbSucceeded[Index - 1] = bSucceeded;
if ( !bSucceeded )
return;
ConvertV8ArgsToTuple<Index - 1, T >::Call( tup, args, pbSucceeded );
}
};
template< typename T >
struct ConvertV8ArgsToTuple< 0, T >
{
static void Call( T &tup, const v8::FunctionCallbackInfo<v8::Value> &args, bool *pbSucceeded )
{
}
};
// frees all args in tuple
template< int Index, typename T >
struct FreeV8ArgsToTuple
{
static void Call( T &tup, bool *pbSucceeded )
{
if ( pbSucceeded && pbSucceeded[Index - 1] )
FreeConvertedParam( STDTR1::get< Index - 1 >( tup ) );
FreeV8ArgsToTuple<Index - 1, T >::Call( tup, pbSucceeded );
}
};
template< typename T >
struct FreeV8ArgsToTuple < 0, T >
{
static void Call( T &tup, bool *pbSucceeded )
{
}
};
template< typename ObjType, typename RetType, typename ...Args >
void JSMethodCallTuple( const v8::FunctionCallbackInfo<v8::Value>& args )
{
v8::Isolate::Scope isolate_scope( args.GetIsolate() );
v8::HandleScope handle_scope( args.GetIsolate() );
v8::Persistent<v8::Context> &perContext = UIEngine()->GetV8GlobalContext();
v8::Handle<v8::Context> context = v8::Local<v8::Context>::New( GetV8Isolate(), perContext );
v8::Context::Scope context_scope( context );
if( args.Length() < sizeof...(Args) )
{
v8::String::Utf8Value str( args.Callee()->GetName()->ToString() );
GetV8Isolate()->ThrowException( v8::String::NewFromUtf8( GetV8Isolate(), CFmtStr1024( "%s requires %d arguments; only %d given.", *str, (int)sizeof...(Args), (int)args.Length() ).String() ) );
return;
}
ObjType *pPanel = GetThisPtrForJSCall<ObjType>( args.Holder() );
if ( !pPanel )
return;
v8::Local<v8::Array> callbackArray = v8::Local<v8::Array>::Cast( args.Data() );
HACKY_FUNC_PTR_CASTER< RetType( ObjType::* )(Args...) > caster;
RestoreFuncPtr( caster, callbackArray, 0 );
bool *pbSucceeded = NULL;
if ( sizeof...(Args) > 0 )
{
pbSucceeded = new bool[sizeof...(Args)];
V_memset( pbSucceeded, 0, sizeof...(Args)* sizeof( bool ) );
}
STDTR1::tuple< Args... > tupleArgs;
ConvertV8ArgsToTuple< sizeof...(Args), STDTR1::tuple< Args... > >::Call( tupleArgs, args, pbSucceeded );
bool bSucceeded = true;
for ( int i = 0; i < sizeof...(Args); i++ )
{
if ( !pbSucceeded[i] )
bSucceeded = false;
}
if ( bSucceeded )
JSMethodCallTuple_Helper( pPanel, caster.funcPtr, args, typename make_indexes<Args...>::type(), tupleArgs );
FreeV8ArgsToTuple< sizeof...(Args), STDTR1::tuple< Args... > >::Call( tupleArgs, pbSucceeded );
delete[] pbSucceeded;
}
template< typename ObjType >
void JSMethodCallTupleRaw( const v8::FunctionCallbackInfo<v8::Value>& args )
{
v8::Isolate::Scope isolate_scope( args.GetIsolate() );
v8::HandleScope handle_scope( args.GetIsolate() );
v8::Persistent<v8::Context> &perContext = UIEngine()->GetV8GlobalContext();
v8::Handle<v8::Context> context = v8::Local<v8::Context>::New( GetV8Isolate(), perContext );
v8::Context::Scope context_scope( context );
ObjType *pPanel = GetThisPtrForJSCall<ObjType>( args.Holder() );
if ( !pPanel )
return;
v8::Local<v8::Array> callbackArray = v8::Local<v8::Array>::Cast( args.Data() );
HACKY_FUNC_PTR_CASTER< void ( ObjType::* )( const v8::FunctionCallbackInfo<v8::Value>& ) > caster;
RestoreFuncPtr( caster, callbackArray, 0 );
(pPanel->*caster.funcPtr)( args );
}
template< typename RetType, typename ...Args >
void JSFunctionCallTuple( const v8::FunctionCallbackInfo<v8::Value>& args )
{
v8::Isolate::Scope isolate_scope( args.GetIsolate() );
v8::HandleScope handle_scope( args.GetIsolate() );
v8::Persistent<v8::Context> &perContext = UIEngine()->GetV8GlobalContext();
v8::Handle<v8::Context> context = v8::Local<v8::Context>::New( GetV8Isolate(), perContext );
v8::Context::Scope context_scope( context );
if( args.Length() < sizeof...(Args) )
{
v8::String::Utf8Value str( args.Callee()->GetName()->ToString() );
GetV8Isolate()->ThrowException( v8::String::NewFromUtf8( GetV8Isolate(), CFmtStr1024( "%s requires %d arguments; only %d given.", *str, (int)sizeof...(Args), (int)args.Length() ).String() ) );
return;
}
v8::Local<v8::Array> callbackArray = v8::Local<v8::Array>::Cast( args.Data() );
HACKY_FUNC_PTR_CASTER< RetType( * )(Args...) > caster;
RestoreFuncPtr( caster, callbackArray, 0 );
bool *pbSucceeded = NULL;
if( sizeof...(Args) > 0 )
{
pbSucceeded = new bool[sizeof...(Args)];
V_memset( pbSucceeded, 0, sizeof...(Args)* sizeof( bool ) );
}
STDTR1::tuple< Args... > tupleArgs;
ConvertV8ArgsToTuple< sizeof...(Args), STDTR1::tuple< Args... > >::Call( tupleArgs, args, pbSucceeded );
bool bSucceeded = true;
for( int i = 0; i < sizeof...(Args); i++ )
{
if( !pbSucceeded[i] )
bSucceeded = false;
}
if( bSucceeded )
JSFunctionCallTuple_Helper( caster.funcPtr, args, typename make_indexes<Args...>::type(), tupleArgs );
FreeV8ArgsToTuple< sizeof...(Args), STDTR1::tuple< Args... > >::Call( tupleArgs, pbSucceeded );
delete[] pbSucceeded;
}
// Infer types for all arguments.
template< uint8 unIndex, typename Type1, typename ...Types >
struct RegisterJSTypesDeducer
{
static void Call( RegisterJSType_t *pTypes, uint8 unMaxIndex )
{
Assert( unIndex <= RegisterJSEntryInfo_t::k_unMaxParams );
if ( unIndex <= RegisterJSEntryInfo_t::k_unMaxParams )
{
pTypes[unMaxIndex - unIndex] = RegisterJSTypeDeducer_t<Type1>::Type();
#if defined( SOURCE2_PANORAMA )
RegisterJSTypesDeducer< unIndex - 1, Types... >::Call( pTypes, unMaxIndex );
#endif
}
}
};
template< typename Type1 >
struct RegisterJSTypesDeducer< 0, Type1 >
{
static void Call( RegisterJSType_t *pTypes, uint8 unMaxIndex )
{
// This is the termination placeholder.
}
};
// two RegisterJSMethods, one for const function pointers, one for mutable
template < typename ObjType, typename RetType, typename ...Args>
void RegisterJSMethod( const char *pchMethodName, RetType( ObjType::*mf )(Args...), const char *pDesc = NULL )
{
v8::Isolate::Scope isolate_scope( GetV8Isolate() );
v8::HandleScope handle_scope( GetV8Isolate() );
v8::Handle<v8::Array> callbackArray = v8::Array::New( GetV8Isolate(), 3 );
GetPtrToCallbackArray( mf, callbackArray );
v8::Handle<v8::ObjectTemplate> objTemplate = UIEngine()->GetCurrentV8ObjectTemplateToSetup();
objTemplate->Set( v8::String::NewFromUtf8( GetV8Isolate(), pchMethodName ), v8::FunctionTemplate::New( GetV8Isolate(), &JSMethodCallTuple<ObjType, RetType, Args...>, callbackArray ) );
int nEntry = UIEngine()->NewRegisterJSEntry( pchMethodName, RegisterJSEntryInfo_t::k_EMethod, pDesc, RegisterJSTypeDeducer_t<RetType>::Type() );
#if defined( SOURCE2_PANORAMA )
RegisterJSType_t pParamTypes[RegisterJSEntryInfo_t::k_unMaxParams];
RegisterJSTypesDeducer< sizeof...(Args), Args..., void >::Call( pParamTypes, sizeof...(Args) );
UIEngine()->SetRegisterJSEntryParams( nEntry, sizeof...(Args), pParamTypes );
#else
REFERENCE( nEntry );
#endif
}
template < typename ObjType, typename RetType, typename ...Args>
void RegisterJSMethod( const char *pchMethodName, RetType( ObjType::*mf )(Args...) const, const char *pDesc )
{
v8::Isolate::Scope isolate_scope( GetV8Isolate() );
v8::HandleScope handle_scope( GetV8Isolate() );
v8::Handle<v8::Array> callbackArray = v8::Array::New( GetV8Isolate(), 3 );
GetPtrToCallbackArray( mf, callbackArray );
v8::Handle<v8::ObjectTemplate> objTemplate = UIEngine()->GetCurrentV8ObjectTemplateToSetup();
objTemplate->Set( v8::String::NewFromUtf8( GetV8Isolate(), pchMethodName ), v8::FunctionTemplate::New( GetV8Isolate(), &JSMethodCallTuple<ObjType, RetType, Args...>, callbackArray ) );
int nEntry = UIEngine()->NewRegisterJSEntry( pchMethodName, RegisterJSEntryInfo_t::k_EMethod, pDesc, RegisterJSTypeDeducer_t<RetType>::Type() );
#if defined( SOURCE2_PANORAMA )
RegisterJSType_t pParamTypes[RegisterJSEntryInfo_t::k_unMaxParams];
RegisterJSTypesDeducer< sizeof...(Args), Args..., void >::Call( pParamTypes, sizeof...(Args) );
UIEngine()->SetRegisterJSEntryParams( nEntry, sizeof...(Args), pParamTypes );
#else
REFERENCE( nEntry );
#endif
}
template < typename RetType, typename ...Args>
void RegisterJSGlobalFunction( const char *pchJSFunctionName, RetType( *pFunc )(Args...), bool bTrueGlobal, const char *pDesc )
{
v8::Isolate::Scope isolate_scope( GetV8Isolate() );
v8::HandleScope handle_scope( GetV8Isolate() );
v8::Persistent<v8::Context> &perContext = UIEngine()->GetV8GlobalContext();
v8::Handle<v8::Context> context = v8::Local<v8::Context>::New( GetV8Isolate(), perContext );
v8::Context::Scope context_scope( context );
v8::Handle<v8::Array> callbackArray = v8::Array::New( GetV8Isolate(), 3 );
GetPtrToCallbackArray( pFunc, callbackArray );
v8::Handle< v8::FunctionTemplate > funcTempl = v8::FunctionTemplate::New( GetV8Isolate(), &JSFunctionCallTuple< RetType, Args...>, callbackArray );
UIEngine()->AddGlobalV8FunctionTemplate( pchJSFunctionName, &funcTempl, bTrueGlobal );
int nEntry = UIEngine()->NewRegisterJSEntry( pchJSFunctionName, RegisterJSEntryInfo_t::k_EGlobalFunction, pDesc, RegisterJSTypeDeducer_t<RetType>::Type() );
#if defined( SOURCE2_PANORAMA )
RegisterJSType_t pParamTypes[RegisterJSEntryInfo_t::k_unMaxParams];
RegisterJSTypesDeducer< sizeof...(Args), Args..., void >::Call( pParamTypes, sizeof...(Args) );
UIEngine()->SetRegisterJSEntryParams( nEntry, sizeof...(Args), pParamTypes );
#else
REFERENCE( nEntry );
#endif
}
inline void RegisterJSGlobalFunctionRaw( const char *pchJSFunctionName, void (*pCallbackFunc)( const v8::FunctionCallbackInfo< v8::Value > &callbackInfo ), bool bTrueGlobal, const char *pDesc = NULL )
{
v8::Isolate::Scope isolate_scope( GetV8Isolate() );
v8::HandleScope handle_scope( GetV8Isolate() );
v8::Persistent<v8::Context> &perContext = UIEngine()->GetV8GlobalContext();
v8::Handle<v8::Context> context = v8::Local<v8::Context>::New( GetV8Isolate(), perContext );
v8::Context::Scope context_scope( context );
v8::Handle< v8::FunctionTemplate > funcTempl = v8::FunctionTemplate::New( GetV8Isolate(), pCallbackFunc );
UIEngine()->AddGlobalV8FunctionTemplate( pchJSFunctionName, &funcTempl, bTrueGlobal );
int nEntry = UIEngine()->NewRegisterJSEntry( pchJSFunctionName, RegisterJSEntryInfo_t::k_EGlobalFunction, pDesc, k_ERegisterJSTypeVoid );
RegisterJSType_t pParamTypes[1] = { k_ERegisterJSTypeRawV8Args };
UIEngine()->SetRegisterJSEntryParams( nEntry, 1, pParamTypes );
}
template < typename ObjType >
inline void RegisterJSMethodRaw( const char *pchMethodName, void ( ObjType::*mf )( const v8::FunctionCallbackInfo< v8::Value > &callbackInfo ), const char *pDesc = NULL )
{
v8::Isolate::Scope isolate_scope( GetV8Isolate() );
v8::HandleScope handle_scope( GetV8Isolate() );
v8::Handle<v8::Array> callbackArray = v8::Array::New( GetV8Isolate(), 3 );
GetPtrToCallbackArray( mf, callbackArray );
v8::Handle<v8::ObjectTemplate> objTemplate = UIEngine()->GetCurrentV8ObjectTemplateToSetup();
objTemplate->Set( v8::String::NewFromUtf8( GetV8Isolate(), pchMethodName ), v8::FunctionTemplate::New( GetV8Isolate(), &JSMethodCallTupleRaw<ObjType>, callbackArray ) );
int nEntry = UIEngine()->NewRegisterJSEntry( pchMethodName, RegisterJSEntryInfo_t::k_EMethod, pDesc, k_ERegisterJSTypeVoid );
RegisterJSType_t pParamTypes[1] = { k_ERegisterJSTypeRawV8Args };
UIEngine()->SetRegisterJSEntryParams( nEntry, 1, pParamTypes );
}
inline v8::Local< v8::String > JSObjectToJSON( v8::Isolate *pIsolate, v8::Local< v8::Value > object )
{
v8::Local< v8::Context > context = pIsolate->GetCurrentContext();
v8::Local< v8::Object > global = context->Global();
v8::Local< v8::Object > global_JSON = v8::Handle< v8::Object >::Cast( global->Get( v8::String::NewFromUtf8( pIsolate, "JSON" ) ) );
v8::Local< v8::Function > global_JSON_stringify = v8::Handle< v8::Function >::Cast( global_JSON->Get( v8::String::NewFromUtf8( pIsolate, "stringify" ) ) );
v8::Local< v8::Value > args[] = { object };
return v8::Local< v8::String >::Cast( global_JSON_stringify->Call( global_JSON, 1, args ) );
}
}
#pragma warning(pop)
#if _GNUC
#pragma GCC diagnostic pop
#endif
#endif // _WIN32