ui_lua.cpp

Go to the documentation of this file.

/*
Copyright (C) 2002-2020 UFO: Alien Invasion.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/


#include "ui_lua.h"

#include "../../shared/cxx.h"
#include "../../shared/defines.h"
#include "../../shared/shared.h"
#include "../../common/cvar.h"
#include "../../common/hashtable.h"
#include "../../common/filesys.h"
#include "../../common/scripts_lua.h"
#include "../cl_lua.h"

//#include "../client.h"
#include "ui_main.h"
#include "ui_components.h"
#include "ui_behaviour.h"
#include "ui_node.h"
#include "ui_parse.h"
#include "ui_internal.h"

#include "../../common/swig_lua_runtime.h"

/* internal field for passing script name as a key to lua registration functions */
char ui_scriptname[256] = "";


void UI_InitLua (void) {
}

void UI_ShutdownLua (void) {
}

bool UI_ExecuteLuaEventScript (uiNode_t* node, LUA_EVENT event)
{
    lua_rawgeti(CL_GetLuaState(), LUA_REGISTRYINDEX, event); /* push event function on lua stack */
    SWIG_NewPointerObj(CL_GetLuaState(), node, static_cast<swig_type_info*>(node->behaviour->lua_SWIG_typeinfo), 0); /* push sender on lua stack */
    if (lua_pcall(CL_GetLuaState(), 1, 0, 0) != 0) {
        Com_Printf("UI_ExecuteLuaEventScript\n");
        Com_Printf ("lua error(0) [node=%s, behaviour=%s]: %s\n", UI_GetPath(node), node->behaviour->name, lua_tostring(CL_GetLuaState(), -1));
        return false;
    }
    return true;
}

bool UI_ExecuteLuaEventScript_ParamList (uiNode_t* node, LUA_EVENT event, linkedList_t* params)
{
    lua_rawgeti(CL_GetLuaState(), LUA_REGISTRYINDEX, event); /* push event function on lua stack */
    SWIG_NewPointerObj(CL_GetLuaState(), node, static_cast<swig_type_info*>(node->behaviour->lua_SWIG_typeinfo), 0); /* push sender on lua stack */
    int nparams = 0;
    LIST_Foreach(params, char, parameter) {
        lua_pushstring(CL_GetLuaState(), parameter);
        nparams++;
    }
    if (lua_pcall(CL_GetLuaState(), nparams + 1, 0, 0) != 0) {
        Com_Printf("UI_ExecuteLuaEventScript\n");
        Com_Printf ("lua error(0) [node=%s, behaviour=%s]: %s\n", UI_GetPath(node), node->behaviour->name, lua_tostring(CL_GetLuaState(), -1));
        return false;
    }
    return true;
}

bool UI_ExecuteLuaEventScript_ReturnBool (uiNode_t* node, LUA_EVENT event, bool &result)
{
    lua_rawgeti (CL_GetLuaState (), LUA_REGISTRYINDEX, event); /* push event function on lua stack */
    SWIG_NewPointerObj (CL_GetLuaState(), node, static_cast<swig_type_info*>(node->behaviour->lua_SWIG_typeinfo), 0); /* push sender on lua stack */
    if (lua_pcall (CL_GetLuaState(), 1, 1, 0) != 0) {
        Com_Printf("UI_ExecuteLuaEventScript_ReturnBool\n");
        Com_Printf ("lua error(0) [node=%s, behaviour=%s]: %s\n", UI_GetPath(node), node->behaviour->name, lua_tostring(CL_GetLuaState(), -1));
        return false;
    }
    if (!lua_isboolean(CL_GetLuaState(), -1)) {
        Com_Printf("UI_ExecuteLuaEventScript_ReturnBool\n");
        Com_Printf ("lua error(0) [node=%s, behaviour=%s]: expecting a boolean as return value\n", UI_GetPath(node), node->behaviour->name);
        return false;
    }
    result = lua_toboolean(CL_GetLuaState(), -1);
    return true;
}

