ui_data.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 "../cl_shared.h"
#include "../cl_language.h"
#include "ui_main.h"
#include "ui_internal.h"
#include "ui_nodes.h"
#include "node/ui_node_option.h"
 
#include "../cl_language.h"

static const char* const ui_sharedDataIDNames[] = {
    "", 
    STRINGIFY(TEXT_STANDARD),
    STRINGIFY(TEXT_LIST),
    STRINGIFY(TEXT_LIST2),
    STRINGIFY(TEXT_UFOPEDIA),
    STRINGIFY(TEXT_UFOPEDIA_REQUIREMENT),
    STRINGIFY(TEXT_BUILDINGS),
    STRINGIFY(TEXT_BUILDING_INFO),
    STRINGIFY(TEXT_RESEARCH),
    STRINGIFY(TEXT_POPUP),
    STRINGIFY(TEXT_POPUP_INFO),
    STRINGIFY(TEXT_AIRCRAFT_LIST),
    STRINGIFY(TEXT_AIRCRAFT_INFO),
    STRINGIFY(TEXT_PRODUCTION_LIST),
    STRINGIFY(TEXT_PRODUCTION_AMOUNT),
    STRINGIFY(TEXT_PRODUCTION_INFO),
    STRINGIFY(TEXT_MOUSECURSOR_RIGHT),
    STRINGIFY(TEXT_PRODUCTION_QUEUED),
    STRINGIFY(TEXT_BASE_LIST),
    STRINGIFY(TEXT_MOUSECURSOR_PLAYERNAMES),
    STRINGIFY(TEXT_UFOPEDIA_MAILHEADER),
    STRINGIFY(TEXT_UFOPEDIA_MAIL),
    STRINGIFY(TEXT_CHAT_WINDOW),
    STRINGIFY(TEXT_AIREQUIP_1),
    STRINGIFY(TEXT_AIREQUIP_2),
    STRINGIFY(TEXT_BASEDEFENCE_LIST),
    STRINGIFY(TEXT_TIPOFTHEDAY),
    STRINGIFY(TEXT_GENERIC),
    STRINGIFY(TEXT_XVI),
    STRINGIFY(TEXT_MOUSECURSOR_TOP),
    STRINGIFY(TEXT_MOUSECURSOR_BOTTOM),
    STRINGIFY(TEXT_MOUSECURSOR_LEFT),
    STRINGIFY(TEXT_MESSAGEOPTIONS),
    STRINGIFY(TEXT_UFORECOVERY_NATIONS),
    STRINGIFY(TEXT_UFORECOVERY_UFOYARDS),
    STRINGIFY(TEXT_UFORECOVERY_CAPACITIES),
    STRINGIFY(TEXT_MATERIAL_STAGES),
    STRINGIFY(TEXT_IRCCONTENT),
    STRINGIFY(TEXT_IRCUSERS),
    STRINGIFY(TEXT_MULTIPLAYER_USERLIST),
    STRINGIFY(TEXT_MULTIPLAYER_USERTEAM),
    STRINGIFY(TEXT_ITEMDESCRIPTION),
    STRINGIFY(TEXT_MISSIONBRIEFING),
    STRINGIFY(TEXT_MISSIONBRIEFING_TITLE),
    STRINGIFY(TEXT_MISSIONBRIEFING_VICTORY_CONDITIONS),
 
    STRINGIFY(OPTION_LANGUAGES),
    STRINGIFY(OPTION_JOYSTICKS),
    STRINGIFY(OPTION_VIDEO_RESOLUTIONS),
    STRINGIFY(OPTION_SINGLEPLAYER_SKINS),
    STRINGIFY(OPTION_MULTIPLAYER_SKINS),
    STRINGIFY(OPTION_UFOPEDIA),
    STRINGIFY(OPTION_UFOS),
    STRINGIFY(OPTION_DROPSHIPS),
    STRINGIFY(OPTION_BASELIST),
    STRINGIFY(OPTION_TEAMDEFS),
    STRINGIFY(OPTION_PRODUCTION_REQUIREMENTS),
};
CASSERT(lengthof(ui_sharedDataIDNames) == UI_MAX_DATAID);

int UI_GetDataIDByName (const char* name)
{
    for (int num = 0; num < UI_MAX_DATAID; num++)
        if (Q_streq(name, ui_sharedDataIDNames[num]))
            return num;
 
    return -1;
}

void UI_RegisterText (int dataId, const char* text)
{
    UI_ResetData(dataId);
 
    if (!text)
        return;
 
    ui_global.sharedData[dataId].type = UI_SHARED_TEXT;
    ui_global.sharedData[dataId].data.text = text;
    ui_global.sharedData[dataId].versionId++;
}

