ui_input.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 "ui_main.h"
#include "ui_internal.h"
#include "ui_actions.h"
#include "ui_input.h"
#include "ui_internal.h"
#include "ui_nodes.h"
#include "ui_node.h"
#include "ui_parse.h"
#include "ui_draw.h"
#include "ui_dragndrop.h"
#include "ui_timer.h"
 
#include "../input/cl_keys.h"
#include "../input/cl_input.h"
#include "../cl_shared.h"
#include "../battlescape/cl_localentity.h"
#include "../battlescape/cl_camera.h"
#include "../battlescape/cl_actor.h"
#include "../battlescape/cl_battlescape.h"

static uiNode_t* focusNode;

static uiNode_t* hoveredNode;

static uiNode_t* oldHoveredNode;

static int oldMousePosX, oldMousePosY;

static uiNode_t* capturedNode;

static uiNode_t* pressedNode;

static int pressedNodeLocationX;

static int pressedNodeLocationY;

static int pressedNodeButton;

#define UI_STARTDRAG_ALREADY_SENT -1

#define LONGPRESS_DELAY 800

static uiTimer_t* longPressTimer;
 

static bool UI_FocusExecuteActionNode (void)
{
#if 0   
    if (IN_GetMouseSpace() != MS_UI)
        return false;
 
    if (UI_GetMouseCapture())
        return false;
 
    if (focusNode) {
        if (focusNode->onClick) {
            UI_ExecuteEventActions(focusNode, focusNode->onClick);
        }
        UI_ExecuteEventActions(focusNode, focusNode->onMouseLeave);
        focusNode = nullptr;
        return true;
    }
#endif
    return false;
}
 
#if 0   
static uiNode_t* UI_GetNextActionNode (uiNode_t* node)
{
    if (node)
        node = node->next;
    while (node) {
        if (UI_CheckVisibility(node) && !node->invis
         && ((node->onClick && node->onMouseEnter) || node->onMouseEnter))
            return node;
        node = node->next;
    }
    return nullptr;
}
#endif

static bool UI_FocusNextActionNode (void)
{
#if 0   
    static int i = UI_MAX_WINDOWSTACK + 1;  /* to cycle between all windows */
 
    if (IN_GetMouseSpace() != MS_UI)
        return false;
 
    if (UI_GetMouseCapture())
        return false;
 
    if (i >= ui_global.windowStackPos)
        i = UI_GetLastFullScreenWindow();
 
    assert(i >= 0);
 
    if (focusNode) {
        uiNode_t* node = UI_GetNextActionNode(focusNode);
        if (node)
            return UI_FocusSetNode(node);
    }
 
    while (i < ui_global.windowStackPos) {
        uiNode_t* window;
        window = ui_global.windowStack[i++];
        if (UI_FocusSetNode(UI_GetNextActionNode(window->firstChild)))
            return true;
    }
    i = UI_GetLastFullScreenWindow();
 
    /* no node to focus */
    UI_RemoveFocus();
#endif
    return false;
}

void UI_RequestFocus (uiNode_t* node)
{
    uiNode_t* tmp;
    assert(node);
    if (node == focusNode)
        return;
 
    /* invalidate the data before calling the event */
    tmp = focusNode;
    focusNode = nullptr;
 
    /* lost the focus */
    if (tmp) {
        UI_Node_FocusLost(tmp);
    }
 
    /* get the focus */
    focusNode = node;
    UI_Node_FocusGained(focusNode);
}

bool UI_HasFocus (const uiNode_t* node)
{
    return node == focusNode;
}

void UI_RemoveFocus (void)
{
    uiNode_t* tmp;
 
    if (UI_GetMouseCapture())
        return;
 
    if (!focusNode)
        return;
 
    /* invalidate the data before calling the event */
    tmp = focusNode;
    focusNode = nullptr;
 
    /* callback the lost of the focus */
    UI_Node_FocusLost(tmp);
}
 
static uiKeyBinding_t* UI_AllocStaticKeyBinding (void)
{
    uiKeyBinding_t* result;
    if (ui_global.numKeyBindings >= UI_MAX_KEYBINDING)
        Com_Error(ERR_FATAL, "UI_AllocStaticKeyBinding: UI_MAX_KEYBINDING hit");
 
    result = &ui_global.keyBindings[ui_global.numKeyBindings];
    ui_global.numKeyBindings++;
 
    OBJZERO(*result);
    return result;
}
 
int UI_GetKeyBindingCount (void)
{
    return ui_global.numKeyBindings;
}
 
