ui_node_baseinventory.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_parse.h"
#include "../ui_actions.h"
#include "../ui_dragndrop.h"
#include "../ui_tooltip.h"
#include "../ui_nodes.h"
#include "../ui_input.h"
#include "../ui_render.h"
#include "ui_node_baseinventory.h"
#include "ui_node_model.h"
#include "ui_node_container.h"
#include "ui_node_abstractnode.h"

#include "../../client.h"
#include "../../renderer/r_draw.h"
#include "../../renderer/r_mesh.h"
#include "../../cl_game.h"
#include "../../cl_team.h"
#include "../../battlescape/cl_actor.h"
#include "../../cl_inventory.h"

#define EXTRADATA_TYPE containerExtraData_t
#define EXTRADATA(node) UI_EXTRADATA(node, EXTRADATA_TYPE)
#define EXTRADATACONST(node) UI_EXTRADATACONST(node, EXTRADATA_TYPE)

static int dragInfoFromX = -1;
static int dragInfoFromY = -1;

static const invList_t *dragInfoIC;

static invList_t *UI_ContainerNodeGetExistingItem (const uiNode_t *node, objDef_t *item, const itemFilterTypes_t filterType)
{
    return INVSH_SearchInInventoryWithFilter(ui_inventory, EXTRADATACONST(node).container, NONE, NONE, item, filterType);
}

#define CII_AMMOONLY 0x01
#define CII_WEAPONONLY 0x02     
#define CII_AVAILABLEONLY 0x04
#define CII_NOTAVAILABLEONLY 0x08
#define CII_END 0x80

typedef struct {
    const uiNode_t* node;
    byte groupSteps[6];
    int groupID;
    itemFilterTypes_t filterEquipType;

    int itemID;             
    invList_t *itemFound;   
} containerItemIterator_t;

static void UI_ContainerItemIteratorNext (containerItemIterator_t *iterator)
{
    assert(iterator->groupSteps[iterator->groupID] != CII_END);

    /* iterate each groups */
    for (; iterator->groupSteps[iterator->groupID] != CII_END; iterator->groupID++) {
        int filter = iterator->groupSteps[iterator->groupID];
        /* next */
        iterator->itemID++;

        /* iterate all item type*/
        for (;iterator->itemID < csi.numODs; iterator->itemID++) {
            qboolean isAmmo;
            qboolean isWeapon;
            qboolean isArmour;
            objDef_t *obj = INVSH_GetItemByIDX(iterator->itemID);

            /* gameplay filter */
            if (!GAME_ItemIsUseable(obj))
                continue;

            /* type filter */
            isArmour = INV_IsArmour(obj);
            isAmmo = obj->numWeapons != 0 && INV_IsAmmo(obj);
            isWeapon = obj->weapon || obj->isMisc || isArmour;

            if ((filter & CII_WEAPONONLY) && !isWeapon)
                continue;
            if ((filter & CII_AMMOONLY) && !isAmmo)
                continue;
            if (!INV_ItemMatchesFilter(obj, iterator->filterEquipType))
                continue;

            /* exists in inventory filter */
            iterator->itemFound = UI_ContainerNodeGetExistingItem(iterator->node, obj, iterator->filterEquipType);
            if ((filter & CII_AVAILABLEONLY) && iterator->itemFound == NULL)
                continue;
            if ((filter & CII_NOTAVAILABLEONLY) && iterator->itemFound != NULL)
                continue;

            /* we found something */
            return;
        }

        /* can we search into another group? */
        if (iterator->groupSteps[iterator->groupID + 1] != CII_END)
            iterator->itemID = -1;
    }

    /* clean up */
    iterator->itemFound = NULL;
}