void UI_RegisterLinkedListText (int dataId, linkedList_t* text)
{
    if (ui_global.sharedData[dataId].type == UI_SHARED_LINKEDLISTTEXT && ui_global.sharedData[dataId].data.linkedListText == text) {
        ui_global.sharedData[dataId].versionId++;
        return;
    }
    UI_ResetData(dataId);
    ui_global.sharedData[dataId].type = UI_SHARED_LINKEDLISTTEXT;
    ui_global.sharedData[dataId].data.linkedListText = text;
    ui_global.sharedData[dataId].versionId++;
}
 
const char* UI_GetText (int textId)
{
    if (ui_global.sharedData[textId].type != UI_SHARED_TEXT)
        return nullptr;
    return CL_Translate(ui_global.sharedData[textId].data.text);
}
 
const char* UI_GetTextFromList (int textId, int line)
{
    if (ui_global.sharedData[textId].type != UI_SHARED_LINKEDLISTTEXT)
        return nullptr;
    linkedList_t* list = ui_global.sharedData[textId].data.linkedListText;
    return static_cast<const char*>(LIST_GetByIdx(list, line));
}
 
int UI_GetDataVersion (int textId)
{
    return ui_global.sharedData[textId].versionId;
}

uiNode_t* UI_AddOption (uiNode_t** tree, const char* name, const char* label, const char* value)
{
    uiNode_t* last;
    uiNode_t* option;
    assert(tree != nullptr);
 
    option = UI_AllocOptionNode(name, label, value);
 
    /* append the option */
    last = *tree;
    if (last != nullptr) {
        while (last->next)
            last = last->next;
    }
 
    if (last)
        last->next = option;
    else
        *tree = option;
 
    return option;
}

static void UI_DeleteOption (uiNode_t* tree)
{
    while (tree) {
        uiNode_t* del = tree;
        tree = tree->next;
        UI_DeleteNode(del);
    }
}

void UI_ResetData (int dataId)
{
    assert(dataId < UI_MAX_DATAID);
    assert(dataId >= 0);
 
    switch (ui_global.sharedData[dataId].type) {
    case UI_SHARED_LINKEDLISTTEXT:
        LIST_Delete(&ui_global.sharedData[dataId].data.linkedListText);
        break;
    case UI_SHARED_OPTION:
        if (_Mem_AllocatedInPool(com_genericPool, ui_global.sharedData[dataId].data.option)) {
            UI_DeleteOption(ui_global.sharedData[dataId].data.option);
        }
        break;
    default:
        break;
    }
 
    ui_global.sharedData[dataId].type = UI_SHARED_NONE;
    ui_global.sharedData[dataId].data.text = nullptr;
    ui_global.sharedData[dataId].versionId++;
}

static uiNode_t* UI_OptionNodeRemoveHigherOption (uiNode_t** option)
{
    uiNode_t* prev = *option;
    uiNode_t* prevfind = nullptr;
    uiNode_t* search = (*option)->next;
    const char* label = CL_Translate(OPTIONEXTRADATA(*option).label);
 
    /* search the smaller element */
    while (search) {
        const char* searchlabel = CL_Translate(OPTIONEXTRADATA(search).label);
        if (strcmp(label, searchlabel) < 0) {
            prevfind = prev;
            label = searchlabel;
        }
        prev = search;
        search = search->next;
    }
 
    /* remove the first element */
    if (prevfind == nullptr) {
        uiNode_t* tmp = *option;
        *option = (*option)->next;
        return tmp;
    } else {
        uiNode_t* tmp = prevfind->next;
        prevfind->next = tmp->next;
        return tmp;
    }
}

void UI_SortOptions (uiNode_t** first)
{
    uiNode_t* option;
 
    /* unlink the unsorted list */
    option = *first;
    if (option == nullptr)
        return;
    *first = nullptr;
 
    /* construct a sorted list */
    while (option) {
        uiNode_t* element;
        element = UI_OptionNodeRemoveHigherOption(&option);
        element->next = *first;
        *first = element;
    }
}

void UI_UpdateInvisOptions (uiNode_t* option, const linkedList_t* stringList)
{
    if (option == nullptr || stringList == nullptr)
        return;
 
    while (option) {
        if (LIST_ContainsString(stringList, option->name))
            option->invis = false;
        else
            option->invis = true;
        option = option->next;
    }
}
 