bool UI_ExecuteLuaEventScript_XY (uiNode_t* node, LUA_EVENT event, int x, int y)
{
    lua_rawgeti(CL_GetLuaState(), LUA_REGISTRYINDEX, event); /* push event function on lua stack */
    SWIG_NewPointerObj(CL_GetLuaState(), node, static_cast<swig_type_info*>(node->behaviour->lua_SWIG_typeinfo), 0); /* push sender on lua stack */
    lua_pushinteger(CL_GetLuaState(), x); /* push x on lua stack */
    lua_pushinteger(CL_GetLuaState(), y); /* push y on lua stack */
    if (lua_pcall(CL_GetLuaState(), 3, 0, 0) != 0) {
        Com_Printf("UI_ExecuteLuaEventScript_XY\n");
        Com_Printf("lua error(0) [node=%s, behaviour=%s]: %s\n", UI_GetPath(node), node->behaviour->name, lua_tostring(CL_GetLuaState(), -1));
        return false;
    }
    return true;
}

bool UI_ExecuteLuaEventScript_DxDy (uiNode_t* node, LUA_EVENT event, int dx, int dy)
{
    lua_rawgeti(CL_GetLuaState(), LUA_REGISTRYINDEX, event); /* push event function on lua stack */
    SWIG_NewPointerObj(CL_GetLuaState(), node, static_cast<swig_type_info*>(node->behaviour->lua_SWIG_typeinfo), 0); /* push sender on lua stack */
    lua_pushinteger(CL_GetLuaState(), dx); /* push dx on lua stack */
    lua_pushinteger(CL_GetLuaState(), dy); /* push dy on lua stack */
    if (lua_pcall(CL_GetLuaState(), 3, 0, 0) != 0) {
        Com_Printf("UI_ExecuteLuaEventScript_DxDy\n");
        Com_Printf("lua error(0) [node=%s, behaviour=%s]: %s\n", UI_GetPath(node), node->behaviour->name, lua_tostring(CL_GetLuaState(), -1));
        return false;
    }
    return true;
}

bool UI_ExecuteLuaEventScript_Key (uiNode_t* node, LUA_EVENT event, unsigned int key, unsigned short unicode)
{
    lua_rawgeti(CL_GetLuaState(), LUA_REGISTRYINDEX, event); /* push event function on lua stack */
    SWIG_NewPointerObj(CL_GetLuaState(), node, static_cast<swig_type_info*>(node->behaviour->lua_SWIG_typeinfo), 0); /* push sender on lua stack */
    lua_pushinteger(CL_GetLuaState(), key); /* push key on lua stack */
    lua_pushinteger(CL_GetLuaState(), unicode); /* push unicode on lua stack */
    if (lua_pcall(CL_GetLuaState(), 3, 0, 0) != 0) {
        Com_Printf("UI_ExecuteLuaEventScript_Key\n");
        Com_Printf("lua error(0) [node=%s, behaviour=%s]: %s\n", UI_GetPath(node), node->behaviour->name, lua_tostring(CL_GetLuaState(), -1));
        return false;
    }
    return true;
}

bool UI_ExecuteLuaEventScript_DragDrop (uiNode_t* node, LUA_EVENT event, bool &result)
{
    lua_rawgeti(CL_GetLuaState(), LUA_REGISTRYINDEX, event); /* push event function on lua stack */
    SWIG_NewPointerObj(CL_GetLuaState(), node, static_cast<swig_type_info*>(node->behaviour->lua_SWIG_typeinfo), 0); /* push sender on lua stack */
    if (lua_pcall(CL_GetLuaState(), 1, 1, 0) != 0) {
        Com_Printf("UI_ExecuteLuaEventScript_DragDrop\n");
        Com_Printf ("lua error(0) [node=%s, behaviour=%s]: %s\n", UI_GetPath(node), node->behaviour->name, lua_tostring(CL_GetLuaState(), -1));
        return false;
    }
    if (!lua_isboolean(CL_GetLuaState(), -1)) {
        Com_Printf ("lua error(0) [node=%s, behaviour=%s]: expecting a boolean as return value\n", UI_GetPath(node), node->behaviour->name);
        return false;
    }
    result = lua_toboolean(CL_GetLuaState(), -1);
    return true;
}

