ui_node_editor.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_main.h"
#include "../ui_parse.h"
#include "../ui_behaviour.h"
#include "../ui_draw.h"
#include "../ui_input.h"
#include "../ui_nodes.h"
#include "../ui_windows.h"
#include "../ui_render.h"
#include "../ui_actions.h"
#include "ui_node_editor.h"
#include "ui_node_abstractnode.h"

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

#include "../../../common/scripts_lua.h"

typedef enum {
    ZONE_NONE = -1,
    ZONE_TOPRIGHT_CORNER,
    ZONE_TOPLEFT_CORNER,
    ZONE_BOTTOMRIGHT_CORNER,
    ZONE_BOTTOMLEFT_CORNER,
    ZONE_BODY
} zoneNode_t;


static uiNode_t* anchoredNode = nullptr;
static const vec4_t red = {1.0, 0.0, 0.0, 1.0};
static const vec4_t grey = {0.8, 0.8, 0.8, 1.0};
static const int anchorSize = 10;
static zoneNode_t dragStatus = ZONE_NONE;
static int startX;
static int startY;

static void UI_EditorNodeHighlightNode (uiNode_t* node, const vec4_t color, bool displayAnchor)
{
    vec2_t pos;
    UI_GetNodeAbsPos(node, pos);

    UI_DrawRect(pos[0] - 1, pos[1] - 1, node->box.size[0] + 2, node->box.size[1] + 2, color, 1.0, 0x3333);

    if (displayAnchor) {
        UI_DrawFill(pos[0] - anchorSize, pos[1] - anchorSize, anchorSize, anchorSize, color);
        UI_DrawFill(pos[0] - anchorSize, pos[1] + node->box.size[1], anchorSize, anchorSize, color);
        UI_DrawFill(pos[0] + node->box.size[0], pos[1] + node->box.size[1], anchorSize, anchorSize, color);
        UI_DrawFill(pos[0] + node->box.size[0], pos[1] - anchorSize, anchorSize, anchorSize, color);
    }
}

static zoneNode_t UI_EditorNodeGetElementAtPosition (uiNode_t* node, int x, int y)
{
    UI_NodeAbsoluteToRelativePos(anchoredNode, &x, &y);

    if (x > 0 && x < node->box.size[0] && y > 0 && y < node->box.size[1]) {
        return ZONE_BODY;
    }

    if (y > -anchorSize && y < 0) {
        if (x > -anchorSize && x < 0) {
            return ZONE_TOPLEFT_CORNER;
        } else if (x > node->box.size[0] && x < node->box.size[0] + anchorSize) {
            return ZONE_TOPRIGHT_CORNER;
        }
    } else if (y > node->box.size[1] && y < node->box.size[1] + anchorSize) {
        if (x > -anchorSize && x < 0) {
            return ZONE_BOTTOMLEFT_CORNER;
        } else if (x > node->box.size[0] && x < node->box.size[0] + anchorSize) {
            return ZONE_BOTTOMRIGHT_CORNER;
        }
    }
    return ZONE_NONE;
}

void uiEditorNode::draw (uiNode_t* node)
{
    UI_CaptureDrawOver(node);
}

void uiEditorNode::drawOverWindow (uiNode_t* node)
{
    uiNode_t* hovered = nullptr;

    if (UI_GetMouseCapture() != node) {
        if (anchoredNode)
            UI_EditorNodeHighlightNode(anchoredNode, red, false);
        return;
    }

    if (dragStatus == ZONE_NONE) {
#if 0   /* it does nothing, remember why we need that... */
        if (anchoredNode)
            UI_EditorNodeGetElementAtPosition(anchoredNode, mousePosX, mousePosY);
#endif
        hovered = UI_GetNodeAtPosition(mousePosX, mousePosY);
        /* do not edit node from editor window */
        if (hovered && hovered->root == node->root)
            hovered = nullptr;
    }

    if (hovered && hovered != anchoredNode)
        UI_EditorNodeHighlightNode(hovered, grey, true);

    if (anchoredNode)
        UI_EditorNodeHighlightNode(anchoredNode, red, true);
}