static void UI_ContainerItemIteratorInit (containerItemIterator_t *iterator, const uiNode_t* const node)
{
    int groupID = 0;
    iterator->itemID = -1;
    iterator->groupID = 0;
    iterator->node = node;
    iterator->filterEquipType = EXTRADATACONST(node).filterEquipType;

    if (EXTRADATACONST(node).displayAvailableOnTop) {
        /* available items */
        if (EXTRADATACONST(node).displayWeapon)
            iterator->groupSteps[groupID++] = CII_WEAPONONLY | CII_AVAILABLEONLY;
        if (EXTRADATACONST(node).displayAmmo)
            iterator->groupSteps[groupID++] = CII_AMMOONLY | CII_AVAILABLEONLY;
        /* unavailable items */
        if (EXTRADATACONST(node).displayUnavailableItem) {
            if (EXTRADATACONST(node).displayWeapon)
                iterator->groupSteps[groupID++] = CII_WEAPONONLY | CII_NOTAVAILABLEONLY;
            if (EXTRADATACONST(node).displayAmmo)
                iterator->groupSteps[groupID++] = CII_AMMOONLY | CII_NOTAVAILABLEONLY;
        }
    } else {
        const int filter = (EXTRADATACONST(node).displayUnavailableItem) ? 0 : CII_AVAILABLEONLY;
        if (EXTRADATACONST(node).displayWeapon)
            iterator->groupSteps[groupID++] = CII_WEAPONONLY | filter;
        if (EXTRADATACONST(node).displayAmmo)
            iterator->groupSteps[groupID++] = CII_AMMOONLY | filter;
    }
    iterator->groupSteps[groupID++] = CII_END;

    /* find the first item */
    UI_ContainerItemIteratorNext(iterator);
}

static void UI_BaseInventoryNodeUpdateScroll (uiNode_t* node)
{
    if (EXTRADATA(node).onViewChange) {
        UI_ExecuteEventActions(node, EXTRADATA(node).onViewChange);
    }
}

static void UI_GetItemTooltip (item_t item, char *tooltipText, size_t stringMaxLength)
{
    objDef_t *weapon;

    assert(item.t);

    if (item.amount > 1)
        Com_sprintf(tooltipText, stringMaxLength, "%i x %s\n", item.amount, _(item.t->name));
    else
        Com_sprintf(tooltipText, stringMaxLength, "%s\n", _(item.t->name));

    /* Only display further info if item.t is researched */
    if (GAME_ItemIsUseable(item.t)) {
        if (item.t->weapon) {
            /* Get info about used ammo (if there is any) */
            if (item.t == item.m) {
                /* Item has no ammo but might have shot-count */
                if (item.a) {
                    Q_strcat(tooltipText, va(_("Ammo: %i\n"), item.a), stringMaxLength);
                }
            } else if (item.m) {
                /* Search for used ammo and display name + ammo count */
                Q_strcat(tooltipText, va(_("%s loaded\n"), _(item.m->name)), stringMaxLength);
                Q_strcat(tooltipText, va(_("Ammo: %i\n"),  item.a), stringMaxLength);
            }
        } else if (item.t->numWeapons) {
            /* Check if this is a non-weapon and non-ammo item */
            if (!(item.t->numWeapons == 1 && item.t->weapons[0] == item.t)) {
                int i;
                /* If it's ammo get the weapon names it can be used in */
                Q_strcat(tooltipText, _("Usable in:\n"), stringMaxLength);
                for (i = 0; i < item.t->numWeapons; i++) {
                    weapon = item.t->weapons[i];
                    if (GAME_ItemIsUseable(weapon)) {
                        Q_strcat(tooltipText, va("* %s\n", _(weapon->name)), stringMaxLength);
                    }
                }
            }
        }
    }
}

static void UI_BaseInventoryNodeLoaded (uiNode_t* const node)
{
    EXTRADATA(node).container = INVSH_GetInventoryDefinitionByID("equip");
}

