ui_nodes.cpp

Go to the documentation of this file.

 
/*
Copyright (C) 2002-2025 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 "../../common/hashtable.h"
#include "../../common/scripts_lua.h"
 
#include "ui_main.h"
#include "ui_internal.h"
#include "ui_behaviour.h"
#include "ui_node.h"
#include "ui_nodes.h"
#include "ui_parse.h"
#include "ui_input.h"
 
#include "node/ui_node_abstractnode.h"
#include "node/ui_node_abstractscrollbar.h"
#include "node/ui_node_abstractoption.h"
#include "node/ui_node_abstractvalue.h"
#include "node/ui_node_bar.h"
#include "node/ui_node_base.h"
#include "node/ui_node_baseinventory.h"
#include "node/ui_node_battlescape.h"
#include "node/ui_node_button.h"
#include "node/ui_node_checkbox.h"
#include "node/ui_node_controls.h"
#include "node/ui_node_container.h"
#include "node/ui_node_data.h"
#include "node/ui_node_editor.h"
#include "node/ui_node_geoscape.h"
#include "node/ui_node_image.h"
#include "node/ui_node_item.h"
#include "node/ui_node_linechart.h"
#include "node/ui_node_material_editor.h"
#include "node/ui_node_messagelist.h"
#include "node/ui_node_model.h"
#include "node/ui_node_option.h"
#include "node/ui_node_optionlist.h"
#include "node/ui_node_optiontree.h"
#include "node/ui_node_panel.h"
#include "node/ui_node_radar.h"
#include "node/ui_node_radiobutton.h"
#include "node/ui_node_rows.h"
#include "node/ui_node_selectbox.h"
#include "node/ui_node_sequence.h"
#include "node/ui_node_string.h"
#include "node/ui_node_special.h"
#include "node/ui_node_spinner.h"
#include "node/ui_node_tab.h"
#include "node/ui_node_tbar.h"
#include "node/ui_node_text.h"
#include "node/ui_node_text2.h"
#include "node/ui_node_textlist.h"
#include "node/ui_node_textentry.h"
#include "node/ui_node_texture.h"
#include "node/ui_node_timer.h"
#include "node/ui_node_video.h"
#include "node/ui_node_vscrollbar.h"
#include "node/ui_node_zone.h"
 
#include "ui_lua.h"
 
typedef void (*registerFunction_t)(uiBehaviour_t* node);

static const registerFunction_t registerFunctions[] = {
    UI_RegisterNullNode,
    UI_RegisterAbstractNode,
    UI_RegisterAbstractOptionNode,
    UI_RegisterAbstractScrollableNode,
    UI_RegisterAbstractScrollbarNode,
    UI_RegisterAbstractValueNode,
    UI_RegisterBarNode,
    UI_RegisterBaseInventoryNode,
    UI_RegisterBaseLayoutNode,
    UI_RegisterBattlescapeNode,
    UI_RegisterButtonNode,
    UI_RegisterCheckBoxNode,
    UI_RegisterConFuncNode,
    UI_RegisterContainerNode,
    UI_RegisterControlsNode,
    UI_RegisterCvarFuncNode,
    UI_RegisterDataNode,
    UI_RegisterEditorNode,
    UI_RegisterFuncNode,
    UI_RegisterGeoscapeNode,
    UI_RegisterImageNode,
    UI_RegisterItemNode,
    UI_RegisterLineChartNode,
    UI_RegisterMaterialEditorNode,
    UI_RegisterMessageListNode,
    UI_RegisterModelNode,
    UI_RegisterOptionNode,
    UI_RegisterOptionListNode,
    UI_RegisterOptionTreeNode,
    UI_RegisterPanelNode,
    UI_RegisterRadarNode,
    UI_RegisterRadioButtonNode,
    UI_RegisterRowsNode,
    UI_RegisterSelectBoxNode,
    UI_RegisterSequenceNode,
    UI_RegisterSpinnerNode,
    UI_RegisterStringNode,
    UI_RegisterTabNode,
    UI_RegisterTBarNode,
    UI_RegisterTextNode,
    UI_RegisterText2Node,
    UI_RegisterTextEntryNode,
    UI_RegisterTextListNode,
    UI_RegisterTextureNode,
    UI_RegisterTimerNode,
    UI_RegisterVideoNode,
    UI_RegisterVScrollbarNode,
    UI_RegisterWindowNode,
    UI_RegisterZoneNode
};
#define NUMBER_OF_BEHAVIOURS lengthof(registerFunctions)

static uiBehaviour_t nodeBehaviourList[NUMBER_OF_BEHAVIOURS];

bool UI_CheckVisibility (uiNode_t* node)
{
    bool result = true;
    /* old script check */
    if (node->visibilityCondition != nullptr) {
        uiCallContext_t context;
        context.source = node;
        context.useCmdParam = false;
        result = UI_GetBooleanFromExpression(node->visibilityCondition, &context);
    }
    /* lua script check */
    else if (node->lua_onVisibleWhen != LUA_NOREF) {
        UI_ExecuteLuaEventScript_ReturnBool (node, node->lua_onVisibleWhen, result);
    }
    return result;
}

