TreeView.hpp

//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2026 Bruno Van de Velde (vdv_b@tgui.eu)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
//    you must not claim that you wrote the original software.
//    If you use this software in a product, an acknowledgment
//    in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
//    and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
 
#ifndef TGUI_TREE_VIEW_HPP
#define TGUI_TREE_VIEW_HPP
 
#include <TGUI/Renderers/TreeViewRenderer.hpp>
#include <TGUI/Text.hpp>
#include <TGUI/Widgets/Scrollbar.hpp>

 
namespace tgui
{
    class TGUI_API TreeView : public Widget, public DualScrollbarChildInterface
    {
    public:
        using Ptr = std::shared_ptr<TreeView>;
        using ConstPtr = std::shared_ptr<const TreeView>;
 
        static constexpr char StaticWidgetType[] = "TreeView"; 

        struct ConstNode
        {
            bool expanded = true;
            String text;
            std::vector<ConstNode> nodes;
        };

        struct Node
        {
            Text text;
            unsigned int depth = 0;
            bool expanded = true;
            Node* parent = nullptr;
            std::vector<std::shared_ptr<Node>> nodes;
        };

        explicit TreeView(const char* typeName = StaticWidgetType, bool initRenderer = true);

        // Copy constructor
        TreeView(const TreeView& other);

        // Move constructor
        TreeView(TreeView&&) = default;

        // Overload of copy assignment operator
        TreeView& operator=(const TreeView& other);

        // Overload of move assignment operator
        TreeView& operator=(TreeView&&) = default;

        [[nodiscard]] static TreeView::Ptr create();

        [[nodiscard]] static TreeView::Ptr copy(const TreeView::ConstPtr& treeView);

        [[nodiscard]] TreeViewRenderer* getSharedRenderer() override;
        [[nodiscard]] const TreeViewRenderer* getSharedRenderer() const override;

        [[nodiscard]] TreeViewRenderer* getRenderer() override;

        void setSize(const Layout2d& size) override;
        using Widget::setSize;

        bool addItem(const std::vector<String>& hierarchy, bool createParents = true);

        bool changeItem(const std::vector<String>& hierarchy, const String& leafText);

        void expand(const std::vector<String>& hierarchy);

        void expandAll();

        void collapse(const std::vector<String>& hierarchy);

        void collapseAll();

        bool selectItem(const std::vector<String>& hierarchy);

        void deselectItem();

        bool removeItem(const std::vector<String>& hierarchy, bool removeParentsWhenEmpty = true);

        void removeAllItems();

        [[nodiscard]] std::vector<String> getSelectedItem() const;

        [[nodiscard]] std::vector<String> getHoveredItem() const;

        bool setItemIndexInParent(const std::vector<String>& hierarchy, std::size_t index);

        int getItemIndexInParent(const std::vector<String>& hierarchy) const;

        bool changeItemHierarchy(const std::vector<String>& oldHierarchy, const std::vector<String>& newHierarchy);

        [[nodiscard]] ConstNode getNode(const std::vector<String>& hierarchy) const;

        [[nodiscard]] std::vector<ConstNode> getNodes() const;

        void setItemHeight(unsigned int itemHeight);

        [[nodiscard]] unsigned int getItemHeight() const;

        TGUI_DEPRECATED("Use getVerticalScrollbar()->setValue(value) instead") void setVerticalScrollbarValue(unsigned int value);

        TGUI_DEPRECATED("Use getVerticalScrollbar()->getValue() instead")
        [[nodiscard]] unsigned int getVerticalScrollbarValue() const;

        TGUI_DEPRECATED("Use getVerticalScrollbar()->getMaxValue() instead")
        [[nodiscard]] unsigned int getVerticalScrollbarMaxValue() const;

        TGUI_DEPRECATED("Use getHorizontalScrollbar()->setValue(value) instead")
        void setHorizontalScrollbarValue(unsigned int value);

        TGUI_DEPRECATED("Use getHorizontalScrollbar()->getValue() instead")
        [[nodiscard]] unsigned int getHorizontalScrollbarValue() const;

        TGUI_DEPRECATED("Use getHorizontalScrollbar()->getMaxValue() instead")
        [[nodiscard]] unsigned int getHorizontalScrollbarMaxValue() const;

        [[nodiscard]] bool isMouseOnWidget(Vector2f pos) const override;

