ui_nodes.c

Go to the documentation of this file.

/*
Copyright (C) 2002-2010 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_main.h"
#include "ui_internal.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_button.h"
#include "node/ui_node_checkbox.h"
#include "node/ui_node_controls.h"
#include "node/ui_node_video.h"
#include "node/ui_node_container.h"
#include "node/ui_node_custombutton.h"
#include "node/ui_node_editor.h"
#include "node/ui_node_ekg.h"
#include "node/ui_node_image.h"
#include "node/ui_node_item.h"
#include "node/ui_node_linechart.h"
#include "node/ui_node_map.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_keybinding.h"
#include "node/ui_node_todo.h"
#include "node/ui_node_vscrollbar.h"
#include "node/ui_node_zone.h"

typedef void (*registerFunction_t)(uiBehaviour_t *node);

static const registerFunction_t registerFunctions[] = {
    UI_RegisterNullNode,
    UI_RegisterAbstractBaseNode,
    UI_RegisterAbstractNode,
    UI_RegisterAbstractOptionNode,
    UI_RegisterAbstractScrollableNode,
    UI_RegisterAbstractScrollbarNode,
    UI_RegisterAbstractValueNode,
    UI_RegisterBarNode,
    UI_RegisterBaseInventoryNode,
    UI_RegisterBaseLayoutNode,
    UI_RegisterBaseMapNode,
    UI_RegisterButtonNode,
    UI_RegisterCheckBoxNode,
    UI_RegisterConFuncNode,
    UI_RegisterContainerNode,
    UI_RegisterControlsNode,
    UI_RegisterCustomButtonNode,
    UI_RegisterCvarFuncNode,
    UI_RegisterEditorNode,
    UI_RegisterEKGNode,
    UI_RegisterFuncNode,
    UI_RegisterImageNode,
    UI_RegisterItemNode,
    UI_RegisterKeyBindingNode,
    UI_RegisterLineChartNode,
    UI_RegisterMapNode,
    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_RegisterSpecialNode,
    UI_RegisterSpinnerNode,
    UI_RegisterStringNode,
    UI_RegisterTabNode,
    UI_RegisterTBarNode,
    UI_RegisterTextNode,
    UI_RegisterText2Node,
    UI_RegisterTextEntryNode,
    UI_RegisterTextListNode,
    UI_RegisterTodoNode,
    UI_RegisterVideoNode,
    UI_RegisterVScrollbarNode,
    UI_RegisterWindowNode,
    UI_RegisterZoneNode
};
#define NUMBER_OF_BEHAVIOURS lengthof(registerFunctions)

static uiBehaviour_t nodeBehaviourList[NUMBER_OF_BEHAVIOURS];

const value_t *UI_GetPropertyFromBehaviour (const uiBehaviour_t *behaviour, const char* name)
{
    for (; behaviour; behaviour = behaviour->super) {
        const value_t *result;
        if (behaviour->properties == NULL)
            continue;
        result = UI_FindPropertyByName(behaviour->properties, name);
        if (result)
            return result;
    }
    return NULL;
}

qboolean UI_CheckVisibility (uiNode_t *node)
{
    uiCallContext_t context;
    if (!node->visibilityCondition)
        return qtrue;
    context.source = node;
    context.useCmdParam = qfalse;
    return UI_GetBooleanFromExpression(node->visibilityCondition, &context);
}

const char* UI_GetPath (const uiNode_t* node)
{
    static char result[MAX_VAR];
    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, nodes[i]->name, sizeof(result));
        if (i > 0)
            Q_strcat(result, ".", sizeof(result));
    }

    return result;
}

void UI_ReadNodePath (const char* path, const uiNode_t *relativeNode, uiNode_t **resultNode, const value_t **resultProperty)
{
    char name[MAX_VAR];
    uiNode_t* node = NULL;
    const char* nextName;
    char nextCommand = '^';

    *resultNode = NULL;
    if (resultProperty)
        *resultProperty = NULL;

    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 (!strcmp(name, "this")) {
                if (relativeNode == NULL)
                    return;
                node = *(uiNode_t**) ((void*)&relativeNode);
            } else if (!strcmp(name, "parent")) {
                if (relativeNode == NULL)
                    return;
                node = relativeNode->parent;
            } else if (!strcmp(name, "root")) {
                if (relativeNode == NULL)
                    return;
                node = relativeNode->root;
            } else
                node = UI_GetWindow(name);
            break;
        case '.':   /* child node */
            if (!strcmp(name, "parent"))
                node = node->parent;
            else if (!strcmp(name, "root"))
                node = node->root;
            else
                node = UI_GetNode(node, name);
            break;
        case '#':   /* window index */
            assert(node->behaviour == ui_windowBehaviour);
            node = UI_WindowNodeGetIndexedChild(node, name);
            break;
        case '@':   /* property */
            assert(nextCommand == '\0');
            *resultProperty = UI_GetPropertyFromBehaviour(node->behaviour, name);
            *resultNode = node;
            return;
        }

        if (!node)
            return;
    }

    *resultNode = node;
    return;
}