static const vec3_t scale = {3.5, 3.5, 3.5};
static const vec4_t colorDefault = {1, 1, 1, 1};
static const vec4_t colorLoadable = {0.5, 1, 0.5, 1};
static const vec4_t colorDisabled = {0.5, 0.5, 0.5, 1};
static const vec4_t colorDisabledHiden = {0.5, 0.5, 0.5, 0.5};
static const vec4_t colorDisabledLoadable = {0.5, 0.25, 0.25, 1.0};
static const vec4_t colorPreview = { 0.5, 0.5, 1, 1 };  
static int UI_BaseInventoryNodeDrawItems (uiNode_t *node, objDef_t *highlightType)
{
    qboolean outOfNode = qfalse;
    vec2_t nodepos;
    int items = 0;
    int rowHeight = 0;
    const int cellWidth = node->size[0] / EXTRADATA(node).columns;
    containerItemIterator_t iterator;
    int currentHeight = 0;
    UI_GetNodeAbsPos(node, nodepos);

    UI_ContainerItemIteratorInit(&iterator, node);
    for (; iterator.itemID < csi.numODs; UI_ContainerItemIteratorNext(&iterator)) {
        const int id = iterator.itemID;
        objDef_t *obj = INVSH_GetItemByIDX(id);
        item_t tempItem = {1, NULL, obj, 0, 0};
        vec3_t pos;
        vec3_t ammopos;
        const float *color;
        qboolean isHighlight = qfalse;
        int amount;
        const int col = items % EXTRADATA(node).columns;
        int cellHeight = 0;
        invList_t *icItem = iterator.itemFound;

        /* skip items over and bellow the node view */
        if (outOfNode || currentHeight < EXTRADATA(node).scrollCur) {
            int height;
            R_FontTextSize("f_verysmall", _(obj->name),
                cellWidth - 5, LONGLINES_WRAP, NULL, &height, NULL, NULL);
            height += obj->sy * C_UNIT + 10;
            if (height > rowHeight)
                rowHeight = height;

            if (outOfNode || currentHeight + rowHeight < EXTRADATA(node).scrollCur) {
                if (col == EXTRADATA(node).columns - 1) {
                    currentHeight += rowHeight;
                    rowHeight = 0;
                }
                items++;
                continue;
            }
        }

        Vector2Copy(nodepos, pos);
        pos[0] += cellWidth * col;
        pos[1] += currentHeight - EXTRADATA(node).scrollCur;
        pos[2] = 0;

        if (highlightType) {
            if (INV_IsAmmo(obj))
                isHighlight = INVSH_LoadableInWeapon(obj, highlightType);
            else
                isHighlight = INVSH_LoadableInWeapon(highlightType, obj);
        }

        if (icItem != NULL) {
            if (isHighlight)
                color = colorLoadable;
            else
                color = colorDefault;
        } else {
            if (isHighlight)
                color = colorDisabledLoadable;
            else
                color = colorDisabledHiden;
        }

        if (icItem)
            amount = icItem->item.amount;
        else
            amount = 0;

        /* draw item */
        pos[0] += obj->sx * C_UNIT / 2.0;
        pos[1] += obj->sy * C_UNIT / 2.0;
        UI_DrawItem(node, pos, &tempItem, -1, -1, scale, color);
        UI_DrawString("f_verysmall", ALIGN_LC,
            pos[0] + obj->sx * C_UNIT / 2.0, pos[1] + obj->sy * C_UNIT / 2.0,
            pos[0] + obj->sx * C_UNIT / 2.0, cellWidth - 5, /* maxWidth */
            0, va("x%i", amount), 0, 0, NULL, qfalse, 0);
        pos[0] -= obj->sx * C_UNIT / 2.0;
        pos[1] += obj->sy * C_UNIT / 2.0;
        cellHeight += obj->sy * C_UNIT;

        /* save position for ammo */
        Vector2Copy(pos, ammopos);
        ammopos[2] = 0;
        ammopos[0] += obj->sx * C_UNIT + 10;

        /* draw the item name. */
        cellHeight += UI_DrawString("f_verysmall", ALIGN_UL,
            pos[0], pos[1],
            pos[0], cellWidth - 5, /* max width */
            0, _(obj->name), 0, 0, NULL, qfalse, LONGLINES_WRAP);

        /* draw ammos of weapon */
        if (obj->weapon && EXTRADATA(node).displayAmmoOfWeapon) {
            int ammoIdx;
            for (ammoIdx = 0; ammoIdx < obj->numAmmos; ammoIdx++) {
                tempItem.t = obj->ammos[ammoIdx];

                /* skip unusable ammo */
                if (!GAME_ItemIsUseable(tempItem.t))
                    continue;

                /* find and skip none existing ammo */
                icItem = UI_ContainerNodeGetExistingItem(node, tempItem.t, EXTRADATA(node).filterEquipType);
                if (!icItem)
                    continue;

                /* Calculate the center of the item model/image. */
                ammopos[0] += icItem->item.t->sx * C_UNIT / 2.0;
                ammopos[1] -= icItem->item.t->sy * C_UNIT / 2.0;
                UI_DrawItem(node, ammopos, &tempItem, -1, -1, scale, colorDefault);
                UI_DrawString("f_verysmall", ALIGN_LC,
                    ammopos[0] + icItem->item.t->sx * C_UNIT / 2.0, ammopos[1] + icItem->item.t->sy * C_UNIT / 2.0,
                    ammopos[0] + icItem->item.t->sx * C_UNIT / 2.0, cellWidth - 5 - ammopos[0], /* maxWidth */
                    0, va("x%i", icItem->item.amount), 0, 0, NULL, qfalse, 0);
                ammopos[0] += icItem->item.t->sx * C_UNIT / 2.0;
                ammopos[1] += icItem->item.t->sy * C_UNIT / 2.0;
            }
        }
        cellHeight += 10;

        if (cellHeight > rowHeight) {
            rowHeight = cellHeight;
        }

        /* add a marge between rows */
        if (col == EXTRADATA(node).columns - 1) {
            currentHeight += rowHeight;
            rowHeight = 0;
            if (currentHeight - EXTRADATA(node).scrollCur >= node->size[1])
                outOfNode = qtrue;
        }

        /* count items */
        items++;
    }

    if (rowHeight != 0) {
        currentHeight += rowHeight;
    }
    return currentHeight;
}

