ui_node_abstractscrollable.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_main.h"
#include "../ui_parse.h"
#include "../ui_behaviour.h"
#include "../ui_font.h"
#include "../ui_render.h"
#include "../ui_actions.h"
#include "../ui_lua.h"
 
#include "ui_node_abstractnode.h"
#include "ui_node_abstractscrollable.h"
 
#include "../../client.h" /* gettext _() */
 
#include "../../../common/scripts_lua.h"
 
#define EXTRADATA_TYPE abstractScrollableExtraData_t
#define EXTRADATA(node) UI_EXTRADATA(node, EXTRADATA_TYPE)

bool uiAbstractScrollableNode::isSizeChange (uiNode_t* node)
{
    assert(UI_Node_IsScrollableContainer(node));
 
    if (!Vector2Equal(node->box.size, EXTRADATA(node).cacheSize)) {
        Vector2Copy(node->box.size, EXTRADATA(node).cacheSize);
        return true;
    }
    return false;
}

bool uiScroll_t::move (int viewPos)
{
    /* clap position */
    if (viewPos > this->fullSize - this->viewSize)
        viewPos = this->fullSize - this->viewSize;
    if (viewPos < 0)
        viewPos = 0;
 
    /* no changes */
    if (this->viewPos == viewPos) {
        return false;
    }
 
    this->viewPos = viewPos;
    return true;
}

bool uiScroll_t::set (int viewPos, int viewSize, int fullSize)
{
    bool updated = false;
 
    /* default values */
    if (viewPos == -1)
        viewPos = this->viewPos;
    if (viewSize == -1)
        viewSize = this->viewSize;
    if (fullSize == -1)
        fullSize = this->fullSize;
 
    /* fix limits */
    if (viewSize < 0)
        viewSize = 0;
    if (fullSize < 0)
        fullSize = 0;
    if (viewPos < 0)
        viewPos = 0;
 
    /* clap position */
    if (viewSize >= fullSize)
        viewPos = 0;
    else if (viewPos > fullSize - viewSize)
        viewPos = fullSize - viewSize;
 
    /* update */
    if (this->viewPos != viewPos) {
        this->viewPos = viewPos;
        updated = true;
    }
    if (this->viewSize != viewSize) {
        this->viewSize = viewSize;
        updated = true;
    }
    if (this->fullSize != fullSize) {
        this->fullSize = fullSize;
        updated = true;
    }
 
    return updated;
}
 
void uiAbstractScrollableNode::initNode(uiNode_t* node) {
    uiLocatedNode::initNode(node);
    EXTRADATA(node).lua_onViewChange = LUA_NOREF;
}

bool uiAbstractScrollableNode::setScrollY (uiNode_t* node, int viewPos, int viewSize, int fullSize)
{
    bool updated;
    assert(UI_Node_IsScrollableContainer(node));
 
    updated = EXTRADATA(node).scrollY.set(viewPos, viewSize, fullSize);
 
    if (updated) {
        if (EXTRADATA(node).onViewChange) {
            UI_ExecuteEventActions(node, EXTRADATA(node).onViewChange);
        }
        else if (EXTRADATA(node).lua_onViewChange != LUA_NOREF) {
            UI_ExecuteLuaEventScript (node, EXTRADATA(node).lua_onViewChange);
        }
    }
 
 
    return updated;
}
 
void uiAbstractScrollableNode::pageUp (uiNode_t* node) {
    const int pos = EXTRADATA(node).scrollY.viewPos - 10;
    setScrollY(node, (pos >= 0)?pos:0, -1, -1);
}
void uiAbstractScrollableNode::pageDown (uiNode_t* node) {
    setScrollY(node, EXTRADATA(node).scrollY.viewPos + 10, -1, -1);
}
void uiAbstractScrollableNode::moveUp (uiNode_t* node) {
    setScrollY(node, EXTRADATA(node).scrollY.viewPos - 1, -1, -1);
}
void uiAbstractScrollableNode::moveDown(uiNode_t* node) {
    setScrollY(node, EXTRADATA(node).scrollY.viewPos + 1, -1, -1);
}
void uiAbstractScrollableNode::moveHome (uiNode_t* node) {
    setScrollY(node, 0, -1, -1);
}
void uiAbstractScrollableNode::moveEnd (uiNode_t* node) {
    setScrollY(node, EXTRADATA(node).scrollY.fullSize, -1, -1);
}