uiKeyBinding_t* UI_GetKeyBindingByIndex (int index)
{
    return &ui_global.keyBindings[index];
}

static void UI_SetKeyBindingEx (const char* path, int key, const char* description, bool inherited)
{
    uiNode_t* node;
    const value_t* property = nullptr;
 
    UI_ReadNodePath(path, nullptr, nullptr, &node, &property);
    if (node == nullptr) {
        Com_Printf("UI_SetKeyBinding: node \"%s\" not found.\n", path);
        return;
    }
 
    if (property != nullptr && property->type != V_UI_NODEMETHOD)
        Com_Error(ERR_FATAL, "UI_SetKeyBinding: Only node and method are supported. Property @%s not found in path \"%s\".", property->string, path);
 
    /* init and link the keybinding */
    uiKeyBinding_t* binding = UI_AllocStaticKeyBinding();
    binding->node = node;
    binding->property = property;
    binding->key = key;
    binding->inherited = inherited;
    node->key = binding;
 
    if (Q_strnull(description))
        Com_Printf("Warning: Empty description for UI keybinding: %s (%s)\n", path, Key_KeynumToString(key));
    else
        binding->description = Mem_PoolStrDup(description, ui_dynPool, 0);
 
    UI_WindowNodeRegisterKeyBinding(node->root, binding);
 
    /* search and update windows that extend node->root */
    for (int windowId = 0; windowId < ui_global.numWindows; windowId++) {
        uiNode_t* window = ui_global.windows[windowId];
 
        /* skip windows which are not direct extends of the main window */
        if (window->super != node->root)
            continue;
 
        /* create a new patch from the new windows */
        char newPath[256];
        newPath[0] = '\0';
        Q_strcat(newPath, sizeof(newPath), "%s%s", window->name, path + strlen(node->root->name));
        UI_SetKeyBindingEx(newPath, key, description, true);
    }
}

void UI_SetKeyBinding (const char* path, int key, const char* description)
{
    UI_SetKeyBindingEx(path, key, description, false);
}

static bool UI_KeyPressedInWindow (uiNode_t* window, unsigned int key, unsigned int unicode)
{
    uiNode_t* node;
    const uiKeyBinding_t* binding;
 
    /* search requested key binding */
    binding = UI_WindowNodeGetKeyBinding(window, key);
    if (!binding) {
        /* no binding found, perhaps a lua event handler is attached to this window */
        UI_Node_KeyPressed (window, key, unicode);
        return false;
    }
 
    /* check node visibility */
    node = binding->node;
    while (node) {
        if (node->disabled || node->invis)
            return false;
        node = node->parent;
    }
 
    /* execute event */
    node = binding->node;
    if (binding->property == nullptr)
        UI_Node_Activate(node);
    else if (binding->property->type == V_UI_NODEMETHOD) {
        uiCallContext_t newContext;
        uiNodeMethod_t func = (uiNodeMethod_t) binding->property->ofs;
        newContext.source = node;
        newContext.useCmdParam = false;
        func(node, &newContext);
    } else
        Com_Printf("UI_KeyPressedInWindow: @%s not supported.", binding->property->string);
 
    return true;
}

bool UI_KeyRelease (unsigned int key, unsigned short unicode)
{
    /* translate event into the node with focus */
    if (focusNode) {
        return UI_Node_KeyReleased(focusNode, key, unicode);
    }
 
    return false;
}

bool UI_KeyPressed (unsigned int key, unsigned short unicode)
{
    if (UI_DNDIsDragging()) {
        if (key == K_ESCAPE) {
            UI_DNDAbort();
            return true;
        }
        return false;
    }
 
    if (key == K_ESCAPE && CL_BattlescapeRunning()
     && selActor && CL_ActorFireModeActivated(selActor->actorMode)) {
        /* Cancel firing with Escape, needed for Android, where right mouse click is bound to multitouch, which is non-obvious */
        CL_ActorSetMode(selActor, M_MOVE);
        return true;
    }
 
    /* translate event into the node with focus */
    /* note: this is not executed if the top node is a modal window, see code below */
    if (focusNode) {
        if (UI_Node_KeyPressed(focusNode, key, unicode)) {
            return true;
        }
    }
 
    /* else use common behaviour */
    switch (key) {
    case K_TAB:
        if (UI_FocusNextActionNode())
            return true;
        break;
    case K_ENTER:
    case K_KP_ENTER:
        if (UI_FocusExecuteActionNode())
            return true;
        break;
    case K_ESCAPE:
        if (UI_GetMouseCapture() != nullptr) {
            UI_MouseRelease();
            return true;
        }
        UI_PopWindowWithEscKey();
        return true;
    }
 
    int lastWindowId = UI_GetLastFullScreenWindow();
    if (lastWindowId < 0)
        return false;
 
    /* check "active" window from top to down */
    for (int windowId = ui_global.windowStackPos - 1; windowId >= lastWindowId; windowId--) {
        uiNode_t* window = ui_global.windowStack[windowId];
        if (!window)
            return false;
        if (UI_KeyPressedInWindow(window, key, unicode))
            return true;
        if (UI_WindowIsModal(window))
            break;
    }
 
    return false;
}