void UI_RegisterOption (int dataId, uiNode_t* option)
{
    if (ui_global.sharedData[dataId].type == UI_SHARED_OPTION && ui_global.sharedData[dataId].data.option == option) {
        ui_global.sharedData[dataId].versionId++;
        return;
    }
    UI_ResetData(dataId);
    ui_global.sharedData[dataId].type = UI_SHARED_OPTION;
    ui_global.sharedData[dataId].data.option = option;
    ui_global.sharedData[dataId].versionId++;
}
 
uiNode_t* UI_GetOption (int dataId)
{
    if (ui_global.sharedData[dataId].type == UI_SHARED_OPTION) {
        return ui_global.sharedData[dataId].data.option;
    }
    return nullptr;
}

static uiNode_t* UI_FindOptionAtIndex (int index, uiNode_t* option, uiOptionIterator_t* iterator)
{
    while (option) {
        assert(option->behaviour == ui_optionBehaviour);
        if (option->invis) {
            option = option->next;
            continue;
        }
 
        /* we are on the right element */
        if (index == 0) {
            iterator->option = option;
            return option;
        }
 
        /* not the parent */
        index--;
 
        if (OPTIONEXTRADATA(option).collapsed) {
            option = option->next;
            continue;
        }
 
        /* its a child */
        if (index < OPTIONEXTRADATA(option).childCount) {
            if (iterator->depthPos >= MAX_DEPTH_OPTIONITERATORCACHE)
                assert(false);
            iterator->depthCache[iterator->depthPos] = option;
            iterator->depthPos++;
            return UI_FindOptionAtIndex(index, option->firstChild, iterator);
        }
        index -= OPTIONEXTRADATA(option).childCount;
        option = option->next;
    }
 
    iterator->option = nullptr;
    return nullptr;
}

uiNode_t* UI_InitOptionIteratorAtIndex(int index, uiNode_t* option, uiOptionIterator_t* iterator) {
    return UI_InitOptionIteratorAtIndex(index, option, iterator, true, true);
}

uiNode_t* UI_InitOptionIteratorAtIndex (int index, uiNode_t* option, uiOptionIterator_t* iterator, bool skipCollapsed, bool skipInvisible)
{
    assert(option == nullptr || option->behaviour == ui_optionBehaviour);
    OBJZERO(*iterator);
    iterator->skipCollapsed = skipCollapsed;
    iterator->skipInvisible = skipInvisible;
    return UI_FindOptionAtIndex(index, option, iterator);
}

uiNode_t* UI_OptionIteratorNextOption (uiOptionIterator_t* iterator)
{
    uiNode_t* option;
 
    option = iterator->option;
    assert(iterator->depthPos < MAX_DEPTH_OPTIONITERATORCACHE);
    iterator->depthCache[iterator->depthPos] = option;
    iterator->depthPos++;
 
    if (OPTIONEXTRADATA(option).collapsed && iterator->skipCollapsed)
        option = nullptr;
    else
        option = option->firstChild;
 
    while (true) {
        while (option) {
            if (!option->invis || !iterator->skipInvisible) {
                iterator->option = option;
                return option;
            }
            option = option->next;
        }
        if (iterator->depthPos == 0)
            break;
        iterator->depthPos--;
        option = iterator->depthCache[iterator->depthPos]->next;
    }
 
    iterator->option = nullptr;
    return nullptr;
}

uiNode_t* UI_FindOptionByValue (uiOptionIterator_t* iterator, const char* value)
{
    while (iterator->option) {
        assert(iterator->option->behaviour == ui_optionBehaviour);
        if (Q_streq(OPTIONEXTRADATA(iterator->option).value, value))
            return iterator->option;
        UI_OptionIteratorNextOption(iterator);
    }
    return nullptr;
}

int UI_FindOptionPosition (uiOptionIterator_t* iterator, const uiNode_t* option)
{
    int i = 0;
    while (iterator->option) {
        if (iterator->option == option)
            return i;
        i++;
        UI_OptionIteratorNextOption(iterator);
    }
    return -1;
}

static void UI_ResetData_f (void)
{
    if (Cmd_Argc() == 2) {
        const char* dataId = Cmd_Argv(1);
        const int id = UI_GetDataIDByName(dataId);
        if (id == -1)
            Com_Printf("%s: invalid data ID: %s\n", Cmd_Argv(0), dataId);
        else
            UI_ResetData(id);
    } else {
        for (int i = 0; i < UI_MAX_DATAID; i++)
            UI_ResetData(i);
    }
}

void UI_InitData (void)
{
    Cmd_AddCommand("ui_resetdata", UI_ResetData_f, "Resets memory and data used by a UI data id");
}