const char* UI_GetPath (const uiNode_t* node)
{
    static char result[512];
    const uiNode_t* nodes[8];
    int i = 0;
 
    while (node) {
        assert(i < 8);
        nodes[i] = node;
        node = node->parent;
        i++;
    }

    result[0] = '\0';
    while (i) {
        i--;
        Q_strcat(result, sizeof(result), "%s", nodes[i]->name);
        if (i > 0)
            Q_strcat(result, sizeof(result), ".");
    }
 
    return result;
}

void UI_ReadNodePath (const char* path, const uiNode_t* relativeNode, const uiNode_t* iterationNode, uiNode_t** resultNode, const value_t** resultProperty, value_t *luaMethod) {
    char name[MAX_VAR];
    uiNode_t* node = nullptr;
    uiNode_t* childnode = nullptr;
    const char* nextName;
    char nextCommand = '^';
 
    *resultNode = nullptr;
    if (resultProperty)
        *resultProperty = nullptr;
 
    nextName = path;
    while (nextName && nextName[0] != '\0') {
        const char* begin = nextName;
        char command = nextCommand;
        nextName = strpbrk(begin, ".@#");
        if (!nextName) {
            Q_strncpyz(name, begin, sizeof(name));
            nextCommand = '\0';
        } else {
            assert(nextName - begin + 1 <= sizeof(name));
            Q_strncpyz(name, begin, nextName - begin + 1);
            nextCommand = *nextName;
            nextName++;
        }
 
        switch (command) {
        case '^':   /* first string */
            if (Q_streq(name, "this")) {
                if (relativeNode == nullptr)
                    return;
                node = const_cast<uiNode_t *>(relativeNode);
            } else if (Q_streq(name, "parent")) {
                if (relativeNode == nullptr)
                    return;
                node = relativeNode->parent;
            } else if (Q_streq(name, "root")) {
                if (relativeNode == nullptr)
                    return;
                node = relativeNode->root;
            } else if (Q_streq(name, "child")) {
                if (iterationNode == nullptr)
                    return;
                node = const_cast<uiNode_t *>(iterationNode);
            } else
                node = UI_GetWindow(name);
            break;
        case '.':   /* child node */
            if (Q_streq(name, "parent"))
                childnode = node->parent;
            else if (Q_streq(name, "root"))
                childnode = node->root;
            else {
                childnode = UI_GetNode(node, name);
                /* if no node found and if we need it, then it is possible we call a lua based function */
                if (luaMethod && !childnode) {
                    *resultProperty = UI_GetPropertyOrLuaMethod(node, name, luaMethod);
                    if (luaMethod->type) {
                        childnode = node;
                    }
                }
            }
            node = childnode;
            break;
        case '#':   /* window index */
            assert(UI_Node_IsWindow(node));
            node = UI_WindowNodeGetIndexedChild(node, name);
            break;
        case '@':   /* property */
            assert(nextCommand == '\0');
            *resultProperty = UI_GetPropertyOrLuaMethod(node, name, luaMethod);
            *resultNode = node;
            return;
        }
 
        if (!node)
            return;
    }
 
    *resultNode = node;
    return;
}