bool UI_ExecuteLuaEventScript_DragDrop_XY (uiNode_t* node, LUA_EVENT event, int x, int y, bool &result)
{
    lua_rawgeti(CL_GetLuaState(), LUA_REGISTRYINDEX, event); /* push event function on lua stack */
    SWIG_NewPointerObj(CL_GetLuaState(), node, static_cast<swig_type_info*>(node->behaviour->lua_SWIG_typeinfo), 0); /* push sender on lua stack */
    lua_pushinteger(CL_GetLuaState(), x); /* push x to lua stack */
    lua_pushinteger(CL_GetLuaState(), y); /* push y to lua stack */
    if (lua_pcall(CL_GetLuaState(), 3, 1, 0) != 0) {
        Com_Printf("UI_ExecuteLuaEventScript_DragDrop_XY\n");
        Com_Printf("lua error(0) [node=%s, behaviour=%s]: %s\n", UI_GetPath(node), node->behaviour->name, lua_tostring(CL_GetLuaState(), -1));
        return false;
    }
    if (!lua_isboolean(CL_GetLuaState(), -1)) {
        Com_Printf("lua error(0) [node=%s, behaviour=%s]: expecting a boolean as return value\n", UI_GetPath(node), node->behaviour->name);
        return false;
    }
    result = lua_toboolean(CL_GetLuaState(), -1);
    return true;
}

bool UI_ExecuteLuaEventScript_DragDrop_IsDropped (uiNode_t* node, LUA_EVENT event, bool isDropped, bool &result)
{
    lua_rawgeti(CL_GetLuaState(), LUA_REGISTRYINDEX, event); /* push event function on lua stack */
    SWIG_NewPointerObj(CL_GetLuaState(), node, static_cast<swig_type_info*>(node->behaviour->lua_SWIG_typeinfo), 0); /* push sender on lua stack */
    lua_pushboolean(CL_GetLuaState(), isDropped); /* push isDropped to lua stack */
    if (lua_pcall(CL_GetLuaState(), 2, 1, 0) != 0) {
        Com_Printf("UI_ExecuteLuaEventScript_DragDrop_IsDropped\n");
        Com_Printf("lua error(0) [node=%s, behaviour=%s]: %s\n", UI_GetPath(node), node->behaviour->name, lua_tostring(CL_GetLuaState(), -1));
        return false;
    }
    if (!lua_isboolean(CL_GetLuaState(), -1)) {
        Com_Printf("lua error(0) [node=%s, behaviour=%s]: expecting a boolean as return value\n", UI_GetPath(node), node->behaviour->name);
        return false;
    }
    result = lua_toboolean(CL_GetLuaState(), -1);
    return true;
}

bool UI_ExecuteLuaMethod (uiNode_t* node, LUA_FUNCTION fcn, linkedList_t* params, int nparams)
{
    lua_rawgeti(CL_GetLuaState(), LUA_REGISTRYINDEX, fcn); /* push event function on lua stack */
    SWIG_NewPointerObj(CL_GetLuaState(), node, static_cast<swig_type_info*>(node->behaviour->lua_SWIG_typeinfo), 0); /* push sender on lua stack */
    /* push parameters on stack -> note: all the parameters are pushed as strings, since this is the only
     * parameter type the old-style script can handle */
    for (int i = 0; i < nparams; i++) {
        const char* value = const_cast<const char*>((char*)LIST_GetByIdx(params, i));
        lua_pushstring(CL_GetLuaState(), value);
    }
    if (lua_pcall(CL_GetLuaState(), nparams + 1, 0, 0) != 0) {
        Com_Printf("UI_ExecuteLuaMethod\n");
        Com_Printf("lua error(0) [node=%s, behaviour=%s]: %s\n", UI_GetPath(node), node->behaviour->name, lua_tostring(CL_GetLuaState(), -1));
        return false;
    }
    return true;
}