static void UI_BaseInventoryNodeDraw2 (uiNode_t *node, objDef_t *highlightType)
{
    qboolean updateScroll = qfalse;
    int visibleHeight = 0;
    int needHeight = 0;
    vec2_t pos;

    UI_GetNodeAbsPos(node, pos);
    R_PushClipRect(pos[0], pos[1], node->size[0], node->size[1]);

    needHeight = UI_BaseInventoryNodeDrawItems(node, highlightType);

    R_PopClipRect();
    visibleHeight = node->size[1];

#if 0
    R_FontDrawString("f_verysmall", ALIGN_UL,
        node->pos[0], node->pos[1], node->pos[0], node->pos[1],
        0,  0,  /* maxWidth/maxHeight */
        0, va("%i %i/%i", EXTRADATA(node).scrollCur, visibleRows, totalRows), 0, 0, NULL, qfalse, 0);
#endif

    /* Update display of scroll buttons if something changed. */
    if (visibleHeight != EXTRADATA(node).scrollNum || needHeight != EXTRADATA(node).scrollTotalNum) {
        EXTRADATA(node).scrollTotalNum = needHeight;
        EXTRADATA(node).scrollNum = visibleHeight;
        updateScroll = qtrue;
    }
    if (EXTRADATA(node).scrollCur > needHeight - visibleHeight) {
        EXTRADATA(node).scrollCur = needHeight - visibleHeight;
        updateScroll = qtrue;
    }
    if (EXTRADATA(node).scrollCur < 0) {
        EXTRADATA(node).scrollCur = 0;
        updateScroll = qtrue;
    }

    if (updateScroll)
        UI_BaseInventoryNodeUpdateScroll(node);
}

static void UI_BaseInventoryNodeDraw (uiNode_t *node)
{
    objDef_t *highlightType = NULL;

    if (!EXTRADATA(node).container)
        return;
    if (!ui_inventory)
        return;
    /* is container invisible */
    if (node->color[3] < 0.001)
        return;

    /* Highlight weapons that the dragged ammo (if it is one) can be loaded into. */
    if (UI_DNDIsDragging() && UI_DNDGetType() == DND_ITEM) {
        highlightType = UI_DNDGetItem()->t;
    }

    UI_BaseInventoryNodeDraw2(node, highlightType);
}