uiNode_t* UI_GetNodeByPath (const char* path)
{
    uiNode_t* node = nullptr;
    const value_t* property =  nullptr;
    UI_ReadNodePath(path, nullptr, nullptr, &node, &property);
    if (property) {
        Com_Printf("WARNING: Search for node using path [%s] returns property [%s]\n", path, property->string);
    }
    return node;
}

static uiNode_t* UI_AllocNodeWithoutNew (const char* name, const char* type, bool isDynamic)
{
    uiNode_t* node;
    uiBehaviour_t* behaviour;
    int nodeSize;
 
    behaviour = UI_GetNodeBehaviour(type);
    if (behaviour == nullptr)
        Com_Error(ERR_FATAL, "UI_AllocNodeWithoutNew: Node behaviour '%s' doesn't exist", type);
 
    nodeSize = sizeof(*node) + behaviour->extraDataSize;
 
    if (!isDynamic) {
        void* memory = UI_AllocHunkMemory(nodeSize, STRUCT_MEMORY_ALIGN, true);
        if (memory == nullptr)
            Com_Error(ERR_FATAL, "UI_AllocNodeWithoutNew: No more memory to allocate a new node - increase the cvar ui_hunksize");
        node = static_cast<uiNode_t*>(memory);
        ui_global.numNodes++;
    } else {
        node = static_cast<uiNode_t*>(Mem_PoolAlloc(nodeSize, ui_dynPool, 0));
        node->dynamic = true;
    }
 
    node->behaviour = behaviour;
#ifdef DEBUG
    UI_Node_DebugCountWidget(node, 1);
#endif
    if (UI_Node_IsAbstract(node))
        Com_Error(ERR_FATAL, "UI_AllocNodeWithoutNew: Node behavior '%s' is abstract. We can't instantiate it.", type);
 
    if (name != nullptr) {
        Q_strncpyz(node->name, name, sizeof(node->name));
        if (strlen(node->name) != strlen(name))
            Com_Printf("UI_AllocNodeWithoutNew: Node name \"%s\" truncated. New name is \"%s\"\n", name, node->name);
    }
 
    return node;
}

uiNode_t* UI_AllocNode (const char* name, const char* type, bool isDynamic)
{
    uiNode_t* node = UI_AllocNodeWithoutNew(name, type, isDynamic);
 
    /* default initializtion */
    UI_Node_InitNode(node);
 
    /* allocate memory */
    if (node->dynamic) {
        UI_Node_InitNodeDynamic(node);
    }
 
    /* initialize default properties */
    UI_Node_Loading(node);
 
    return node;
}

uiNode_t* UI_CloneNode (const uiNode_t* node, uiNode_t* newWindow, bool recursive, const char* newName, bool isDynamic)
{
    uiNode_t* newNode = UI_AllocNodeWithoutNew(nullptr, UI_Node_GetWidgetName(node), isDynamic);
 
    /* clone all data */
    memcpy(newNode, node, UI_Node_GetMemorySize(node));
    newNode->dynamic = isDynamic;
 
    /* custom name */
    if (newName != nullptr) {
        Q_strncpyz(newNode->name, newName, sizeof(newNode->name));
        if (strlen(newNode->name) != strlen(newName))
            Com_Printf("UI_CloneNode: Node name \"%s\" truncated. New name is \"%s\"\n", newName, newNode->name);
    }
 
    /* clean up node navigation */
    if (node->root == node && newWindow == nullptr)
        newWindow = newNode;
 
    newNode->root = newWindow;
    newNode->parent = nullptr;
    newNode->firstChild = nullptr;
    newNode->lastChild = nullptr;
    newNode->next = nullptr;
    newNode->super = node;
 
    /* clone node methods */
    if (node->nodeMethods) {
        newNode->nodeMethods = HASH_CloneTable(node->nodeMethods);
    }
 
    /* allocate memories */
    if (newNode->dynamic) {
        UI_Node_InitNodeDynamic(newNode);
    }
 
    /* typically, cloning makes a copy of all the internals of a source node; override the ::clone(node) method
       to alter this behaviour */
    UI_Node_Clone(node, newNode);
 
    /* clone child */
    if (recursive) {
        for (uiNode_t* childNode = node->firstChild; childNode; childNode = childNode->next) {
            uiNode_t* newChildNode = UI_CloneNode(childNode, newWindow, recursive, nullptr, isDynamic);
            UI_AppendNode(newNode, newChildNode);
        }
    }
 
    return newNode;
}