bool UI_ExecuteLuaConFunc (uiNode_t* node, LUA_FUNCTION fcn)
{
    lua_rawgeti(CL_GetLuaState(), LUA_REGISTRYINDEX, fcn); /* push event function on lua stack */
    SWIG_NewPointerObj(CL_GetLuaState(), node, static_cast<swig_type_info*>(node->behaviour->lua_SWIG_typeinfo), 0); /* push sender on lua stack */
    /* read parameters from cmd and push them on the stack; first parameter is skipped, since this is the
     * function name; all parameters are strings */
    for (int i = 1; i < Cmd_Argc(); i++)
        lua_pushstring(CL_GetLuaState(), Cmd_Argv(i));

    /* execute the confunc */
    if (lua_pcall(CL_GetLuaState(), Cmd_Argc(), 0, 0) != 0) {
        Com_Printf("UI_ExecuteLuaConFunc\n");
        Com_Printf ("lua error(0) [node=%s, behaviour=%s]: %s\n", UI_GetPath(node), node->behaviour->name, lua_tostring(CL_GetLuaState(), -1));
        return false;
    }
    return true;
}

bool UI_ExecuteLuaMethod_ByName (uiNode_t* node, const char* name, linkedList_t* params, int nparams)
{
    LUA_FUNCTION fn;
    if (UI_GetNodeMethod(node, name, fn)) {
        return UI_ExecuteLuaMethod(node, fn, params, nparams);
    }
    Com_Printf("UI_ExecuteNodeMethod_ByName: calling undefined method %s on node %s\n", name, node->name);
    return false;
}

void UI_RegisterHandler_OnLoad (LUA_FUNCTION fcn)
{
    CL_RegisterCallback(ui_scriptname, fcn);
}

void UI_CallHandler_OnLoad (lua_State* L, const char* key)
{
    CL_ExecuteCallback(L, key);
}

bool UI_ParseAndLoadLuaScript (const char* name, const char** text)
{
    /* determine the length of the string buffer */
    int ntext = strlen(*text);
    /* signal lua file found */
    Com_Printf("UI_ParseAndLoadLuaScript: %s\n", name);
    /* load the contents of the lua file */
    if (luaL_loadbuffer(CL_GetLuaState(), *text, ntext, name) == 0) {
        /* set the script name for calls to the registration functions */
        Q_strncpyz (ui_scriptname, name, sizeof(ui_scriptname));
        /* the script is loaded, now execute it; this will trigger any register_XXXX functions to be
         * called by the lua script */
        if (lua_pcall(CL_GetLuaState(), 0, LUA_MULTRET, 0) != 0) {
            Com_Printf("lua error: %s\n", lua_tostring(CL_GetLuaState(), -1));
        }
        else {
            /* at this point the lua file is loaded and callbacks are registered (on the stack),
               now call the onLoad if it exists */
            UI_CallHandler_OnLoad (CL_GetLuaState(), name);
        }
        ui_scriptname[0] = '\0';
    } else {
        Com_Error(0, "lua load error: %s\n", lua_tostring(CL_GetLuaState(), -1));
    }
    /* reset the content pointer, this will force the cached content to be released
       FS_NextScriptHeader. */
    *text = nullptr;
    /* execute the onLoad function */
    return true;
}

