tf2/tf2_src/public/panorama/uijsregistration.h

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