static uiNode_t* UI_GetNodeInTreeAtPosition (uiNode_t* node, int rx, int ry)
{
    if (node->invis || UI_Node_IsVirtual(node) || !UI_CheckVisibility(node))
        return nullptr;
 
    /* relative to the node */
    rx -= node->box.pos[0];
    ry -= node->box.pos[1];
 
    /* check bounding box */
    if (rx < 0 || ry < 0 || rx >= node->box.size[0] || ry >= node->box.size[1])
        return nullptr;

    uiNode_t* find = nullptr;
    if (node->firstChild) {
        vec2_t clientPosition = {0, 0};
 
        if (UI_Node_IsScrollableContainer(node))
            UI_Node_GetClientPosition(node, clientPosition);
 
        rx -= clientPosition[0];
        ry -= clientPosition[1];
 
        for (uiNode_t* child = node->firstChild; child; child = child->next) {
            uiNode_t* tmp;
            tmp = UI_GetNodeInTreeAtPosition(child, rx, ry);
            if (tmp)
                find = tmp;
        }
 
        rx += clientPosition[0];
        ry += clientPosition[1];
    }
    if (find)
        return find;
 
    /* disable ghost/excluderect in debug mode 2 */
    if (UI_DebugMode() != 2) {
        /* is the node tangible */
        if (node->ghost)
            return nullptr;
 
        /* check excluded box */
        for (uiExcludeRect_t* excludeRect = node->firstExcludeRect; excludeRect != nullptr; excludeRect = excludeRect->next) {
            if (rx >= excludeRect->pos[0]
             && rx < excludeRect->pos[0] + excludeRect->size[0]
             && ry >= excludeRect->pos[1]
             && ry < excludeRect->pos[1] + excludeRect->size[1])
                return nullptr;
        }
    }
 
    /* we are over the node */
    return node;
}

uiNode_t* UI_GetNodeAtPosition (int x, int y)
{
    /* find the first window under the mouse */
    for (int pos = ui_global.windowStackPos - 1; pos >= 0; pos--) {
        uiNode_t* window = ui_global.windowStack[pos];
        uiNode_t* find;
 
        /* update the layout */
        UI_Validate(window);
 
        find = UI_GetNodeInTreeAtPosition(window, x, y);
        if (find)
            return find;
 
        /* we must not search anymore */
        if (UI_WindowIsDropDown(window))
            break;
        if (UI_WindowIsModal(window))
            break;
        if (UI_WindowIsFullScreen(window))
            break;
    }
 
    return nullptr;
}

uiBehaviour_t* UI_GetNodeBehaviour (const char* name)
{
    unsigned char min = 0;
    unsigned char max = NUMBER_OF_BEHAVIOURS;
 
    while (min != max) {
        const int mid = (min + max) >> 1;
        const int diff = strcmp(nodeBehaviourList[mid].name, name);
        assert(mid < max);
        assert(mid >= min);
 
        if (diff == 0)
            return &nodeBehaviourList[mid];
 
        if (diff > 0)
            max = mid;
        else
            min = mid + 1;
    }
 
    return nullptr;
}
 
uiBehaviour_t* UI_GetNodeBehaviourByIndex (int index)
{
    return &nodeBehaviourList[index];
}
 
int UI_GetNodeBehaviourCount (void)
{
    return NUMBER_OF_BEHAVIOURS;
}

