ui_input.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_actions.h"
#include "ui_input.h"
#include "ui_internal.h"
#include "ui_nodes.h"
#include "ui_parse.h"
#include "ui_draw.h"
#include "ui_dragndrop.h"
#include "ui_sound.h"

#include "../input/cl_keys.h"
#include "../input/cl_input.h"

static uiNode_t* focusNode;

static uiNode_t* hoveredNode;

static uiNode_t *oldHoveredNode;

static int oldMousePosX, oldMousePosY;

static uiNode_t* capturedNode;

static qboolean UI_FocusExecuteActionNode (void)
{
#if 0   
    if (mouseSpace != MS_UI)
        return qfalse;

    if (UI_GetMouseCapture())
        return qfalse;

    if (focusNode) {
        if (focusNode->onClick) {
            UI_ExecuteEventActions(focusNode, focusNode->onClick);
        }
        UI_ExecuteEventActions(focusNode, focusNode->onMouseLeave);
        focusNode = NULL;
        return qtrue;
    }
#endif
    return qfalse;
}

#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 NULL;
}
#endif

static qboolean UI_FocusNextActionNode (void)
{
#if 0   
    static int i = UI_MAX_WINDOWSTACK + 1;  /* to cycle between all windows */

    if (mouseSpace != MS_UI)
        return qfalse;

    if (UI_GetMouseCapture())
        return qfalse;

    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 qtrue;
    }
    i = UI_GetLastFullScreenWindow();

    /* no node to focus */
    UI_RemoveFocus();
#endif
    return qfalse;
}

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 = NULL;

    /* lost the focus */
    if (tmp && tmp->behaviour->focusLost) {
        tmp->behaviour->focusLost(tmp);
    }

    /* get the focus */
    focusNode = node;
    if (focusNode->behaviour->focusGained) {
        focusNode->behaviour->focusGained(focusNode);
    }
}

qboolean 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 = NULL;

    /* callback the lost of the focus */
    if (tmp->behaviour->focusLost) {
        tmp->behaviour->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++;

    memset(result, 0, sizeof(*result));
    return result;
}

int UI_GetKeyBindingCount (void)
{
    return ui_global.numKeyBindings;
}

uiKeyBinding_t* UI_GetKeyBindingByIndex (int index)
{
    return &ui_global.keyBindings[index];
}

void UI_SetKeyBinding (const char* path, int key)
{
    uiNode_t *node;
    uiKeyBinding_t *binding;
    const value_t *property = NULL;

    UI_ReadNodePath(path, NULL, &node, &property);
    if (node == NULL) {
        Com_Printf("UI_SetKeyBinding: node \"%s\" not found.\n", path);
        return;
    }

    if (property != NULL && 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 */
    binding = UI_AllocStaticKeyBinding();
    binding->node = node;
    binding->property = property;
    binding->key = key;
    node->key = binding;
    UI_WindowNodeRegisterKeyBinding(node->root, binding);
}

static qboolean UI_KeyPressedInWindow (unsigned int key, const uiNode_t *window)
{
    uiNode_t *node;
    const uiKeyBinding_t *binding;

    /* search requested key binding */
    binding = UI_WindowNodeGetKeyBinding(window, key);
    if (!binding)
        return qfalse;

    /* check node visibility */
    node = binding->node;
    while (node) {
        if (node->disabled || node->invis)
            return qfalse;
        node = node->parent;
    }

    /* execute event */
    node = binding->node;
    if (binding->property == NULL)
        node->behaviour->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 = qfalse;
        func(node, &newContext);
    } else
        Com_Printf("UI_KeyPressedInWindow: @%s not supported.", binding->property->string);

    return qtrue;
}

qboolean UI_KeyPressed (unsigned int key, unsigned short unicode)
{
    int windowId;
    int lastWindowId;

    if (UI_DNDIsDragging()) {
        if (key == K_ESCAPE)
            UI_DNDAbort();
        return qtrue;
    }

    /* translate event into the node with focus */
    if (focusNode && focusNode->behaviour->keyPressed) {
        if (focusNode->behaviour->keyPressed(focusNode, key, unicode))
            return qtrue;
    }

    /* else use common behaviour */
    switch (key) {
    case K_TAB:
        if (UI_FocusNextActionNode())
            return qtrue;
        break;
    case K_ENTER:
    case K_KP_ENTER:
        if (UI_FocusExecuteActionNode())
            return qtrue;
        break;
    case K_ESCAPE:
        if (UI_GetMouseCapture() != NULL) {
            UI_MouseRelease();
            return qtrue;
        }
        UI_PopWindowWithEscKey();
        return qtrue;
    }

    lastWindowId = UI_GetLastFullScreenWindow();
    if (lastWindowId < 0)
        return qfalse;

    /* check "active" window from top to down */
    for (windowId = ui_global.windowStackPos - 1; windowId >= lastWindowId; windowId--) {
        const uiNode_t *window = ui_global.windowStack[windowId];
        if (!window)
            return qfalse;
        if (UI_KeyPressedInWindow(key, window))
            return qtrue;
        if (UI_WindowIsModal(window))
            break;
    }

    return qfalse;
}

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 == NULL);
    assert(node != NULL);
    capturedNode = node;
}

void UI_MouseRelease (void)
{
    uiNode_t *tmp = capturedNode;

    if (capturedNode == NULL)
        return;

    capturedNode = NULL;
    if (tmp->behaviour->capturedMouseLost)
        tmp->behaviour->capturedMouseLost(tmp);

    UI_InvalidateMouse();
}

uiNode_t *UI_GetHoveredNode (void)
{
    return hoveredNode;
}

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

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

    return qfalse;
}