static invList_t *UI_BaseInventoryNodeGetItem (const uiNode_t* const node,
    int mouseX, int mouseY, int* contX, int* contY)
{
    qboolean outOfNode = qfalse;
    vec2_t nodepos;
    int items = 0;
    int rowHeight = 0;
    const int cellWidth = node->size[0] / EXTRADATACONST(node).columns;
    int tempX, tempY;
    containerItemIterator_t iterator;
    int currentHeight = 0;

    if (!contX)
        contX = &tempX;
    if (!contY)
        contY = &tempY;

    UI_GetNodeAbsPos(node, nodepos);

    UI_ContainerItemIteratorInit(&iterator, node);
    for (; iterator.itemID < csi.numODs; UI_ContainerItemIteratorNext(&iterator)) {
        const int id = iterator.itemID;
        objDef_t *obj = INVSH_GetItemByIDX(id);
        vec2_t pos;
        vec2_t ammopos;
        const int col = items % EXTRADATACONST(node).columns;
        int cellHeight = 0;
        invList_t *icItem = iterator.itemFound;
        int height;

        /* skip items over and bellow the node view */
        if (outOfNode || currentHeight < EXTRADATACONST(node).scrollCur) {
            int height;
            R_FontTextSize("f_verysmall", _(obj->name),
                cellWidth - 5, LONGLINES_WRAP, NULL, &height, NULL, NULL);
            height += obj->sy * C_UNIT + 10;
            if (height > rowHeight)
                rowHeight = height;

            if (outOfNode || currentHeight + rowHeight < EXTRADATACONST(node).scrollCur) {
                if (col == EXTRADATACONST(node).columns - 1) {
                    currentHeight += rowHeight;
                    rowHeight = 0;
                }
                items++;
                continue;
            }
        }

        Vector2Copy(nodepos, pos);
        pos[0] += cellWidth * col;
        pos[1] += currentHeight - EXTRADATACONST(node).scrollCur;

        /* check item */
        if (mouseY < pos[1])
            break;
        if (mouseX >= pos[0] && mouseX < pos[0] + obj->sx * C_UNIT
         && mouseY >= pos[1] && mouseY < pos[1] + obj->sy * C_UNIT) {
            if (icItem) {
                *contX = icItem->x;
                *contY = icItem->y;
                return icItem;
            } else {
                return NULL;
            }
        }
        pos[1] += obj->sy * C_UNIT;
        cellHeight += obj->sy * C_UNIT;

        /* save position for ammo */
        Vector2Copy(pos, ammopos);
        ammopos[0] += obj->sx * C_UNIT + 10;

        /* draw the item name. */
        R_FontTextSize("f_verysmall", _(obj->name),
            cellWidth - 5, LONGLINES_WRAP, NULL, &height, NULL, NULL);
        cellHeight += height;

        /* draw ammos of weapon */
        if (obj->weapon && EXTRADATACONST(node).displayAmmoOfWeapon) {
            int ammoIdx;
            for (ammoIdx = 0; ammoIdx < obj->numAmmos; ammoIdx++) {
                objDef_t *objammo = obj->ammos[ammoIdx];

                /* skip unusable ammo */
                if (!GAME_ItemIsUseable(objammo))
                    continue;

                /* find and skip none existing ammo */
                icItem = UI_ContainerNodeGetExistingItem(node, objammo, EXTRADATACONST(node).filterEquipType);
                if (!icItem)
                    continue;

                /* check ammo (ammopos in on the left-lower corner) */
                if (mouseX < ammopos[0] || mouseY >= ammopos[1])
                    break;
                if (mouseX >= ammopos[0] && mouseX < ammopos[0] + objammo->sx * C_UNIT
                 && mouseY >= ammopos[1] - objammo->sy * C_UNIT && mouseY < ammopos[1]) {
                    *contX = icItem->x;
                    *contY = icItem->y;
                    return icItem;
                }
                ammopos[0] += objammo->sx * C_UNIT;
            }
        }
        cellHeight += 10;

        if (cellHeight > rowHeight) {
            rowHeight = cellHeight;
        }

        /* add a margin between rows */
        if (col == EXTRADATACONST(node).columns - 1) {
            currentHeight += rowHeight;
            rowHeight = 0;
            if (currentHeight - EXTRADATACONST(node).scrollCur >= node->size[1])
                return NULL;
        }

        /* count items */
        items++;
    }

    *contX = NONE;
    *contY = NONE;
    return NULL;
}

static void UI_BaseInventoryNodeDrawTooltip (uiNode_t *node, int x, int y)
{
    static char tooltiptext[MAX_VAR * 2];
    const invList_t *itemHover;
    vec2_t nodepos;

    UI_GetNodeAbsPos(node, nodepos);

    /* Find out where the mouse is. */
    itemHover = UI_BaseInventoryNodeGetItem(node, x, y, NULL, NULL);

    if (itemHover) {
        const int itemToolTipWidth = 250;

        /* Get name and info about item */
        UI_GetItemTooltip(itemHover->item, tooltiptext, sizeof(tooltiptext));
#ifdef DEBUG
        /* Display stored container-coordinates of the item. */
        Q_strcat(tooltiptext, va("\n%i/%i", itemHover->x, itemHover->y), sizeof(tooltiptext));
#endif
        UI_DrawTooltip(tooltiptext, x, y, itemToolTipWidth);
    }
}