void uiEditorNode::onCapturedMouseMove (uiNode_t* node, int x, int y)
{
    vec2_t size;
    const int diffX = x - startX;
    const int diffY = y - startY;
    startX = x;
    startY = y;

    if (anchoredNode == nullptr)
        return;

    switch (dragStatus) {
    case ZONE_NONE:
        return;
    case ZONE_TOPLEFT_CORNER:
        anchoredNode->box.pos[0] += diffX;
        anchoredNode->box.pos[1] += diffY;
        size[0] = anchoredNode->box.size[0] - diffX;
        size[1] = anchoredNode->box.size[1] - diffY;
        break;
    case ZONE_TOPRIGHT_CORNER:
        anchoredNode->box.pos[1] += diffY;
        size[0] = anchoredNode->box.size[0] + diffX;
        size[1] = anchoredNode->box.size[1] - diffY;
        break;
    case ZONE_BOTTOMLEFT_CORNER:
        anchoredNode->box.pos[0] += diffX;
        size[0] = anchoredNode->box.size[0] - diffX;
        size[1] = anchoredNode->box.size[1] + diffY;
        break;
    case ZONE_BOTTOMRIGHT_CORNER:
        size[0] = anchoredNode->box.size[0] + diffX;
        size[1] = anchoredNode->box.size[1] + diffY;
        break;
    case ZONE_BODY:
        anchoredNode->box.pos[0] += diffX;
        anchoredNode->box.pos[1] += diffY;
        size[0] = anchoredNode->box.size[0];
        size[1] = anchoredNode->box.size[1];
        break;
    default:
        Sys_Error("UI_EditorNodeCapturedMouseMove: Invalid status of %i", dragStatus);
    }

    if (size[0] < 5)
        size[0] = 5;
    if (size[1] < 5)
        size[1] = 5;

    UI_NodeSetSize(anchoredNode, size);
}

void uiEditorNode::onCapturedMouseLost (uiNode_t* node)
{
    dragStatus = ZONE_NONE;
}

void uiEditorNode::onMouseUp (uiNode_t* node, int x, int y, int button)
{
    if (UI_GetMouseCapture() != node)
        return;
    if (button != K_MOUSE1)
        return;
    dragStatus = ZONE_NONE;
}

static void UI_EditorNodeSelectNode (uiNode_t* node, uiNode_t* selected)
{
    if (selected == nullptr)
        return;
    /* do not select a node from the editor window */
    if (selected->root == node->root)
        return;
    anchoredNode = selected;
    Cvar_Set("ui_sys_editor_node", "%s", anchoredNode->name);
    Cvar_Set("ui_sys_editor_window", "%s", anchoredNode->root->name);
}

void uiEditorNode::onMouseDown (uiNode_t* node, int x, int y, int button)
{
    uiNode_t* hovered;

    if (UI_GetMouseCapture() != node)
        return;
    if (button != K_MOUSE1)
        return;

    hovered = UI_GetNodeAtPosition(mousePosX, mousePosY);

    /* stop the capture */
    if (hovered && hovered->root == node->root) {
        UI_MouseRelease();
        return;
    }

    if (hovered == anchoredNode)
        hovered = nullptr;

    if (anchoredNode) {
        dragStatus = UI_EditorNodeGetElementAtPosition(anchoredNode, x, y);
        if (dragStatus == ZONE_BODY) {
            if (hovered == nullptr) {
                startX = x;
                startY = y;
                return;
            }
        } else if (dragStatus != ZONE_NONE) {
            startX = x;
            startY = y;
            return;
        }
    }

    /* select the node */
    UI_EditorNodeSelectNode(node, hovered);
}

static void UI_EditorNodeStart (uiNode_t* node, const uiCallContext_t* context)
{
    UI_SetMouseCapture(node);
}

static void UI_EditorNodeStop (uiNode_t* node, const uiCallContext_t* context)
{
    UI_MouseRelease();
}