void UI_DeleteAllChild (uiNode_t* node)
{
    uiNode_t* child;
    child = node->firstChild;
    while (child) {
        uiNode_t* next = child->next;
        UI_DeleteNode(child);
        child = next;
    }
}
 
static void UI_BeforeDeletingNode (const uiNode_t* node)
{
    if (UI_GetHoveredNode() == node) {
        UI_InvalidateMouse();
    }
}

void UI_DeleteNode (uiNode_t* node)
{
    if (!node->dynamic) {
        Com_Printf("UI_DeleteNode: Can't delete the static node '%s'\n", UI_GetPath(node));
        return;
    }
 
    UI_BeforeDeletingNode(node);
 
    UI_DeleteAllChild(node);
    if (node->firstChild != nullptr) {
        Com_Printf("UI_DeleteNode: Node '%s' contain static nodes. We can't delete it.\n", UI_GetPath(node));
        return;
    }
 
    if (node->parent)
        UI_RemoveNode(node->parent, node);
 
    /* delete all allocated properties */
    for (uiBehaviour_t* behaviour = node->behaviour; behaviour; behaviour = behaviour->super) {
        const value_t** property = behaviour->localProperties;
        if (property == nullptr)
            continue;
        while (*property) {
            if (((*property)->type & V_UI_MASK) == V_UI_CVAR) {
                if (void*& mem = Com_GetValue<void*>(node, *property)) {
                    UI_FreeStringProperty(mem);
                    mem = 0;
                }
            }

 
            property++;
        }
    }
 
    UI_Node_DeleteNode(node);
}
 
void UI_InitNodes (void)
{
    int i = 0;
    uiBehaviour_t* current = nodeBehaviourList;
 
    /* compute list of node behaviours */
    for (i = 0; i < NUMBER_OF_BEHAVIOURS; i++) {
        OBJZERO(*current);
        current->registration = true;
        registerFunctions[i](current);
        current->registration = false;
        current++;
    }
 
    /* @todo This check for a-z sortable behaviour list can be entirely within debug */
    /* check for safe data: list must be sorted by alphabet */
    current = nodeBehaviourList;
    assert(current);
    for (i = 0; i < NUMBER_OF_BEHAVIOURS - 1; i++) {
        const uiBehaviour_t* a = current;
        const uiBehaviour_t* b = current + 1;
        assert(b);
        if (strcmp(a->name, b->name) >= 0) {
#ifdef DEBUG
            Com_Error(ERR_FATAL, "UI_InitNodes: '%s' is before '%s'. Please order node behaviour registrations by name", a->name, b->name);
#else
            Com_Error(ERR_FATAL, "UI_InitNodes: Error: '%s' is before '%s'", a->name, b->name);
#endif
        }
        current++;
    }
 
    /* finalize node behaviour initialization */
    current = nodeBehaviourList;
    for (i = 0; i < NUMBER_OF_BEHAVIOURS; i++) {
        UI_InitializeNodeBehaviour(current);
        current++;
    }
}
 
void uiBox_t::alignBox (uiBox_t& inner, align_t direction)
{
    switch (direction % 3) {
    case 0: /* left */
        inner.pos[0] = this->pos[0];
        break;
    case 1: /* middle */
        inner.pos[0] = this->pos[0] + (this->size[0] * 0.5) - (inner.size[0] * 0.5);
        break;
    case 2: /* right */
        inner.pos[0] = this->pos[0] + this->size[0] - inner.size[0];
        break;
    }
    switch (direction / 3) {
    case 0: /* top */
        inner.pos[1] = this->pos[1];
        break;
    case 1: /* middle */
        inner.pos[1] = this->pos[1] + (this->size[1] * 0.5) - (inner.size[1] * 0.5);
        break;
    case 2: /* bottom */
        inner.pos[1] = this->pos[1] + this->size[1] - inner.size[1];
        break;
    default:
        inner.pos[1] = this->pos[1];
        Com_Error(ERR_FATAL, "UI_ImageAlignBoxInBox: Align %d not supported\n", direction);
    }
}