static void UI_ContainerNodeAutoPlace (uiNode_t* node, int mouseX, int mouseY)
{
    int sel;
#if 0   /* see bellow #1 */
    int id;
#endif
    invList_t *ic;
    int fromX, fromY;

    if (!ui_inventory)
        return;

    /* don't allow this in tactical missions */
    if (CL_BattlescapeRunning())
        return;

    sel = cl_selected->integer;
    if (sel < 0)
        return;

    assert(EXTRADATA(node).container);

    ic = UI_BaseInventoryNodeGetItem(node, mouseX, mouseY, &fromX, &fromY);
    Com_DPrintf(DEBUG_CLIENT, "UI_ContainerNodeAutoPlace: item %i/%i selected from scrollable container.\n", fromX, fromY);
    if (!ic)
        return;
#if 0   /* see bellow #1 */
    id = ic->item.t->idx;
#endif

    /* Right click: automatic item assignment/removal. */
    if (EXTRADATA(node).container->id != csi.idEquip) {
        if (ic->item.m && ic->item.m != ic->item.t && ic->item.a) {
            /* Remove ammo on removing weapon from a soldier */
            INV_UnloadWeapon(ic, ui_inventory, INVDEF(csi.idEquip));
        } else {
            /* Move back to idEquip (ground, floor) container. */
            INV_MoveItem(ui_inventory, INVDEF(csi.idEquip), NONE, NONE, EXTRADATA(node).container, ic);
        }
    } else {
        qboolean packed = qfalse;
        int px, py;
        assert(ic->item.t);
        /* armour can only have one target */
        if (INV_IsArmour(ic->item.t)) {
            packed = INV_MoveItem(ui_inventory, INVDEF(csi.idArmour), 0, 0, EXTRADATA(node).container, ic);
        /* ammo or item */
        } else if (INV_IsAmmo(ic->item.t)) {
            INVSH_FindSpace(ui_inventory, &ic->item, INVDEF(csi.idBelt), &px, &py, NULL);
            packed = INV_MoveItem(ui_inventory, INVDEF(csi.idBelt), px, py, EXTRADATA(node).container, ic);
            if (!packed) {
                INVSH_FindSpace(ui_inventory, &ic->item, INVDEF(csi.idHolster), &px, &py, NULL);
                packed = INV_MoveItem(ui_inventory, INVDEF(csi.idHolster), px, py, EXTRADATA(node).container, ic);
            }
            if (!packed) {
                INVSH_FindSpace(ui_inventory, &ic->item, INVDEF(csi.idBackpack), &px, &py, NULL);
                packed = INV_MoveItem( ui_inventory, INVDEF(csi.idBackpack), px, py, EXTRADATA(node).container, ic);
            }
            /* Finally try left and right hand. There is no other place to put it now. */
            if (!packed) {
                const invList_t *rightHand = INVSH_SearchInInventory(ui_inventory, INVDEF(csi.idRight), 0, 0);

                /* Only try left hand if right hand is empty or no twohanded weapon/item is in it. */
                if (!rightHand || !rightHand->item.t->fireTwoHanded) {
                    INVSH_FindSpace(ui_inventory, &ic->item, INVDEF(csi.idLeft), &px, &py, NULL);
                    packed = INV_MoveItem(ui_inventory, INVDEF(csi.idLeft), px, py, EXTRADATA(node).container, ic);
                }
            }
            if (!packed) {
                INVSH_FindSpace(ui_inventory, &ic->item, INVDEF(csi.idRight), &px, &py, NULL);
                packed = INV_MoveItem(ui_inventory, INVDEF(csi.idRight), px, py, EXTRADATA(node).container, ic);
            }
        } else {
            if (ic->item.t->headgear) {
                INVSH_FindSpace(ui_inventory, &ic->item, INVDEF(csi.idHeadgear), &px, &py, NULL);
                packed = INV_MoveItem(ui_inventory, INVDEF(csi.idHeadgear), px, py, EXTRADATA(node).container, ic);
            } else {
                /* left and right are single containers, but this might change - it's cleaner to check
                 * for available space here, too */
                INVSH_FindSpace(ui_inventory, &ic->item, INVDEF(csi.idRight), &px, &py, NULL);
                packed = INV_MoveItem(ui_inventory, INVDEF(csi.idRight), px, py, EXTRADATA(node).container, ic);
                if (ic->item.t->weapon && !ic->item.a && packed)
                    INV_LoadWeapon(ic, ui_inventory, EXTRADATA(node).container, INVDEF(csi.idRight));
                if (!packed) {
                    const invList_t *rightHand = INVSH_SearchInInventory(ui_inventory, INVDEF(csi.idRight), 0, 0);

                    /* Only try left hand if right hand is empty or no twohanded weapon/item is in it. */
                    if (!rightHand || (rightHand && !rightHand->item.t->fireTwoHanded)) {
                        INVSH_FindSpace(ui_inventory, &ic->item, INVDEF(csi.idLeft), &px, &py, NULL);
                        packed = INV_MoveItem(ui_inventory, INVDEF(csi.idLeft), px, py, EXTRADATA(node).container, ic);
                        if (ic->item.t->weapon && !ic->item.a && packed)
                            INV_LoadWeapon(ic, ui_inventory, EXTRADATA(node).container, INVDEF(csi.idLeft));
                    }
                }
                if (!packed) {
                    INVSH_FindSpace(ui_inventory, &ic->item, INVDEF(csi.idBelt), &px, &py, NULL);
                    packed = INV_MoveItem(ui_inventory, INVDEF(csi.idBelt), px, py, EXTRADATA(node).container, ic);
                    if (ic->item.t->weapon && !ic->item.a && packed)
                        INV_LoadWeapon(ic, ui_inventory, EXTRADATA(node).container, INVDEF(csi.idBelt));
                }
                if (!packed) {
                    INVSH_FindSpace(ui_inventory, &ic->item, INVDEF(csi.idHolster), &px, &py, NULL);
                    packed = INV_MoveItem(ui_inventory, INVDEF(csi.idHolster), px, py, EXTRADATA(node).container, ic);
                    if (ic->item.t->weapon && !ic->item.a && packed)
                        INV_LoadWeapon(ic, ui_inventory, EXTRADATA(node).container, INVDEF(csi.idHolster));
                }
                if (!packed) {
                    INVSH_FindSpace(ui_inventory, &ic->item, INVDEF(csi.idBackpack), &px, &py, NULL);
                    packed = INV_MoveItem(ui_inventory, INVDEF(csi.idBackpack), px, py, EXTRADATA(node).container, ic);
                    if (ic->item.t->weapon && !ic->item.a && packed)
                        INV_LoadWeapon(ic, ui_inventory, EXTRADATA(node).container, INVDEF(csi.idBackpack));
                }
            }
        }
        /* no need to continue here - placement wasn't successful at all */
        if (!packed)
            return;
    }

    if (INV_IsArmour(ic->item.t)) {
        uiNode_t *armour = UI_GetNode(node->root, "armour");
        if (armour && armour->onChange)
            UI_ExecuteEventActions(armour, armour->onChange);
    }

    /* Update display of scroll buttons. */
    UI_BaseInventoryNodeUpdateScroll(node);
}