void UI_MouseMove (int x, int y)
{
    if (UI_DNDIsDragging())
        return;

    /* send the captured move mouse event */
    if (capturedNode) {
        if (capturedNode->behaviour->capturedMouseMove)
            capturedNode->behaviour->capturedMouseMove(capturedNode, x, y);
        return;
    }

    hoveredNode = UI_GetNodeAtPosition(x, y);

    /* update nodes: send 'in' and 'out' event */
    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 != NULL)
                break;
            commonNode = commonNode->parent;
        }

        /* send 'leave' event from old node to common node */
        node = oldHoveredNode;
        while (node != commonNode) {
            UI_ExecuteEventActions(node, node->onMouseLeave);
            node = node->parent;
        }
        if (oldHoveredNode)
            oldHoveredNode->state = qfalse;

        /* send 'enter' event from common node to new node */
        while (commonNode != hoveredNode) {
            node = hoveredNode;
            while (node->parent != commonNode)
                node = node->parent;
            commonNode = node;
            UI_ExecuteEventActions(node, node->onMouseEnter);
        }
        if (hoveredNode) {
            hoveredNode->state = qtrue;
            UI_ExecuteEventActions(hoveredNode, hoveredNode->onMouseEnter);
        }
    }
    oldHoveredNode = hoveredNode;

    /* send the move event */
    if (hoveredNode && hoveredNode->behaviour->mouseMove) {
        hoveredNode->behaviour->mouseMove(hoveredNode, x, y);
    }
}

#define UI_IsMouseInvalidate (oldMousePosX == -1)

static void UI_LeftClick (int x, int y)
{
    qboolean disabled;
    if (UI_IsMouseInvalidate)
        return;

    /* send it to the captured mouse node */
    if (capturedNode) {
        if (capturedNode->behaviour->leftClick)
            capturedNode->behaviour->leftClick(capturedNode, x, y);
        return;
    }

    /* if we click outside a dropdown window, we close it */
    if (!hoveredNode && ui_global.windowStackPos != 0) {
        uiNode_t *window = ui_global.windowStack[ui_global.windowStackPos - 1];
        if (UI_WindowIsDropDown(window)) {
            UI_PopWindow(qfalse);
        }
    }

    disabled = (hoveredNode == NULL) || (hoveredNode->disabled) || (hoveredNode->parent && hoveredNode->parent->disabled);
    if (!disabled) {
        if (hoveredNode->behaviour->leftClick) {
            hoveredNode->behaviour->leftClick(hoveredNode, x, y);
        } else {
            UI_ExecuteEventActions(hoveredNode, hoveredNode->onClick);
        }
    }
}

static void UI_RightClick (int x, int y)
{
    qboolean disabled;
    if (UI_IsMouseInvalidate)
        return;

    /* send it to the captured mouse node */
    if (capturedNode) {
        if (capturedNode->behaviour->rightClick)
            capturedNode->behaviour->rightClick(capturedNode, x, y);
        return;
    }

    disabled = (hoveredNode == NULL) || (hoveredNode->disabled) || (hoveredNode->parent && hoveredNode->parent->disabled);
    if (!disabled) {
        if (hoveredNode->behaviour->rightClick) {
            hoveredNode->behaviour->rightClick(hoveredNode, x, y);
        } else {
            UI_ExecuteEventActions(hoveredNode, hoveredNode->onRightClick);
        }
    }
}

static void UI_MiddleClick (int x, int y)
{
    qboolean disabled;
    if (UI_IsMouseInvalidate)
        return;

    /* send it to the captured mouse node */
    if (capturedNode) {
        if (capturedNode->behaviour->middleClick)
            capturedNode->behaviour->middleClick(capturedNode, x, y);
        return;
    }

    disabled = (hoveredNode == NULL) || (hoveredNode->disabled) || (hoveredNode->parent && hoveredNode->parent->disabled);
    if (!disabled) {
        if (hoveredNode->behaviour->middleClick) {
            hoveredNode->behaviour->middleClick(hoveredNode, x, y);
        } else {
            UI_ExecuteEventActions(hoveredNode, hoveredNode->onMiddleClick);
        }
        return;
    }
}

void UI_MouseWheel (qboolean down, int x, int y)
{
    /* send it to the captured mouse node */
    if (capturedNode) {
        if (capturedNode->behaviour->mouseWheel)
            capturedNode->behaviour->mouseWheel(capturedNode, down, x, y);
        return;
    }

    if (hoveredNode) {
        if (hoveredNode->behaviour->mouseWheel) {
            hoveredNode->behaviour->mouseWheel(hoveredNode, down, x, y);
        } else {
            if (hoveredNode->onWheelUp && !down)
                UI_ExecuteEventActions(hoveredNode, hoveredNode->onWheelUp);
            if (hoveredNode->onWheelDown && down)
                UI_ExecuteEventActions(hoveredNode, hoveredNode->onWheelDown);
            else
                UI_ExecuteEventActions(hoveredNode, hoveredNode->onWheel);
        }
    }
}

void UI_MouseDown (int x, int y, int button)
{
    uiNode_t *node;

    /* captured or hover node */
    node = capturedNode ? capturedNode : hoveredNode;

    if (node != NULL) {
        UI_MoveWindowOnTop(node->root);
        if (node->behaviour->mouseDown)
            node->behaviour->mouseDown(node, x, y, button);
    }

    /* click event */
    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;
    }
    UI_PlaySound("click1");
}

void UI_MouseUp (int x, int y, int button)
{
    uiNode_t *node;

    /* captured or hover node */
    node = capturedNode ? capturedNode : hoveredNode;

    if (node == NULL)
        return;

    if (node->behaviour->mouseUp)
        node->behaviour->mouseUp(node, x, y, button);
}