uiNode_t* UI_CreateControl (uiNode_t* parent, const char* type, const char* name, const char* super)
{
    uiNode_t* node = nullptr;
    uiNode_t* node_super = nullptr;
    uiNode_t* inherited_control = nullptr;
    uiBehaviour_t* behaviour = nullptr;

    /* get the behaviour */
    behaviour = UI_GetNodeBehaviour(type);
    if (!behaviour) {
        /* if behaviour class not found, try to get a component of this name*/
        inherited_control = UI_GetComponent(type);
        if (!inherited_control) {
            Com_Printf("UI_CreateControl: node behaviour/control '%s' doesn't exist (%s)\n", type, UI_GetPath(parent));
            return nullptr;
        }
        behaviour = inherited_control->behaviour;
    }
    /* get the super if it exists */
    if (super) {
        node_super = UI_GetComponent(super);
        /* validate the behaviour matches with the type requested */
        if (node_super) {
            if (node_super->behaviour != behaviour) {
                Com_Printf("UI_CreateControl: behaviour [%s] of super does not match requested type [%s]\n", behaviour->name, node_super->behaviour->name);
                return nullptr;
            }
        }
    }

    /* check the name */
    if (!UI_TokenIsName(name, false)) {
        Com_Printf("UI_CreateControl: \"%s\" is not a well formed node name ([a-zA-Z_][a-zA-Z0-9_]*)\n", name);
        return nullptr;
    }
    if (UI_TokenIsReserved(name)) {
        Com_Printf("UI_CreateControl: \"%s\" is a reserved token, we can't call a node with it\n", name);
        return nullptr;
    }

    /* test if node already exists (inside the parent subtree) */
    /* Already existing node should only come from inherited node, we should not have 2 definitions of the same node into the same window. */
    if (parent)
        node = UI_GetNode(parent, name);

    /* reuse a node */
    if (node) {
        if (!node->super) {
            Com_Printf("UI_CreateControl: trying to create duplicate node [%s]\n", UI_GetPath(node));
            return nullptr;
        }
        const uiBehaviour_t* test = (behaviour != nullptr) ? behaviour : (inherited_control != nullptr) ? inherited_control->behaviour : nullptr;
        if (node->behaviour != test) {
            Com_Printf("UI_CreateControl: we can't change node type (node \"%s\")\n", UI_GetPath(node));
            return nullptr;
        }
        Com_DPrintf(DEBUG_CLIENT, "... over-riding node %s\n", UI_GetPath(node));
    } else {
        /* clone using super */
        if (node_super) {
            node = UI_CloneNode(node_super, nullptr, true, name, true);
        }
        /* else try creating a clone of the component */
        else if (inherited_control) {
            /* initialize from a component */
            node = UI_CloneNode(inherited_control, nullptr, true, name, true);
        }
        /* else initialize a new node */
        else {
            node = UI_AllocNode(name, behaviour->name, true);
        }

        if (parent) {
            UI_AppendNode(parent, node);
            if (node_super || inherited_control)
                UI_UpdateRoot(node, parent->root);
        }
    }

    /* call onload (properties are set from lua) */
    UI_Node_Loaded(node);

    return node;
}

void UI_PrintNodeTree (uiNode_t* node, int level)
{
    int i;
    char* indent = new char[level + 1];
    for (i = 0; i < level; i++) {
        indent[i] = '\t';
    }
    indent[i] = '\0';

    Com_Printf("%s[%s]\n", indent, node->name);
    for (uiNode_t* child = node->firstChild; child; child = child->next) {
        UI_PrintNodeTree(child, level + 1);
    }
    delete[] indent;
}

const char* UI_Node_TypeOf(uiNode_t* node)
{
    if (node) {
        return node->behaviour->name;
    }
    return nullptr;
}