        bool leftMousePressed(Vector2f pos) override;

        void leftMouseReleased(Vector2f pos) override;

        void rightMousePressed(Vector2f pos) override;

        void mouseMoved(Vector2f pos) override;

        bool scrolled(float delta, Vector2f pos, bool touch) override;

        void mouseNoLongerOnWidget() override;

        void leftMouseButtonNoLongerDown() override;

        void keyPressed(const Event::KeyEvent& event) override;

        bool canHandleKeyPress(const Event::KeyEvent& event) override;

        void markNodesDirty();

        void draw(BackendRenderTarget& target, RenderStates states) const override;

 
    protected:
        [[nodiscard]] Signal& getSignal(String signalName) override;

        void rendererChanged(const String& property) override;

        [[nodiscard]] std::unique_ptr<DataIO::Node> save(SavingRenderersMap& renderers) const override;

        void load(const std::unique_ptr<DataIO::Node>& node, const LoadingRenderersMap& renderers) override;

        void updateTextSize() override;

        void scrollbarPolicyChanged(Orientation orientation) override;

        // Returns the size without the borders
        [[nodiscard]] Vector2f getInnerSize() const;

        // Updates the bounds of the icons
        void updateIconBounds();

        // This function is called every frame with the time passed since the last frame.
        bool updateTime(Duration elapsedTime) override;

        // Makes a copy of the widget
        [[nodiscard]] Widget::Ptr clone() const override;

        void updateTextColors(std::vector<std::shared_ptr<Node>>& nodes);

        void createNode(std::vector<std::shared_ptr<Node>>& nodes, Node* parent, const String& text);

        [[nodiscard]] Node* findParentNode(const std::vector<String>& hierarchy,
                                           unsigned int parentIndex,
                                           std::vector<std::shared_ptr<Node>>& nodes,
                                           Node* parent,
                                           bool createParents);

        // Expands or collapses one of the visible items
        void toggleNodeInternal(std::size_t index);

        // Expands or collapses a node
        bool expandOrCollapse(const std::vector<String>& hierarchy, bool expand);

        // Helper function to load the items from a text file
        void loadItems(const std::unique_ptr<DataIO::Node>& node, std::vector<std::shared_ptr<Node>>& items, Node* parent);

        // Rebuilds the list of visible items and positions the texts
        unsigned int updateVisibleNodes(std::vector<std::shared_ptr<Node>>& nodes, Node* selectedNode, float textPadding, unsigned int pos);

        // Updates the text colors of the selected and hovered items
        void updateSelectedAndHoveringItemColors();

        // Updates the text color of the hovered item
        void updateHoveredItem(int item);

        // Updates the text color of the selected item
        void updateSelectedItem(int item);

 
    public:
        SignalItemHierarchy onItemSelect = {"ItemSelected"}; 
        SignalItemHierarchy onDoubleClick = {"DoubleClicked"}; 
        SignalItemHierarchy onExpand = {"Expanded"}; 
        SignalItemHierarchy onCollapse = {"Collapsed"}; 
        SignalItemHierarchy onRightClick = {
            "RightClicked"}; 

 
    protected:
        // This contains the nodes of the tree
        std::vector<std::shared_ptr<Node>> m_nodes;
        std::vector<std::shared_ptr<Node>> m_visibleNodes;
 
        int m_selectedItem = -1;
        int m_hoveredItem = -1;
 
        unsigned int m_itemHeight = 0;
        float m_maxRight = 0;
 
        Vector2f m_iconBounds;
 
        bool m_possibleDoubleClick = false;
        int m_doubleClickNodeIndex = -1;
 
        Sprite m_spriteBackground;
        Sprite m_spriteBranchExpanded;
        Sprite m_spriteBranchCollapsed;
        Sprite m_spriteLeaf;
 
        // Cached renderer properties
        Borders m_bordersCached;
        Borders m_paddingCached;
        Color m_borderColorCached;
        Color m_backgroundColorCached;
        Color m_textColorCached;
        Color m_textColorHoverCached;
        Color m_selectedTextColorCached;
        Color m_selectedTextColorHoverCached;
        Color m_selectedBackgroundColorCached;
        Color m_selectedBackgroundColorHoverCached;
        Color m_backgroundColorHoverCached;
        TextStyles m_textStyleCached;
    };
} // namespace tgui
 
#endif // TGUI_TREE_VIEW_HPP