static int oldMouseX = 0;
static int oldMouseY = 0;

static void UI_BaseInventoryNodeCapturedMouseMove (uiNode_t *node, int x, int y)
{
    const int delta = abs(oldMouseX - x) + abs(oldMouseY - y);
    if (delta > 15) {
        UI_DNDDragItem(node, &(dragInfoIC->item));
        UI_MouseRelease();
    }
}

static void UI_BaseInventoryNodeMouseDown (uiNode_t *node, int x, int y, int button)
{
    switch (button) {
    case K_MOUSE1:
    {
        /* start drag and drop */
        int fromX, fromY;
        dragInfoIC = UI_BaseInventoryNodeGetItem(node, x, y, &fromX, &fromY);
        if (dragInfoIC) {
            dragInfoFromX = fromX;
            dragInfoFromY = fromY;
            oldMouseX = x;
            oldMouseY = y;
            UI_SetMouseCapture(node);
            EXTRADATA(node).lastSelectedId = dragInfoIC->item.t->idx;
            if (EXTRADATA(node).onSelect) {
                UI_ExecuteEventActions(node, EXTRADATA(node).onSelect);
            }
        }
        break;
    }
    case K_MOUSE2:
        if (UI_DNDIsDragging()) {
            UI_DNDAbort();
        } else {
            /* auto place */
            UI_ContainerNodeAutoPlace(node, x, y);
        }
        break;
    default:
        break;
    }
}

