ui_dragndrop.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_dragndrop.h"
#include "ui_input.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 qboolean nodeAcceptDND = qfalse;     
static qboolean positionAcceptDND = qfalse; 
static uiDNDType_t objectType;              
static item_t draggingItem;                 
static uiNode_t *sourceNode;                
static uiNode_t *targetNode;                
qboolean UI_DNDIsDragging (void)
{
    return objectType != DND_NOTHING;
}

qboolean UI_DNDIsTargetNode (struct uiNode_s *node)
{
    if (!UI_DNDIsDragging())
        return qfalse;
    return targetNode == node;
}

qboolean UI_DNDIsSourceNode (struct uiNode_s *node)
{
    if (!UI_DNDIsDragging())
        return qfalse;
    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_t *item)
{
    UI_DNDDrag(node);
    assert(UI_DNDIsDragging());
    objectType = DND_ITEM;
    draggingItem = *item;
}

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

void UI_DNDAbort (void)
{
    assert(UI_DNDIsDragging());
    assert(objectType != DND_NOTHING);
    assert(sourceNode != NULL);

    if (nodeAcceptDND && targetNode) {
        targetNode->behaviour->dndLeave(targetNode);
    }
    sourceNode->behaviour->dndFinished(sourceNode, qfalse);

    UI_DNDCleanup();
    UI_InvalidateMouse();
}

void UI_DNDDrop (void)
{
    qboolean result = qfalse;
    assert(UI_DNDIsDragging());
    assert(objectType != DND_NOTHING);
    assert(sourceNode != NULL);

    if (!positionAcceptDND) {
        UI_DNDAbort();
        return;
    }

    if (targetNode) {
        result = targetNode->behaviour->dndDrop(targetNode, mousePosX, mousePosY);
    }
    sourceNode->behaviour->dndFinished(sourceNode, result);

    UI_PlaySound("item-drop");

    UI_DNDCleanup();
    UI_InvalidateMouse();
}

item_t *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) {
            targetNode->behaviour->dndLeave(targetNode);
        }
        targetNode = node;
        if (targetNode) {
            nodeAcceptDND = targetNode->behaviour->dndEnter(targetNode);
        }
    }

    if (targetNode == NULL) {
        nodeAcceptDND = qfalse;
        positionAcceptDND = qfalse;
        return;
    }

    if (!nodeAcceptDND) {
        positionAcceptDND = qfalse;
        return;
    }

    positionAcceptDND = node->behaviour->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(NULL, orgine, &draggingItem, -1, -1, scale, color);
        break;

    default:
        assert(qfalse);
    }
}