controls_toolbar_dock.h

Go to the documentation of this file.

#pragma once
 
// ---------------------------------------------------------------------------
// Toolbar dock - frames a central content area with up to four sides of
// reorderable toolbar items, which can also be dragged between sides. Drop
// feedback matches the dock-tab drop indicator (controls_docking.cpp).
//
// The caller owns the data model (per-side item lists passed each frame) and
// applies changes from callbacks. ToolbarDockState holds the IDs, rect cache,
// ghost window and drop animation.
//
// The rect cache exists because the drag visualizer runs during construction,
// before layout; it reads last frame's rects (like DockNode::cachedLeafRect).
// ---------------------------------------------------------------------------
 
#include <gui_core/gui_id.h>
#include <gui_core/gui_base_types.h>
 
#include <chrono>
#include <functional>
#include <string_view>
#include <vector>
 
namespace tachyon
{
 
    class GUIApplication;

    enum class ToolbarSide : uint8_t { Top = 0, Right = 1, Bottom = 2, Left = 3 };
    inline constexpr int kToolbarSideCount = 4;   

    struct ToolbarDockState
    {
        ID      groupIDs[kToolbarSideCount] {};
        ID      ghostWindowID    = ID::Invalid();
        ID      dockContainerID  = ID::Invalid();

        IntRect cachedSideRects[kToolbarSideCount] {};
        IntRect cachedDockRect  {};   
 
        // Drop overlay animation between sides
        bool    dropAnimHasTarget = false;
        IntRect dropAnimCurrent {};
        IntRect dropAnimTarget  {};
        std::chrono::steady_clock::time_point dropAnimLastTime {};
    };

    void InitializeToolbarDockState(ToolbarDockState& state, GUIApplication& app);
    void ReleaseToolbarDockState  (ToolbarDockState& state, GUIApplication& app);

    struct ToolbarItem
    {
        ID                    id        = ID::Invalid();
        std::string           debugName {};   
        std::function<void()> renderBody;
    };

    struct ToolbarDockCallbacks
    {
        std::function<void(ToolbarSide side, int from, int to)>                       onReorder;
        std::function<void(ToolbarSide srcSide, int srcIdx, ToolbarSide tgtSide)>     onCrossSideDrop;
        std::function<void(ToolbarSide srcSide, int srcIdx, int2 mousePos)>           onTearOff;
    };

    struct FloatingToolbarItem
    {
        ToolbarItem item;
        ID          windowID      = ID::Invalid();
        int2        spawnPosition {};                  
        bool        positioned    = false;             
        std::string title         {};
        ToolbarSide homeSide      = ToolbarSide::Top;  
    };

    void RenderToolbarDock(
        GUIApplication&                                       app,
        ToolbarDockState&                                     state,
        const std::vector<ToolbarItem>                        (&itemsPerSide)[kToolbarSideCount],
        const ToolbarDockCallbacks&                           callbacks,
        std::function<void()>                                 renderContent);
    struct FloatingToolbarOptions
    {
        ToolbarDockState* dockState = nullptr;
        std::function<void(ID windowID, ToolbarSide tgtSide)> onDockBack;
    };
 
    // EmitFloatingToolbarWindows is a GUIApplication member (it needs the protected
    // BeginWindow / EndWindow): `app.EmitFloatingToolbarWindows(items, opts)`.

} // namespace tachyon