static void UI_BaseInventoryNodeMouseUp (uiNode_t *node, int x, int y, int button)
{
    if (button != K_MOUSE1)
        return;
    if (UI_GetMouseCapture() == node) {
        UI_MouseRelease();
    }
    if (UI_DNDIsDragging()) {
        UI_DNDDrop();
    }
}
static void UI_BaseInventoryNodeWheel (uiNode_t *node, qboolean down, int x, int y)
{
    const int delta = 20;
    if (down) {
        const int lenght = EXTRADATA(node).scrollTotalNum - EXTRADATA(node).scrollNum;
        if (EXTRADATA(node).scrollCur < lenght) {
            EXTRADATA(node).scrollCur += delta;
            if (EXTRADATA(node).scrollCur > lenght)
                EXTRADATA(node).scrollCur = lenght;
            UI_BaseInventoryNodeUpdateScroll(node);
        }
    } else {
        if (EXTRADATA(node).scrollCur > 0) {
            EXTRADATA(node).scrollCur -= delta;
            if (EXTRADATA(node).scrollCur < 0)
                EXTRADATA(node).scrollCur = 0;
            UI_BaseInventoryNodeUpdateScroll(node);
        }
    }
}

static void UI_BaseInventoryNodeLoading (uiNode_t *node)
{
    EXTRADATA(node).container = NULL;
    EXTRADATA(node).columns = 1;
    node->color[3] = 1.0;
}

static qboolean UI_BaseInventoryNodeDNDEnter (uiNode_t *target)
{
    /* The node is invalide */
    if (EXTRADATA(target).container == NULL)
        return qfalse;
    /* accept items only, if we have a container */
    return UI_DNDGetType() == DND_ITEM && UI_DNDGetSourceNode() != target;
}

static qboolean UI_BaseInventoryNodeDNDMove (uiNode_t *target, int x, int y)
{
    return qtrue;
}

static void UI_BaseInventoryNodeDNDLeave (uiNode_t *node)
{
}

static void UI_BaseInventoryNodeInit (uiNode_t *node)
{
    assert(!CL_BattlescapeRunning());
}

void UI_RegisterBaseInventoryNode (uiBehaviour_t* behaviour)
{
    behaviour->name = "baseinventory";
    behaviour->extends = "container";
    behaviour->draw = UI_BaseInventoryNodeDraw;
    behaviour->drawTooltip = UI_BaseInventoryNodeDrawTooltip;
    behaviour->mouseDown = UI_BaseInventoryNodeMouseDown;
    behaviour->mouseUp = UI_BaseInventoryNodeMouseUp;
    behaviour->mouseWheel = UI_BaseInventoryNodeWheel;
    behaviour->capturedMouseMove = UI_BaseInventoryNodeCapturedMouseMove;
    behaviour->init = UI_BaseInventoryNodeInit;
    behaviour->loading = UI_BaseInventoryNodeLoading;
    behaviour->loaded = UI_BaseInventoryNodeLoaded;

    behaviour->dndEnter = UI_BaseInventoryNodeDNDEnter;
    behaviour->dndMove = UI_BaseInventoryNodeDNDMove;
    behaviour->dndLeave = UI_BaseInventoryNodeDNDLeave;

    Com_RegisterConstInt("FILTER_S_PRIMARY", FILTER_S_PRIMARY);
    Com_RegisterConstInt("FILTER_S_SECONDARY", FILTER_S_SECONDARY);
    Com_RegisterConstInt("FILTER_S_HEAVY", FILTER_S_HEAVY);
    Com_RegisterConstInt("FILTER_S_MISC", FILTER_S_MISC);
    Com_RegisterConstInt("FILTER_S_ARMOUR", FILTER_S_ARMOUR);
    Com_RegisterConstInt("FILTER_CRAFTITEM", FILTER_CRAFTITEM);
    Com_RegisterConstInt("FILTER_UGVITEM", FILTER_UGVITEM);
    Com_RegisterConstInt("FILTER_AIRCRAFT", FILTER_AIRCRAFT);
    Com_RegisterConstInt("FILTER_DUMMY", FILTER_DUMMY);
    Com_RegisterConstInt("FILTER_DISASSEMBLY", FILTER_DISASSEMBLY);
}