uiNode_t* UI_GetNodeByPath (const char* path)
{
    uiNode_t* node = NULL;
    const value_t *property;
    UI_ReadNodePath(path, NULL, &node, &property);
    return node;
}

static uiNode_t* UI_AllocNodeWithoutNew (const char* name, const char* type, qboolean isDynamic)
{
    uiNode_t* node;
    uiBehaviour_t *behaviour;
    int nodeSize;

    behaviour = UI_GetNodeBehaviour(type);
    if (behaviour == NULL)
        Com_Error(ERR_FATAL, "UI_AllocNodeWithoutNew: Node behaviour '%s' doesn't exist", type);

    nodeSize = sizeof(*node) + behaviour->extraDataSize;

    if (!isDynamic) {
        if (ui_global.curadata + nodeSize > ui_global.adata + ui_global.adataize)
            Com_Error(ERR_FATAL, "UI_AllocNodeWithoutNew: No more memory to allocate a new node");
        node = (uiNode_t*) ui_global.curadata;
        ui_global.curadata = ALIGN_PTR(ui_global.curadata, 8);
        ui_global.curadata += nodeSize;
        ui_global.numNodes++;
        memset(node, 0, nodeSize);
    } else {
        node = (uiNode_t*)Mem_PoolAlloc(nodeSize, ui_dynPool, 0);
        memset(node, 0, nodeSize);
        node->dynamic = qtrue;
    }

    node->behaviour = behaviour;
#ifdef DEBUG
    node->behaviour->count++;
#endif
    if (node->behaviour->isAbstract)
        Com_Error(ERR_FATAL, "UI_AllocNodeWithoutNew: Node behavior '%s' is abstract. We can't instantiate it.", type);

    if (name != NULL) {
        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);
    }

    /* initialize default properties */
    if (node->behaviour->loading)
        node->behaviour->loading(node);

    return node;
}

uiNode_t* UI_AllocNode (const char* name, const char* type, qboolean isDynamic)
{
    uiNode_t* node = UI_AllocNodeWithoutNew (name, type, isDynamic);

    /* allocate memories */
    if (node->dynamic && node->behaviour->new)
        node->behaviour->new(node);

    return node;
}