static void UI_EditorNodeSelectNext (uiNode_t* node, const uiCallContext_t* context)
{
    if (dragStatus != ZONE_NONE)
        return;
    if (anchoredNode == nullptr)
        return;
    UI_EditorNodeSelectNode(node, anchoredNode->next);
}

static void UI_EditorNodeSelectParent (uiNode_t* node, const uiCallContext_t* context)
{
    if (dragStatus != ZONE_NONE)
        return;
    if (anchoredNode == nullptr)
        return;
    UI_EditorNodeSelectNode(node, anchoredNode->parent);
}

static void UI_EditorNodeSelectFirstChild (uiNode_t* node, const uiCallContext_t* context)
{
    if (dragStatus != ZONE_NONE)
        return;
    if (anchoredNode == nullptr)
        return;
    UI_EditorNodeSelectNode(node, anchoredNode->firstChild);
}

static void UI_EditorNodeExtractNode (qFILE* file, uiNode_t* node, int depth)
{
    assert(depth < 16);

    int i;
    char tab[16];
    for (i = 0; i < depth; i++) {
        tab[i] = '\t';
    }
    tab[i] = '\0';

    FS_Printf(file, "%s%s %s {\n", tab, node->behaviour->name, node->name);
    uiNode_t* child = node->firstChild;

    /* properties */
    if (child) {
        FS_Printf(file, "%s\t{\n", tab);
        FS_Printf(file, "%s\t\tpos\t\"%d %d\"\n", tab, (int)node->box.pos[0], (int)node->box.pos[1]);
        FS_Printf(file, "%s\t\tsize\t\"%d %d\"\n", tab, (int)node->box.size[0], (int)node->box.size[1]);
        FS_Printf(file, "%s\t}\n", tab);
    } else {
        FS_Printf(file, "%s\tpos\t\"%d %d\"\n", tab, (int)node->box.pos[0], (int)node->box.pos[1]);
        FS_Printf(file, "%s\tsize\t\"%d %d\"\n", tab, (int)node->box.size[0], (int)node->box.size[1]);
    }

    /* child */
    while (child) {
        UI_EditorNodeExtractNode(file, child, depth + 1);
        child = child->next;
    }

    FS_Printf(file, "%s}\n", tab);
}

static void UI_EditorNodeExtract_f (void)
{
    if (Cmd_Argc() != 2) {
        Com_Printf("Usage: %s <windowname>\n", Cmd_Argv(0));
        return;
    }
    uiNode_t* window = UI_GetWindow(Cmd_Argv(1));
    if (!window) {
        Com_Printf("Window '%s' not found\n", Cmd_Argv(1));
        return;
    }

    ScopedFile file;
    FS_OpenFile(va("window_%s_extracted.ufo", window->name), &file, FILE_WRITE);
    UI_EditorNodeExtractNode(&file, window, 0);

    Com_Printf("Window '%s' extracted.\n", Cmd_Argv(1));
}

void UI_RegisterEditorNode (uiBehaviour_t* behaviour)
{
    behaviour->name = "editor";
    behaviour->manager = UINodePtr(new uiEditorNode());
    behaviour->lua_SWIG_typeinfo = UI_SWIG_TypeQuery("uiEditorNode_t *");

    /* start edition mode */
    UI_RegisterNodeMethod(behaviour, "start", UI_EditorNodeStart);
    /* stop edition mode */
    UI_RegisterNodeMethod(behaviour, "stop", UI_EditorNodeStop);
    /* select the next node (according to the current one) */
    UI_RegisterNodeMethod(behaviour, "selectnext", UI_EditorNodeSelectNext);
    /* select the parent node (according to the current one) */
    UI_RegisterNodeMethod(behaviour, "selectparent", UI_EditorNodeSelectParent);
    /* select first child node (according to the current one) */
    UI_RegisterNodeMethod(behaviour, "selectfirstchild", UI_EditorNodeSelectFirstChild);

    Cmd_AddCommand("ui_extract", UI_EditorNodeExtract_f, "Extract position and size of nodes into a file");
    Cmd_AddParamCompleteFunction("ui_extract", UI_CompleteWithWindow);
}