static void UI_AbstractScrollableNodePageUp (uiNode_t* node, const uiCallContext_t* context)
{
    uiAbstractScrollableNode* b = dynamic_cast<uiAbstractScrollableNode*>(node->behaviour->manager.get());
    b->pageUp(node);
}
 
static void UI_AbstractScrollableNodePageDown (uiNode_t* node, const uiCallContext_t* context)
{
    uiAbstractScrollableNode* b = dynamic_cast<uiAbstractScrollableNode*>(node->behaviour->manager.get());
    b->pageDown(node);
}
 
static void UI_AbstractScrollableNodeMoveUp (uiNode_t* node, const uiCallContext_t* context)
{
    uiAbstractScrollableNode* b = dynamic_cast<uiAbstractScrollableNode*>(node->behaviour->manager.get());
    b->moveUp(node);
}
 
static void UI_AbstractScrollableNodeMoveDown (uiNode_t* node, const uiCallContext_t* context)
{
    uiAbstractScrollableNode* b = dynamic_cast<uiAbstractScrollableNode*>(node->behaviour->manager.get());
    b->moveDown (node);
}
 
static void UI_AbstractScrollableNodeMoveHome (uiNode_t* node, const uiCallContext_t* context)
{
    uiAbstractScrollableNode* b = dynamic_cast<uiAbstractScrollableNode*>(node->behaviour->manager.get());
    b->moveHome (node);
}

static void UI_AbstractScrollableNodeMoveEnd (uiNode_t* node, const uiCallContext_t* context)
{
    uiAbstractScrollableNode* b = dynamic_cast<uiAbstractScrollableNode*>(node->behaviour->manager.get());
    b->moveEnd (node);
}

bool uiAbstractScrollableNode::scrollY (uiNode_t* node, int offset)
{
    assert(UI_Node_IsScrollableContainer(node));
    return setScrollY(node, EXTRADATA(node).scrollY.viewPos + offset, -1, -1);
}
 
void UI_RegisterAbstractScrollableNode (uiBehaviour_t* behaviour)
{
    behaviour->name = "abstractscrollable";
    behaviour->manager = UINodePtr(new uiAbstractScrollableNode());
    behaviour->isAbstract = true;
    behaviour->extraDataSize = sizeof(EXTRADATA_TYPE);
    behaviour->lua_SWIG_typeinfo = UI_SWIG_TypeQuery("uiAbstractScrollableNode_t *");
 
    /* position of the vertical view (into the full number of elements the node contain) */
    UI_RegisterExtradataNodeProperty(behaviour, "viewpos", V_INT, EXTRADATA_TYPE, scrollY.viewPos);
    /* size of the vertical view (proportional to the number of elements the node can display without moving) */
    UI_RegisterExtradataNodeProperty(behaviour, "viewsize", V_INT, EXTRADATA_TYPE, scrollY.viewSize);
    /* full vertical size (proportional to the number of elements the node contain) */
    UI_RegisterExtradataNodeProperty(behaviour, "fullsize", V_INT, EXTRADATA_TYPE, scrollY.fullSize);
    /* Called when one of the properties viewpos/viewsize/fullsize change */
    UI_RegisterExtradataNodeProperty(behaviour, "onviewchange", V_UI_ACTION, EXTRADATA_TYPE, onViewChange);
 
    /* Call it to vertically scroll the document up */
    UI_RegisterNodeMethod(behaviour, "pageup", UI_AbstractScrollableNodePageUp);
    /* Call it to vertically scroll the document down */
    UI_RegisterNodeMethod(behaviour, "pagedown", UI_AbstractScrollableNodePageDown);
    /* Call it to vertically scroll the document up */
    UI_RegisterNodeMethod(behaviour, "moveup", UI_AbstractScrollableNodeMoveUp);
    /* Call it to vertically scroll the document down */
    UI_RegisterNodeMethod(behaviour, "movedown", UI_AbstractScrollableNodeMoveDown);
    /* Call it to vertically reset the scroll position to 0 */
    UI_RegisterNodeMethod(behaviour, "movehome", UI_AbstractScrollableNodeMoveHome);
    /* Call it to vertically move the scroll to the end of the document */
    UI_RegisterNodeMethod(behaviour, "moveend", UI_AbstractScrollableNodeMoveEnd);
}