static uiNode_t *UI_GetNodeInTreeAtPosition (uiNode_t *node, int rx, int ry)
{
    uiNode_t *find;
    int i;

    if (node->invis || node->behaviour->isVirtual || !UI_CheckVisibility(node))
        return NULL;

    /* relative to the node */
    rx -= node->pos[0];
    ry -= node->pos[1];

    /* check bounding box */
    if (rx < 0 || ry < 0 || rx >= node->size[0] || ry >= node->size[1])
        return NULL;

    find = NULL;
    if (node->firstChild) {
        uiNode_t *child;
        vec2_t clientPosition = {0, 0};

        if (node->behaviour->getClientPosition)
            node->behaviour->getClientPosition(node, clientPosition);

        rx -= clientPosition[0];
        ry -= clientPosition[1];

        for (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 NULL;

        /* check excluded box */
        for (i = 0; i < node->excludeRectNum; i++) {
            if (rx >= node->excludeRect[i].pos[0]
             && rx < node->excludeRect[i].pos[0] + node->excludeRect[i].size[0]
             && ry >= node->excludeRect[i].pos[1]
             && ry < node->excludeRect[i].pos[1] + node->excludeRect[i].size[1])
                return NULL;
        }
    }

    /* we are over the node */
    return node;
}

uiNode_t *UI_GetNodeAtPosition (int x, int y)
{
    int pos;

    /* find the first window under the mouse */
    for (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 NULL;
}

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 char 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 NULL;
}

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;
    }
}

void UI_DeleteNode (uiNode_t* node)
{
    uiBehaviour_t *behaviour;

    if (!node->dynamic)
        return;

    UI_DeleteAllChild(node);
    if (node->firstChild != NULL) {
        Com_Printf("UI_DeleteNode: Node '%s' contain static nodes. We can't delete it.", UI_GetPath(node));
        return;
    }

    if (node->parent)
        UI_RemoveNode(node->parent, node);

    /* delete all allocated properties */
    for (behaviour = node->behaviour; behaviour; behaviour = behaviour->super) {
        const value_t *property = behaviour->properties;
        if (property == NULL)
            continue;
        while (property->string != NULL) {
            if ((property->type & V_UI_MASK) == V_UI_CVAR) {
                void *mem = ((byte *) node + property->ofs);
                if (*(void**)mem != NULL) {
                    UI_FreeStringProperty(*(void**)mem);
                    *(void**)mem = NULL;
                }
            }

            property++;
        }
    }

    if (node->behaviour->delete)
        node->behaviour->delete(node);
}

uiNode_t* UI_CloneNode (const uiNode_t* node, uiNode_t *newWindow, qboolean recursive, const char *newName, qboolean isDynamic)
{
    uiNode_t* newNode = UI_AllocNodeWithoutNew(NULL, node->behaviour->name, isDynamic);

    /* clone all data */
    memcpy(newNode, node, sizeof(*node) + node->behaviour->extraDataSize);
    newNode->dynamic = isDynamic;

    /* custom name */
    if (newName != NULL) {
        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 == NULL)
        newWindow = newNode;
    newNode->root = newWindow;
    newNode->parent = NULL;
    newNode->firstChild = NULL;
    newNode->lastChild = NULL;
    newNode->next = NULL;
    newNode->super = *(uiNode_t**) ((void*)&node);

    /* clone child */
    if (recursive) {
        uiNode_t* childNode;
        for (childNode = node->firstChild; childNode; childNode = childNode->next) {
            uiNode_t* newChildNode = UI_CloneNode(childNode, newWindow, recursive, NULL, isDynamic);
            UI_AppendNode(newNode, newChildNode);
        }
    }

    /* allocate memories */
    if (newNode->dynamic && newNode->behaviour->new)
        newNode->behaviour->new(newNode);

    newNode->behaviour->clone(node, newNode);

    return newNode;
}