uiNode_t* UI_CreateComponent (const char* type, const char* name, const char* super)
{
    uiNode_t* node_super = nullptr;
    uiNode_t* component = nullptr;
    uiNode_t* inherited = nullptr;
    uiBehaviour_t* behaviour = nullptr;

    /* check the name */
    if (!UI_TokenIsName(name, false)) {
        Com_Printf("UI_CreateComponent: \"%s\" is not a well formed node name ([a-zA-Z_][a-zA-Z0-9_]*)\n", name);
        return nullptr;
    }
    if (UI_TokenIsReserved(name)) {
        Com_Printf("UI_CreateComponent: \"%s\" is a reserved token, we can't call a node with it\n", name);
        return nullptr;
    }

    /* get the type of behaviour */
    behaviour = UI_GetNodeBehaviour(type);
    if (!behaviour) {
        /* if no default behaviour found, try to get a custom component */
        inherited = UI_GetComponent(type);
        if (!inherited) {
            Com_Printf("UI_CreateComponent: node behaviour/control '%s' doesn't exist\n", type);
            return nullptr;
        }
    }
    /* get the super if it exists */
    if (super) {
        node_super = UI_GetComponent(super);
        /* validate the behaviour matches with the type requested */
        if (node_super) {
            if (node_super->behaviour != behaviour) {
                Com_Printf("UI_CreateComponent: behaviour [%s] of super does not match requested type [%s]\n", behaviour->name, node_super->behaviour->name);
                return nullptr;
            }
        }
    }

    /* clone using super */
    if (node_super) {
        component = UI_CloneNode(node_super, nullptr, true, name, true);
    }
    /* else initialize a new node */
    else {
        /* use inherited if available */
        if (inherited) {
            component = UI_CloneNode(inherited, nullptr, true, name, true);
        }
        /* else use the behaviour type */
        else {
            component = UI_AllocNode(name, behaviour->name, true);
        }
    }

    /* call onload (properties are set and controls are created from lua) */
    UI_Node_Loaded(component);

    /* add to list of instantiated components */
    UI_InsertComponent(component);

    //Com_Printf("UI_CreateComponent: registered new component, name [%s], type [%s]\n", name, type);

    return component;
}

uiNode_t* UI_CreateWindow (const char* type, const char* name, const char* super)
{
    /* make sure we create windows only here */
    if (!Q_streq(type, "window")) {
        Com_Error(ERR_FATAL, "UI_CreateWindow: '%s %s' is not a window node\n", type, name);
        return nullptr; /* never reached */
    }
    /* make sure the name of the window is a correct identifier */
    /* note: since this is called from lua, name is never quoted */
    if (!UI_TokenIsName(name, false)) {
        Com_Printf("UI_CreateWindow: \"%s\" is not a well formed node name ([a-zA-Z_][a-zA-Z0-9_]*)\n", name);
        return nullptr;
    }
    /* make sure the name of the window is not a reserverd word */
    if (UI_TokenIsReserved(name)) {
        Com_Printf("UI_CreateWindow: \"%s\" is a reserved token, we can't call a node with it (node \"%s\")\n", name, name);
        return nullptr;
    }

    /* search for windows with same name */
    int i;
    for (i = 0; i < ui_global.numWindows; i++)
        if (!strncmp(name, ui_global.windows[i]->name, sizeof(ui_global.windows[i]->name)))
            break;

    if (i < ui_global.numWindows) {
        Com_Printf("UI_CreateWindow: %s \"%s\" with same name found, second ignored\n", type, name);
    }

    if (ui_global.numWindows >= UI_MAX_WINDOWS) {
        Com_Error(ERR_FATAL, "UI_CreateWindow: max windows exceeded (%i) - ignore '%s'\n", UI_MAX_WINDOWS, name);
        return nullptr; /* never reached */
    }

    /* create the window */
    uiNode_t* window;

    /* does this window inherit data from another window? */
    if (super != nullptr) {
        uiNode_t* superWindow;
        superWindow = UI_GetWindow(super);
        if (superWindow == nullptr) {
            Sys_Error("Could not get the super window \"%s\"", super);
        }
        window = UI_CloneNode(superWindow, nullptr, true, name, true);
    } else {
        window = UI_AllocNode(name, type, true);
        window->root = window;
    }

    /* call onload (properties are set and controls are created from lua) */
    UI_Node_Loaded(window);

    /* add to list of instantiated windows */
    UI_InsertWindow(window);

    return window;
}