ui_dragndrop.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_internal.h"
#include "ui_dragndrop.h"
#include "ui_input.h"
#include "ui_node.h"
#include "ui_sound.h"
 
#include "node/ui_node_abstractnode.h"
#include "node/ui_node_container.h"
 
#include "../input/cl_input.h"
 
static int oldMousePosX = -1;               
static int oldMousePosY = -1;               
 
static bool nodeAcceptDND = false;      
static bool positionAcceptDND = false;  
 
static uiDNDType_t objectType;              
static Item draggingItem;                   
 
static uiNode_t* sourceNode;                
static uiNode_t* targetNode;                
 

bool UI_DNDIsDragging (void)
{
    return objectType != DND_NOTHING;
}

bool UI_DNDIsTargetNode (uiNode_t* node)
{
    if (!UI_DNDIsDragging())
        return false;
    return targetNode == node;
}

bool UI_DNDIsSourceNode (uiNode_t* node)
{
    if (!UI_DNDIsDragging())
        return false;
    return sourceNode == node;
}

int UI_DNDGetType (void)
{
    return objectType;
}

uiNode_t* UI_DNDGetTargetNode (void)
{
    assert(UI_DNDIsDragging());
    return targetNode;
}

uiNode_t* UI_DNDGetSourceNode (void)
{
    assert(UI_DNDIsDragging());
    return sourceNode;
}

static void UI_DNDDrag (uiNode_t* node)
{
    assert(!UI_DNDIsDragging());
    objectType = DND_SOMETHING;
    sourceNode = node;
 
    UI_PlaySound("item-drag");
}

void UI_DNDDragItem (uiNode_t* node, const Item* item)
{
    UI_DNDDrag(node);
    assert(UI_DNDIsDragging());
    objectType = DND_ITEM;
    draggingItem = *item;
}

static inline void UI_DNDCleanup (void)
{
    objectType = DND_NOTHING;
    targetNode = nullptr;
    sourceNode = nullptr;
}

void UI_DNDAbort (void)
{
    assert(UI_DNDIsDragging());
    assert(objectType != DND_NOTHING);
    assert(sourceNode != nullptr);
 
    if (nodeAcceptDND && targetNode) {
        UI_Node_DndLeave(targetNode);
    }
    UI_Node_DndFinished(sourceNode, false);
 
    UI_DNDCleanup();
    UI_InvalidateMouse();
}

void UI_DNDDrop (void)
{
    bool result = false;
    assert(UI_DNDIsDragging());
    assert(objectType != DND_NOTHING);
    assert(sourceNode != nullptr);
 
    if (!positionAcceptDND) {
        UI_DNDAbort();
        return;
    }
 
    if (targetNode) {
        result = UI_Node_DndDrop(targetNode, mousePosX, mousePosY);
    }
    UI_Node_DndFinished(sourceNode, result);
 
    UI_PlaySound("item-drop");
 
    UI_DNDCleanup();
    UI_InvalidateMouse();
}
 
Item* UI_DNDGetItem (void)
{
    assert(objectType == DND_ITEM);
    return &draggingItem;
}

static void UI_DNDMouseMove (int mousePosX, int mousePosY)
{
    uiNode_t* node = UI_GetNodeAtPosition(mousePosX, mousePosY);
 
    if (node != targetNode) {
        if (nodeAcceptDND && targetNode) {
            UI_Node_DndLeave(targetNode);
        }
        targetNode = node;
        if (targetNode) {
            nodeAcceptDND = UI_Node_DndEnter(targetNode);
        }
    }
 
    if (targetNode == nullptr) {
        nodeAcceptDND = false;
        positionAcceptDND = false;
        return;
    }
 
    if (!nodeAcceptDND) {
        positionAcceptDND = false;
        return;
    }
 
    positionAcceptDND = UI_Node_DndMove(targetNode, mousePosX, mousePosY);
}

void UI_DrawDragAndDrop (int mousePosX, int mousePosY)
{
    const vec3_t scale = { 3.5, 3.5, 3.5 };
    vec3_t orgine;
    vec4_t color = { 1, 1, 1, 1 };
 
    /* check mouse move */
    if (mousePosX != oldMousePosX || mousePosY != oldMousePosY) {
        oldMousePosX = mousePosX;
        oldMousePosY = mousePosY;
        UI_DNDMouseMove(mousePosX, mousePosY);
    }
 
    /* draw the dragging item */
 
    VectorSet(orgine, mousePosX, mousePosY, -50);
 
    /* Tune down the opacity of the cursor-item if the preview item is drawn. */
    if (positionAcceptDND)
        color[3] = 0.2;
 
    switch (objectType) {
    case DND_ITEM:
        UI_DrawItem(nullptr, orgine, &draggingItem, -1, -1, scale, color);
        break;
 
    default:
        assert(false);
    }
}