static const int virtualFunctions[] = {
    offsetof(uiBehaviour_t, draw),
    offsetof(uiBehaviour_t, drawTooltip),
    offsetof(uiBehaviour_t, leftClick),
    offsetof(uiBehaviour_t, rightClick),
    offsetof(uiBehaviour_t, middleClick),
    offsetof(uiBehaviour_t, mouseWheel),
    offsetof(uiBehaviour_t, mouseMove),
    offsetof(uiBehaviour_t, mouseDown),
    offsetof(uiBehaviour_t, mouseUp),
    offsetof(uiBehaviour_t, capturedMouseMove),
    offsetof(uiBehaviour_t, loading),
    offsetof(uiBehaviour_t, loaded),
    offsetof(uiBehaviour_t, init),
    offsetof(uiBehaviour_t, close),
    offsetof(uiBehaviour_t, clone),
    offsetof(uiBehaviour_t, new),
    offsetof(uiBehaviour_t, delete),
    offsetof(uiBehaviour_t, activate),
    offsetof(uiBehaviour_t, doLayout),
    offsetof(uiBehaviour_t, dndEnter),
    offsetof(uiBehaviour_t, dndMove),
    offsetof(uiBehaviour_t, dndLeave),
    offsetof(uiBehaviour_t, dndDrop),
    offsetof(uiBehaviour_t, dndFinished),
    offsetof(uiBehaviour_t, focusGained),
    offsetof(uiBehaviour_t, focusLost),
    offsetof(uiBehaviour_t, extraDataSize),
    offsetof(uiBehaviour_t, sizeChanged),
    offsetof(uiBehaviour_t, propertyChanged),
    offsetof(uiBehaviour_t, getClientPosition),
    -1
};

static void UI_InitializeNodeBehaviour (uiBehaviour_t* behaviour)
{
    if (behaviour->isInitialized)
        return;

    /* check and update properties data */
    if (behaviour->properties) {
        int num = 0;
        const value_t* current = behaviour->properties;
        while (current->string != NULL) {
            num++;
            current++;
        }
        behaviour->propertyCount = num;
    }

    /* everything inherits 'abstractnode' */
    if (behaviour->extends == NULL && strcmp(behaviour->name, "abstractnode") != 0) {
        behaviour->extends = "abstractnode";
    }

    if (behaviour->extends) {
        int i = 0;
        behaviour->super = UI_GetNodeBehaviour(behaviour->extends);
        UI_InitializeNodeBehaviour(behaviour->super);

        while (qtrue) {
            const size_t pos = virtualFunctions[i];
            uintptr_t superFunc;
            uintptr_t func;
            if (pos == -1)
                break;

            /* cache super function if we don't overwrite it */
            superFunc = *(uintptr_t*)((byte*)behaviour->super + pos);
            func = *(uintptr_t*)((byte*)behaviour + pos);
            if (func == 0 && superFunc != 0)
                *(uintptr_t*)((byte*)behaviour + pos) = superFunc;

            i++;
        }
    }

    /* property must not overwrite another property */
    if (behaviour->super && behaviour->properties) {
        const value_t* property = behaviour->properties;
        while (property->string != NULL) {
            const value_t *p = UI_GetPropertyFromBehaviour(behaviour->super, property->string);
#if 0   
            const uiBehaviour_t *b = UI_GetNodeBehaviour(current->string);
#endif
            if (p != NULL)
                Com_Error(ERR_FATAL, "UI_InitializeNodeBehaviour: property '%s' from node behaviour '%s' overwrite another property", property->string, behaviour->name);
#if 0   
            if (b != NULL)
                Com_Error(ERR_FATAL, "UI_InitializeNodeBehaviour: property '%s' from node behaviour '%s' use the name of an existing node behaviour", property->string, behaviour->name);
#endif
            property++;
        }
    }

    /* Sanity: A property must not be outside the node memory */
    if (behaviour->properties) {
        const int size = sizeof(uiNode_t) + behaviour->extraDataSize;
        const value_t* property = behaviour->properties;
        while (property->string != NULL) {
            if (property->type != V_UI_NODEMETHOD && property->ofs + property->size > size)
                Com_Error(ERR_FATAL, "UI_InitializeNodeBehaviour: property '%s' from node behaviour '%s' is outside the node memory. The C code need a fix.", property->string, behaviour->name);
            property++;
        }
    }

    behaviour->isInitialized = qtrue;
}

void UI_InitNodes (void)
{
    int i = 0;
    uiBehaviour_t *current = nodeBehaviourList;

    /* compute list of node behaviours */
    for (i = 0; i < NUMBER_OF_BEHAVIOURS; i++) {
        registerFunctions[i](current);
        current++;
    }

    /* 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++;
    }
}