int CLuaFunctionDefs::RequestBrowserDomains ( lua_State* luaVM )
{
// bool requestBrowserDomains ( table domains, bool isURL [, function callback ] )
std::vector<SString> pages; bool bIsURL; CLuaFunctionRef callbackFunction;
CScriptArgReader argStream ( luaVM );
argStream.ReadStringTable ( pages );
argStream.ReadBool ( bIsURL, false );
argStream.ReadFunction ( callbackFunction, LUA_REFNIL );
argStream.ReadFunctionComplete ();
if ( !argStream.HasErrors () )
{
// Convert to domains if we got a list of URLs
if ( bIsURL )
{
for ( auto& strURL : pages )
{
strURL = g_pCore->GetWebCore ()->GetDomainFromURL ( strURL );
}
}
WebRequestCallback callback = [=]( bool bAllow, const std::vector<SString>& domains ) {
// Test if luaVM is still available
if ( m_pLuaManager->IsLuaVMValid ( luaVM ) && VERIFY_FUNCTION ( callbackFunction ) )
{
CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
if ( !pLuaMain )
return;
CLuaArguments arguments;
arguments.PushBoolean ( bAllow );
CLuaArguments LuaTable;
int i = 0;
for ( const auto& domain : domains )
{
LuaTable.PushNumber ( ++i );
LuaTable.PushString ( domain );
}
arguments.PushTable ( &LuaTable );
arguments.Call ( pLuaMain, callbackFunction );
}
};
g_pCore->GetWebCore ()->RequestPages ( pages, VERIFY_FUNCTION ( callbackFunction ) ? &callback : nullptr );
lua_pushboolean ( luaVM, true );
return 1;
}
else
m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
lua_pushboolean ( luaVM, false );
return 1;
}
int CLuaDatabaseDefs::OOP_DbQuery ( lua_State* luaVM )
{
// handle dbQuery ( [ function callbackFunction, [ table callbackArguments, ] ] element connection, string query, ... )
CLuaFunctionRef iLuaFunction; CLuaArguments callbackArgs; CDatabaseConnectionElement* pElement; SString strQuery; CLuaArguments Args;
CScriptArgReader argStream ( luaVM );
argStream.ReadUserData ( pElement );
if ( argStream.NextIsFunction () )
{
argStream.ReadFunction ( iLuaFunction );
if ( argStream.NextIsTable () )
{
argStream.ReadLuaArgumentsTable( callbackArgs );
}
}
argStream.ReadString ( strQuery );
argStream.ReadLuaArguments ( Args );
argStream.ReadFunctionComplete ();
if ( !argStream.HasErrors () )
{
// Start async query
CDbJobData* pJobData = g_pGame->GetDatabaseManager ()->QueryStart ( pElement->GetConnectionHandle (), strQuery, &Args );
if ( !pJobData )
{
if ( !g_pGame->GetDatabaseManager ()->IsLastErrorSuppressed () )
m_pScriptDebugging->LogWarning ( luaVM, "%s failed; %s", lua_tostring ( luaVM, lua_upvalueindex ( 1 ) ), *g_pGame->GetDatabaseManager ()->GetLastErrorMessage () );
lua_pushboolean ( luaVM, false );
return 1;
}
// Make callback function if required
if ( VERIFY_FUNCTION ( iLuaFunction ) )
{
CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
if ( pLuaMain )
{
CLuaArguments Arguments;
Arguments.PushDbQuery ( pJobData );
Arguments.PushArguments ( callbackArgs );
pJobData->SetCallback ( CLuaDatabaseDefs::DbQueryCallback, g_pGame->GetLuaCallbackManager ()->CreateCallback ( pLuaMain, iLuaFunction, Arguments ) );
}
}
// Add debug info incase query result does not get collected
pJobData->SetLuaDebugInfo ( g_pGame->GetScriptDebugging ()->GetLuaDebugInfo ( luaVM ) );
lua_pushquery ( luaVM, pJobData );
return 1;
}
else
m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
lua_pushboolean ( luaVM, false );
return 1;
}
int CLuaFunctionDefs::GetBrowserSource ( lua_State* luaVM )
{
// bool getBrowserSource ( function callback )
CClientWebBrowser* pWebBrowser; CLuaFunctionRef callbackFunction;
CScriptArgReader argStream ( luaVM );
argStream.ReadUserData ( pWebBrowser );
argStream.ReadFunction ( callbackFunction );
argStream.ReadFunctionComplete ();
if ( !argStream.HasErrors () )
{
CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
if ( pLuaMain && VERIFY_FUNCTION ( callbackFunction ) )
{
pWebBrowser->GetSourceCode ( [callbackFunction, pLuaMain]( const std::string& code ) {
/*
This function should not be called when the resource is about to stop as
stopping the resource destroys the browser element and thus cancels the
CefStringVisitor callback class (see CWebView::GetSourceCode::MyStringVisitor)
*/
if ( VERIFY_FUNCTION ( callbackFunction ) )
{
CLuaArguments arguments;
// TODO: Use SCharStringRef/direct string access instead of copying strings around
arguments.PushString ( code );
arguments.Call ( pLuaMain, callbackFunction );
}
});
lua_pushboolean ( luaVM, true );
return 1;
}
}
else
m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
lua_pushboolean ( luaVM, false );
return 1;
}
void CKeyBinds::Call ( CKeyBind* pKeyBind )
{
if ( pKeyBind && !pKeyBind->IsBeingDeleted () )
{
switch ( pKeyBind->GetType () )
{
case KEY_BIND_FUNCTION:
{
CKeyFunctionBind* pBind = static_cast < CKeyFunctionBind* > ( pKeyBind );
if ( pBind->luaMain && VERIFY_FUNCTION ( pBind->m_iLuaFunction ) )
{
CLuaArguments Arguments;
Arguments.PushElement ( m_pPlayer );
Arguments.PushString ( pBind->boundKey->szKey );
Arguments.PushString ( ( pBind->bHitState ) ? "down" : "up" );
Arguments.PushArguments ( pBind->m_Arguments );
Arguments.Call ( pBind->luaMain, pBind->m_iLuaFunction );
}
break;
}
case KEY_BIND_CONTROL_FUNCTION:
{
CControlFunctionBind* pBind = static_cast < CControlFunctionBind* > ( pKeyBind );
if ( pBind->luaMain && VERIFY_FUNCTION ( pBind->m_iLuaFunction ) )
{
CLuaArguments Arguments;
Arguments.PushElement ( m_pPlayer );
Arguments.PushString ( pBind->boundControl->szControl );
Arguments.PushString ( ( pBind->bHitState ) ? "down" : "up" );
Arguments.PushArguments ( pBind->m_Arguments );
Arguments.Call ( pBind->luaMain, pBind->m_iLuaFunction );
}
break;
}
default:
break;
}
}
}
bool CRegisteredCommands::RemoveCommand(CLuaMain* pLuaMain, const char* szKey, const CLuaFunctionRef& iLuaFunction)
{
assert(pLuaMain);
assert(szKey);
// Call the handler for every virtual machine that matches the given key
int iCompareResult;
bool bFound = false;
list<SCommand*>::iterator iter = m_Commands.begin();
while (iter != m_Commands.end())
{
if ((*iter)->bCaseSensitive)
iCompareResult = strcmp((*iter)->strKey.c_str(), szKey);
else
iCompareResult = stricmp((*iter)->strKey.c_str(), szKey);
// Matching VM's and names?
if ((*iter)->pLuaMain == pLuaMain && iCompareResult == 0)
{
if (VERIFY_FUNCTION(iLuaFunction) && (*iter)->iLuaFunction != iLuaFunction)
{
iter++;
continue;
}
// Delete it and remove it from our list
if (m_bIteratingList)
{
m_TrashCan.push_back(*iter);
++iter;
}
else
{
delete *iter;
iter = m_Commands.erase(iter);
}
bFound = true;
}
else
++iter;
}
return bFound;
}
LuaTimer* LuaTimerManager::AddTimer( lua_State *L, const LuaFunctionRef& ref, CTickCount delay, unsigned int repCount )
{
// Check for the minimum interval
if ( delay.ToLongLong() < LUA_TIMER_MIN_INTERVAL )
return NULL;
if ( !VERIFY_FUNCTION( ref ) )
return NULL;
// Add the timer
LuaTimer *timer = new LuaTimer( L, this, ref );
timer->SetStartTime( CTickCount::Now () );
timer->SetDelay( delay );
timer->SetRepeats( repCount );
m_list.push_back( timer );
return timer;
}
CLuaTimer* CLuaTimerManager::AddTimer ( const CLuaFunctionRef& iLuaFunction, CTickCount llTimeDelay, unsigned int uiRepeats, const CLuaArguments& Arguments )
{
// Check for the minimum interval
if ( llTimeDelay.ToLongLong () < LUA_TIMER_MIN_INTERVAL )
return NULL;
if ( VERIFY_FUNCTION ( iLuaFunction ) )
{
// Add the timer
CLuaTimer* pLuaTimer = new CLuaTimer ( iLuaFunction, Arguments );
pLuaTimer->SetStartTime ( CTickCount::Now () );
pLuaTimer->SetDelay ( llTimeDelay );
pLuaTimer->SetRepeats ( uiRepeats );
m_TimerList.push_back ( pLuaTimer );
return pLuaTimer;
}
return NULL;
}
int CLuaFunctionDefs::AddCommandHandler ( lua_State* luaVM )
{
// Grab our VM
CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
if ( pLuaMain )
{
// Got two strings?
int iArgument1 = lua_type ( luaVM, 1 );
int iArgument2 = lua_type ( luaVM, 2 );
if ( iArgument1 == LUA_TSTRING && iArgument2 == LUA_TFUNCTION )
{
// Check if the command name is case sensitive
bool bCaseSensitive = true;
if ( lua_type ( luaVM, 3 ) == LUA_TBOOLEAN )
bCaseSensitive = ( ( lua_toboolean ( luaVM, 3 ) == 0 ) ? false : true );
// Grab the strings. Valid?
const char* szKey = lua_tostring ( luaVM, 1 );
int iLuaFunction = luaM_toref ( luaVM, 2 );
if ( szKey [0] != 0 && VERIFY_FUNCTION ( iLuaFunction ) )
{
// Add them to our list over command handlers
if ( m_pRegisteredCommands->AddCommand ( pLuaMain, szKey, iLuaFunction, bCaseSensitive ) )
{
lua_pushboolean ( luaVM, true );
return 1;
}
}
else
m_pScriptDebugging->LogWarning ( luaVM, "Empty key or handler strings sent to addCommandHandler" );
}
else
m_pScriptDebugging->LogBadType ( luaVM, "addCommandHandler" );
}
lua_pushboolean ( luaVM, false );
return 1;
}
int CLuaFunctionDefs::SetBrowserAjaxHandler ( lua_State* luaVM )
{
// bool setBrowserAjaxHandler ( browser browser, string URL[, function callback] )
CClientWebBrowser* pWebBrowser; SString strURL; CLuaFunctionRef callbackFunction;
CScriptArgReader argStream ( luaVM );
argStream.ReadUserData ( pWebBrowser );
argStream.ReadString ( strURL );
if ( argStream.NextIsNil () || argStream.NextIsNone () )
{
if ( !argStream.HasErrors () )
{
lua_pushboolean ( luaVM, pWebBrowser->RemoveAjaxHandler ( strURL ) );
return 1;
}
else
m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
}
else
{
argStream.ReadFunction ( callbackFunction );
argStream.ReadFunctionComplete ();
if ( !argStream.HasErrors () )
{
CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine ( luaVM );
if ( pLuaMain && VERIFY_FUNCTION ( callbackFunction ) )
{
CResource* pResource = pLuaMain->GetResource ();
CResourceManager * pResourceManager = m_pResourceManager;
auto netId = pResource->GetNetID ();
bool bResult = pWebBrowser->AddAjaxHandler ( strURL,
[=] ( std::vector<SString>& vecGet, std::vector<SString>& vecPost ) -> const SString
{
// Make sure the resource is still running
if ( !pResourceManager->Exists ( pResource ) || pResource->GetNetID() != netId )
{
return "";
}
// Make sure the function is valid
if ( VERIFY_FUNCTION ( callbackFunction ) )
{
CLuaArguments arguments;
CLuaArguments getArguments;
CLuaArguments postArguments;
for ( auto&& param : vecGet )
getArguments.PushString ( param );
for ( auto&& param : vecPost )
postArguments.PushString ( param );
arguments.PushTable ( &getArguments );
arguments.PushTable ( &postArguments );
CLuaArguments result;
arguments.Call ( pLuaMain, callbackFunction, &result );
if ( result.Count () == 0 )
return "";
CLuaArgument* returnedValue = *result.IterBegin ();
if ( returnedValue->GetType () == LUA_TSTRING )
return returnedValue->GetString ();
else
return "";
}
else
return "";
} );
lua_pushboolean ( luaVM, bResult );
return 1;
}
}
else
m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
}
lua_pushboolean ( luaVM, false );
return 1;
}