gui_dock_node.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/gui_id.h>
#include <gui_core/gui_base_types.h>
#include <gui_core/gui_units.h>
 
#include <functional>
#include <initializer_list>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace tachyon
{
 
    class IDManager;
 

    enum class DockSplitMode : uint8_t
    {
        LeftPinned,    
        RightPinned,   
        TopPinned,     
        BottomPinned,  
    };

    constexpr bool IsHorizontalSplit(DockSplitMode m)
    {
        return m == DockSplitMode::LeftPinned || m == DockSplitMode::RightPinned;
    }

    constexpr bool PinsSecondChild(DockSplitMode m)
    {
        return m == DockSplitMode::RightPinned || m == DockSplitMode::BottomPinned;
    }

    enum class DockDropZone : uint8_t
    {
        None,       
        Left,
        Right,
        Top,
        Bottom,
        Center      
    };

    enum class TabBarLayout : uint8_t
    {
        OneRow,  
        Rows     
    };

    struct DockNode
    {
        ID   nodeID = ID::Invalid();

        ID   tabBarID = ID::Invalid();
        bool isLeaf = true;             
 
        // ---- Leaf fields ----
        std::vector<ID> panelIds;       
        int selectedTab = 0;            
        int selectedTabBeforeDrag = 0; 
        TabBarLayout tabLayout = TabBarLayout::OneRow;   

        ID lastContentID      = ID::Invalid();
        ID lastContentPanelID = ID::Invalid();

        IntRect cachedContentRect {};
        IntRect cachedLeafRect {};      
        IntRect cachedTabBarRect {};    
        IntRect cachedSplitRect {};     
        std::vector<IntRect> cachedTabRects {}; 
 
        // ---- Split fields (only when !isLeaf) ----
        DockSplitMode mode = DockSplitMode::LeftPinned;  
        CssPx splitSize     = 200;   
        CssPx minFirstSize  = 80;    
        CssPx minSecondSize = 80;    
        std::unique_ptr<DockNode> first;   
        std::unique_ptr<DockNode> second;  
    };
 
    // ---- Factory helpers ----------------------------------------------------

    std::unique_ptr<DockNode> MakeLeaf(std::initializer_list<ID> panelIds = {});
    std::unique_ptr<DockNode> MakeSplit(DockSplitMode mode,
                                        CssPx splitSize,
                                        std::unique_ptr<DockNode> first,
                                        std::unique_ptr<DockNode> second,
                                        CssPx minFirstSize = 80,
                                        CssPx minSecondSize = 80);
 
    // ---- Pure tree operations -----------------------------------------------

    void ReorderLeafTabs(DockNode& node, int from, int to);

    void ReleaseDockTreeIDs(DockNode* node, IDManager* idManager);

    bool CloseLeafTab(DockNode& node, int tabIndex);

    void CollapseEmptyLeaves(std::unique_ptr<DockNode>& rootRef, IDManager* idManager = nullptr);

    bool RemovePanel(std::unique_ptr<DockNode>& rootRef, ID panelId, IDManager* idManager = nullptr);

    DockNode*       FindNode(DockNode* root, ID nodeID);
    const DockNode* FindNode(const DockNode* root, ID nodeID);

    struct SplitSizeRange { int min; int max; };
    SplitSizeRange ComputeSplitSizeRange(const DockNode& splitNode,
                                         int containerExtent,
                                         int sizerThickness);

    int ClampSplitSize(const DockNode& splitNode,
                       int containerExtent,
                       int sizerThickness);

    void AssignMissingNodeIDs(DockNode* root, IDManager& idManager);
 
    // ---- Drop target result ----------------------------------------------------

    struct DockDropTarget
    {
        DockNode*    leaf   = nullptr;              
        DockDropZone zone   = DockDropZone::None;   
    };
 
    // ---- Drop-zone geometry ----------------------------------------------------

    DockDropZone ComputeDropZone(IntRect rect, int2 point, float edgeFraction = 0.25f);
 
    // ---- Tab drop position -----------------------------------------------------

    int2 TabRowCursor(const DockNode& leaf, int2 cursor);

    int TabInsertionIndex(const DockNode& leaf, int2 cursor);
 
    // ---- Tree mutation for split-on-drop ---------------------------------------

    std::unique_ptr<DockNode>* FindNodeOwner(std::unique_ptr<DockNode>& rootRef, const DockNode* target);

    DockNode* SplitLeafAtZone(std::unique_ptr<DockNode>& leafRef,
                               ID droppedPanelId,
                               DockDropZone zone,
                               CssPx initialSplitSize = 200);
 
    // ---- Layout save / restore ---------------------------------------------------
    std::string SerializeDockTree(const DockNode& root, const std::function<std::string(ID)>& keyOf);

    std::unique_ptr<DockNode> ParseDockTree(std::string_view text,
        const std::function<std::optional<ID>(std::string_view)>& idOf);

    std::vector<ID> UnplacedPanels(const DockNode& root, const std::vector<ID>& allPanels);

} // namespace tachyon