gui_docking_types.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/style/gui_style_text.h>      // IconID
 
#include <gui_controls/gui_dock_node.h>          // DockNode, DockDropTarget
#include <gui_core/windows/gui_window_backend.h> // WindowMode
 
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
// Docking + panel data model: Panel, DockingLayout (tree + panel registry),
// per-frame construction state, hit-test results and floating windows.
 
namespace tachyon
{
 
 
    // ---- TabBar: reorderable tabs ----
    struct TabBarOptions {
        std::string_view closeLabel = "Close Panel"; 
        bool listHidden = true;
        bool layoutMenu = true;  
        tachyon::ID dropArea = tachyon::ID::Invalid();
    };

    struct TabBarState {
        tachyon::ID barID = tachyon::ID::Invalid();
        int*    selectedIndex = nullptr;
        int     nextTabIndex = 0;
        std::function<void(int)>               onClose;    
        std::function<void(int, tachyon::int2)>    onDragOut;  
        TabBarLayout* layout = nullptr;         
        TabBarOptions options;
        std::vector<bool> shown;                
        struct HiddenTab { int index = 0; tachyon::IconID icon = tachyon::IconID::Invalid; std::string text; };
        std::vector<HiddenTab> hidden;          
    };

    struct TabState {
        bool        open     = false;  
        tachyon::ID id       = tachyon::ID::Invalid();
        tachyon::ID bodyID   = tachyon::ID::Invalid();
        int         index    = 0;
        bool        selected = false;
    };

    struct TabBarMemory {
        int tabCount   = 0;  
        int focusIndex = -1; 
        TabBarLayout layout = TabBarLayout::OneRow;   
 
        std::vector<int32_t> widths;        
        int32_t              barWidth = 0;  
        int32_t              overflowWidth = 0; 
        int32_t              trailingWidth = 0; 
    };
 
    // ---- Panel + DockingContainer ----
    // Panel: a unit of UI content, built by onPanelGUI during OnGUI. DockNodes store only
    // panel IDs; the Panels live in the DockingLayout.
    struct Panel {
        tachyon::ID               id = tachyon::ID::Invalid();      
        std::string           title;                                      
        tachyon::IconID           icon = tachyon::IconID::Invalid;  

        std::string           panelType;

        std::function<void()> onPanelGUI;

        std::function<std::optional<uint64_t>()> cacheSignature;

        std::function<void()> onEnable;
        std::function<void()> onDisable;

        struct Internal
        {
            bool enabled = false;
        } internal;  

        tachyon::int2             scrollOffset { 0, 0 };
    };

    struct DockingLayout {
        std::unique_ptr<tachyon::DockNode>     root;    
        std::unordered_map<tachyon::ID, Panel> panels;  

        tachyon::ID hostWindowID = tachyon::ID::Invalid();

        bool                  tabsInTitleBar = false;
        std::function<void()> onDock;   
    };

    struct DockingConstructionState {
        tachyon::ID        containerID = tachyon::ID::Invalid();
        DockingLayout* layout      = nullptr;
    };

    struct DockLeafResult {
        tachyon::DockNode* leaf   = nullptr;
        DockingLayout* layout = nullptr;
    };

    struct DockDropResult {
        tachyon::DockDropTarget target;
        DockingLayout*      layout = nullptr;
    };
 
    // ---- Floating dock windows ----
    // A torn-off tab dropped outside every dock area gets its own OS window.
    struct FloatingDockWindow {
        tachyon::ID       windowID    = tachyon::ID::Invalid();  
        DockingLayout layout;                                     
        tachyon::int2     spawnPosition {};                   
        bool          positioned = false;                 
        DockingLayout*  home       = nullptr;                
        tachyon::ID  homeLeafID = tachyon::ID::Invalid(); 
        bool            dockRequested = false;                
    };
 
    // ---- Documents ----
    // The level above panels: each document owns a whole panel layout, and the document bar
    // swaps the workspace below it.
    struct Document {
        tachyon::ID     id   = tachyon::ID::Invalid();   
        std::string     name;                            
        std::string     extension;                       
        std::string     kind;
        tachyon::IconID icon  = tachyon::IconID::Invalid;
        bool            dirty = false;                   
        DockingLayout   layout;                          

        struct Internal
        {
            tachyon::ID dockID       = tachyon::ID::Invalid(); 
            bool        closeAsked   = false;  
        } internal;  
    };

    struct DocumentSet {
        std::vector<std::unique_ptr<Document>> documents;
        int active = 0;   

        std::function<void()> onNew;
        std::function<bool(Document&)> onClose;
        std::function<void(std::unique_ptr<Document>, tachyon::int2)> onTearOff;

        Document*       Active()       { return active >= 0 && active < int(documents.size()) ? documents[size_t(active)].get() : nullptr; }
        const Document* Active() const { return active >= 0 && active < int(documents.size()) ? documents[size_t(active)].get() : nullptr; }

        struct Internal
        {
            tachyon::ID barID    = tachyon::ID::Invalid();  
            tachyon::ID tabBarID = tachyon::ID::Invalid();
            tachyon::ID hostWindowID = tachyon::ID::Invalid();  
            tachyon::IntRect barRect {};          
            std::vector<tachyon::IntRect> tabRects;   
        } internal;  
    };

    struct DocumentWindowRef {
        tachyon::ID        windowID  = tachyon::ID::Invalid();
        const DocumentSet* documents = nullptr;
    };

    struct SavedDocument {
        std::string name;
        std::string extension;
        std::string kind;
        std::string layout;   
    };

    struct SavedDocumentWindow {
        std::vector<SavedDocument> documents;   
        int              active = 0;            
        tachyon::IntRect rect {};               
        WindowMode       mode = WindowMode::Normal;
        tachyon::IntRect monitor {};            
    };

    struct DocumentDrag {
        Document*    document = nullptr;
        DocumentSet* source   = nullptr;
        int32_t      tabWidth = 0;   
        int32_t      grabOffset = 0; 
    };

    struct DocumentMove {
        Document*     document = nullptr;
        DocumentSet*  source   = nullptr;
        DocumentSet*  target   = nullptr;   
        int           index    = 0;         
        tachyon::int2 screenPos {};
    };

}