void UI_ReleaseInput (void)
{
    UI_RemoveFocus();
    UI_MouseRelease();
    if (UI_DNDIsDragging())
        UI_DNDAbort();
}

uiNode_t* UI_GetMouseCapture (void)
{
    return capturedNode;
}

void UI_SetMouseCapture (uiNode_t* node)
{
    assert(capturedNode == nullptr);
    assert(node != nullptr);
    capturedNode = node;
}

void UI_MouseRelease (void)
{
    uiNode_t* tmp = capturedNode;
 
    if (capturedNode == nullptr)
        return;
 
    capturedNode = nullptr;
    UI_Node_CapturedMouseLost(tmp);
    UI_InvalidateMouse();
}
 
void UI_ResetInput (void)
{
    hoveredNode = nullptr;
    oldHoveredNode = nullptr;
    focusNode = nullptr;
    capturedNode = nullptr;
    pressedNode = nullptr;
    longPressTimer = nullptr;
}

uiNode_t* UI_GetHoveredNode (void)
{
    return hoveredNode;
}

void UI_InvalidateMouse (void)
{
    oldMousePosX = -1;
    oldMousePosY = -1;
}

bool UI_CheckMouseMove (void)
{
    /* is hovered node no more draw */
    if (hoveredNode && (hoveredNode->invis || !UI_CheckVisibility(hoveredNode)))
        UI_InvalidateMouse();
 
    if (mousePosX != oldMousePosX || mousePosY != oldMousePosY) {
        oldMousePosX = mousePosX;
        oldMousePosY = mousePosY;
        UI_MouseMove(mousePosX, mousePosY);
        return true;
    }
 
    return false;
}

void UI_MouseMove (int x, int y)
{
    if (UI_DNDIsDragging())
        return;
 
    if (pressedNode && !capturedNode) {
        if (pressedNodeLocationX != UI_STARTDRAG_ALREADY_SENT) {
            UI_TimerStop(longPressTimer);
            int dist = abs(pressedNodeLocationX - x) + abs(pressedNodeLocationY - y);
            if (dist > 4) {
                uiNode_t* node = pressedNode;
                while (node) {
                    if (UI_Node_StartDragging(node, pressedNodeLocationX, pressedNodeLocationY, x, y, pressedNodeButton))
                        break;
                    node = node->parent;
                }
                pressedNodeLocationX = UI_STARTDRAG_ALREADY_SENT;
            }
        }
    }
 
    /* send the captured move mouse event */
    if (capturedNode) {
        UI_Node_CapturedMouseMove(capturedNode, x, y);
        return;
    }
 
    hoveredNode = UI_GetNodeAtPosition(x, y);
 
    /* update houvered node by sending messages */
    if (oldHoveredNode != hoveredNode) {
        uiNode_t* commonNode = hoveredNode;
        uiNode_t* node;
 
        /* search the common node */
        while (commonNode) {
            node = oldHoveredNode;
            while (node) {
                if (node == commonNode)
                    break;
                node = node->parent;
            }
            if (node != nullptr)
                break;
            commonNode = commonNode->parent;
        }
 
        /* send 'leave' event from old node to common node */
        node = oldHoveredNode;
        while (node != commonNode) {
            UI_Node_MouseLeave(node);
            node = node->parent;
        }
        if (oldHoveredNode)
            oldHoveredNode->state = false;
 
        /* send 'enter' event from common node to new node */
        while (commonNode != hoveredNode) {
            node = hoveredNode;
            while (node->parent != commonNode)
                node = node->parent;
            commonNode = node;
            UI_Node_MouseEnter(node);
        }
        if (hoveredNode) {
            hoveredNode->state = true;
            UI_Node_MouseEnter(node);
        }
    }
 
    oldHoveredNode = hoveredNode;
 
    /* send the move event */
    if (hoveredNode)
        UI_Node_MouseMove(hoveredNode, x, y);
}
 
#define UI_IsMouseInvalidate() (oldMousePosX == -1)

static void UI_LeftClick (int x, int y)
{
    if (UI_IsMouseInvalidate())
        return;
 
    /* send it to the captured mouse node */
    if (capturedNode) {
        UI_Node_LeftClick(capturedNode, x, y);
        return;
    }
 
    /* if we click outside a dropdown window, we close it */
    if (!pressedNode && ui_global.windowStackPos != 0) {
        uiNode_t* window = ui_global.windowStack[ui_global.windowStackPos - 1];
        if (UI_WindowIsDropDown(window)) {
            UI_PopWindow();
        }
    }
 
    const bool disabled = (pressedNode == nullptr) || (pressedNode->disabled) || (pressedNode->parent && pressedNode->parent->disabled);
    if (!disabled) {
        UI_Node_LeftClick(pressedNode, x, y);
    }
}

static void UI_RightClick (int x, int y)
{
    if (UI_IsMouseInvalidate())
        return;
 
    /* send it to the captured mouse node */
    if (capturedNode) {
        UI_Node_RightClick(capturedNode, x, y);
        return;
    }
 
    const bool disabled = (pressedNode == nullptr) || (pressedNode->disabled) || (pressedNode->parent && pressedNode->parent->disabled);
    if (!disabled) {
        UI_Node_RightClick(pressedNode, x, y);
    }
}

static void UI_MiddleClick (int x, int y)
{
    if (UI_IsMouseInvalidate())
        return;
 
    /* send it to the captured mouse node */
    if (capturedNode) {
        UI_Node_MiddleClick(capturedNode, x, y);
        return;
    }
 
    const bool disabled = (pressedNode == nullptr) || (pressedNode->disabled) || (pressedNode->parent && pressedNode->parent->disabled);
    if (!disabled) {
        UI_Node_MiddleClick(pressedNode, x, y);
    }
}

void UI_MouseScroll (int deltaX, int deltaY)
{
    uiNode_t* node;
 
    /* send it to the captured mouse node */
    if (capturedNode) {
        UI_Node_Scroll(capturedNode, deltaX, deltaY);
        return;
    }
 
    node = hoveredNode;
 
    while (node) {
        if (UI_Node_Scroll(node, deltaX, deltaY)) {
            break;
        }
        node = node->parent;
    }
}

static void UI_LongPressCallback (uiNode_t* , uiTimer_t* timer)
{
    UI_TimerStop(timer);
 
    /* make sure the event still make sense */
    if (pressedNode == nullptr)
        return;
 
    uiNode_t* node = pressedNode;
    while (node) {
        if (UI_Node_MouseLongPress(node, pressedNodeLocationX, pressedNodeLocationY, pressedNodeButton))
            break;
        node = node->parent;
    }
}

void UI_MouseDown (int x, int y, int button)
{
    /* disable old long click event */
    if (longPressTimer)
        UI_TimerStop(longPressTimer);
 
    uiNode_t* node;
 
    /* captured or hover node */
    node = capturedNode ? capturedNode : hoveredNode;
 
    if (node != nullptr) {
        UI_MoveWindowOnTop(node->root);
        UI_Node_MouseDown(node, x, y, button);
    }
 
    /* select clickableNode on button up, and detect multipress button */
    if (pressedNode == nullptr) {
        pressedNode = node;
        pressedNodeLocationX = x;
        pressedNodeLocationY = y;
        pressedNodeButton = button;
        if (longPressTimer == nullptr) {
            longPressTimer = UI_AllocTimer(nullptr, LONGPRESS_DELAY, UI_LongPressCallback);
        }
        UI_TimerStart(longPressTimer);
    } else {
        pressedNode = nullptr;
    }
}

void UI_MouseUp (int x, int y, int button)
{
    /* disable long click event */
    if (longPressTimer)
        UI_TimerStop(longPressTimer);
 
    /* send click event */
    if (pressedNode || capturedNode) {
        switch (button) {
        case K_MOUSE1:
            UI_LeftClick(x, y);
            break;
        case K_MOUSE2:
            UI_RightClick(x, y);
            break;
        case K_MOUSE3:
            UI_MiddleClick(x, y);
            break;
        }
    }
 
    /* captured or hovered node */
    uiNode_t* node = nullptr;
    if (capturedNode) {
        node = capturedNode;
    } else if (pressedNode == hoveredNode) {
        node = hoveredNode;
    }
 
    pressedNode = nullptr;
    if (node == nullptr)
        return;
 
    UI_Node_MouseUp(node, x, y, button);
}