gui_table_types.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/gui_id.h>
#include <gui_core/input/gui_pointer_drag.h>
#include <gui_core/gui_units.h>
#include <gui_core/gui_base_types.h>
#include <gui_core/style/gui_style.h>
#include <gui_core/style/gui_style_manager.h>
#include <gui_core/layout/gui_layout_grid.h>
#include <gui_core/layout/gui_constraints.h>
#include <gui_core/elements/gui_element.h>
#include <gui_core/input/gui_input_handler_func.h>
#include <gui_core/input/gui_input_enums.h>
 
#include <gui_controls/gui_widget_state_types.h>   // MultiSelectState, ItemDragDropConfig, DoubleClickTracker, TreeDropPosition
 
#include <array>
#include <cassert>
#include <functional>
#include <memory>
#include <optional>
#include <unordered_map>
#include <vector>
 
// Table widget data model: column descriptors, the user-owned persistent
// TableState, drag/drop state and the per-emit TableEmit.
 
namespace tachyon
{
 
    // ---- Table widget: row x column data grid ----
    //
    // TableColumn describes a column; callers pass an array each frame.
    // TableState is user-owned and persists widths and selection/sort state;
    // its `internal` member is not part of the API.
    //
    enum class ColumnSizing : uint8_t {
        Resizable,
        Fixed,
        Stretch,
    };

    enum class SectionSizing : uint8_t {
        Scrollable,
        FitContent,
    };

    struct TableColumn {
        std::string_view header;                 
        CssPx   initialWidth = 120;              
        CssPx   minWidth     = 40;               
        CssPx   maxWidth     = 2000;             
        bool    sortable     = false;            
        bool    locked       = false;
        ColumnSizing sizing  = ColumnSizing::Resizable;
        bool    interactiveContent = false;
        StyleRef columnBackground = StyleRef::Invalid();
        StyleRef cellStyle = StyleRef::Invalid();
    };

    struct VirtualTableColumn {
        TableColumn                       column;
        std::function<void(int rowIndex)> generateCell;

        std::function<bool(int rowA, int rowB)> sortAscending;

        int              sectionId        = 0;
        SectionSizing    sectionSizing    = SectionSizing::Scrollable;

        struct Internal
        {
            int32_t                maxContentWidth = 0;
            tachyon::ID         bodyID          = tachyon::ID::Invalid();
            tachyon::ID         sizerID         = tachyon::ID::Invalid();
            tachyon::ID         headerCellID    = tachyon::ID::Invalid();
            tachyon::ElementRef headerRef       = tachyon::ElementRef::Invalid();
            int16_t                dragOffsetX     = 0;
            GridTrack              columnTrack{};
        } internal;  
    };

    enum class TableSelectionMode : uint8_t
    {
        Row,
        Cell,
    };

    struct PendingRowClick
    {
        tachyon::ID          rowID        = tachyon::ID::Invalid();
        tachyon::KeyModifier mods         = tachyon::KeyModifier::None;
        bool             dragPromoted = false;
    };

    struct TableState
    {
        struct TreeRowInfo
        {
            bool*        isOpen      = nullptr;          
            int          depth       = 0;                
            std::string* renameBuf   = nullptr;          
            std::string  renameSeed;                     
            bool         hasChildren = false;            
        };
        using TreeRowMap = std::unordered_map<tachyon::ID, TreeRowInfo>;  

        struct CellLookupEntry { tachyon::ID rowID; int columnIdx; };
        using CellLookupMap = std::unordered_map<tachyon::ID, CellLookupEntry>;

        using ReorderColumnsFn = std::function<void(int fromCol, int toCol)>;

        class LazyReorderFn
        {
        public:
            LazyReorderFn() = default;
            LazyReorderFn(std::nullptr_t) noexcept {}
 
            template <typename F,
                      typename = std::enable_if_t<!std::is_same_v<std::decay_t<F>, LazyReorderFn>>>
            LazyReorderFn& operator=(F&& f)
            {
                if (!_fn) _fn = std::make_unique<ReorderColumnsFn>();
                *_fn = std::forward<F>(f);
                return *this;
            }
            LazyReorderFn& operator=(std::nullptr_t) noexcept { _fn.reset(); return *this; }
 
            explicit operator bool() const noexcept { return _fn && static_cast<bool>(*_fn); }
            void operator()(int from, int to) const { (*_fn)(from, to); }
            ReorderColumnsFn*       get()       noexcept { return _fn.get(); }
            const ReorderColumnsFn* get() const noexcept { return _fn.get(); }
            void reset() noexcept { _fn.reset(); }
 
        private:
            std::unique_ptr<ReorderColumnsFn> _fn;
        };
 
        static constexpr int kMaxTableSections = 8;  
 
        // ---- HOT: read every frame ----------------------------------
        std::vector<int32_t>  columnWidths;
        MultiSelectState*     multiSelect      = nullptr;
        ItemDragDropConfig*   rowDragDrop      = nullptr;
        tachyon::ID               selectedRowID    = tachyon::ID::Invalid();
        bool                  followTail       = false;
        int                   selectedColumn   = 0;               
        int                   sortColumn       = -1;
        TableSelectionMode    selectionMode    = TableSelectionMode::Row;
        bool                  sortDescending   = false;           
        bool                  selectionBar     = false;
        StyleRef              rowStyle         = StyleRef::Invalid();
        StyleRef              cellStyle        = StyleRef::Invalid();
        bool                  showHeaders      = true;
        bool                  columnSeparators = true;
 
        LazyReorderFn                  onReorderColumns;           
        std::function<void(tachyon::ID rowID)> onRowDoubleClick;

        struct Internal
        {
            tachyon::ID bodyID          = tachyon::ID::Invalid();   
            tachyon::ID horzScrollbarID = tachyon::ID::Invalid();
            tachyon::ID vertScrollbarID = tachyon::ID::Invalid();
            int32_t        lastViewportH   = 0;               
            int32_t        lastViewportW   = 0;
            tachyon::ID rowsRangeID     = tachyon::ID::Invalid();
            int            totalRowCount   = 0;
            int32_t        actualRowHeight = 0;
            bool           anyHorzOverflow = false;
            bool           anyVertOverflow = false;
            bool           hasHeaders      = true;
            // followTail bookkeeping
            bool           followInit         = false;
            bool           followPinned       = true;
            int            prevFollowRowCount = 0;
 
            // Mode-specific, allocated on first use
            std::unique_ptr<TreeRowMap>    treeRowInfo;               
            std::vector<int>               treeVisibleIdx;
            std::unique_ptr<CellLookupMap> cellLookup;                
 
            // Per-table gesture state, so tables don't share click detection
            DoubleClickTracker rowClickTracker;
            DoubleClickTracker treeCellClickTracker;
            PendingRowClick    pendingRowClick;

            std::unique_ptr<std::vector<int>> rowOrder;
            int                               sortedColumn     = -2;     
            bool                              sortedDescending = false;
            int                               sortedRowCount   = -1;
            bool                              rowOrderDirty    = false;

            tachyon::ID                                                     firstSectionBodyID = tachyon::ID::Invalid();
            std::unique_ptr<std::array<tachyon::ID, kMaxTableSections - 1>> extraSectionBodyIDs;
            int8_t                                                             sectionCount = 0;
            std::vector<tachyon::ElementRef>                                headerRefs;
        } internal;
 
        // ---- Accessors ----------------------------------------------
        tachyon::ID SectionBodyID(int i) const noexcept
        {
            if (i == 0) return internal.firstSectionBodyID;
            if (i < 1 || i >= kMaxTableSections || !internal.extraSectionBodyIDs) return tachyon::ID::Invalid();
            return (*internal.extraSectionBodyIDs)[size_t(i - 1)];
        }

        void SetSectionBodyID(int i, tachyon::ID id)
        {
            assert(i >= 0 && i < kMaxTableSections);
            if (i == 0) { internal.firstSectionBodyID = id; return; }
            if (!internal.extraSectionBodyIDs)
                internal.extraSectionBodyIDs = std::make_unique<std::array<tachyon::ID, kMaxTableSections - 1>>();
            (*internal.extraSectionBodyIDs)[size_t(i - 1)] = id;
        }

        TreeRowMap&    EnsureTreeRowInfo()
        {
            if (!internal.treeRowInfo) internal.treeRowInfo = std::make_unique<TreeRowMap>();
            return *internal.treeRowInfo;
        }

        CellLookupMap& EnsureCellLookup()
        {
            if (!internal.cellLookup) internal.cellLookup = std::make_unique<CellLookupMap>();
            return *internal.cellLookup;
        }

        tachyon::ID RowIDForIndex(int rowIdx) const noexcept
        {
            if (rowIdx >= internal.totalRowCount) return tachyon::ID::Invalid();
            return RowIDInRange(rowIdx);
        }

        tachyon::ID RowIDInRange(int rowIdx) const noexcept
        {
            if (internal.rowsRangeID == tachyon::ID::Invalid() || rowIdx < 0) return tachyon::ID::Invalid();
            tachyon::ID id{};
            id.value.subRangeParts.mode = tachyon::IDMode::SubRange;
            id.value.subRangeParts.index = static_cast<uint64_t>(rowIdx);
            id.value.subRangeParts.parentHashValue = internal.rowsRangeID.value.rangedParts.hashValue;
            return id;
        }

        int VisualToDataset(int visualIdx) const noexcept
        {
            if (!internal.rowOrder || visualIdx < 0 || visualIdx >= int(internal.rowOrder->size()))
                return visualIdx;
            return (*internal.rowOrder)[visualIdx];
        }

        int DatasetToVisual(int datasetIdx) const noexcept
        {
            if (!internal.rowOrder) return datasetIdx;
            const auto& v = *internal.rowOrder;
            for (size_t i = 0; i < v.size(); ++i)
                if (v[i] == datasetIdx) return int(i);
            return -1;
        }

        void InvalidateRowOrder() noexcept { internal.rowOrderDirty = true; }

        void RestartFollowTail() noexcept
        {
            internal.followInit         = false;
            internal.followPinned       = true;
            internal.prevFollowRowCount = 0;
        }

        const TreeRowInfo* FindTreeRow(tachyon::ID id) const noexcept
        {
            if (!internal.treeRowInfo) return nullptr;
            auto it = internal.treeRowInfo->find(id);
            return (it == internal.treeRowInfo->end()) ? nullptr : &it->second;
        }

        const CellLookupEntry* FindCell(tachyon::ID id) const noexcept
        {
            if (!internal.cellLookup) return nullptr;
            auto it = internal.cellLookup->find(id);
            return (it == internal.cellLookup->end()) ? nullptr : &it->second;
        }
    };
 
    // ---- Column-reorder drag state (survives across frames) ----
    //
    // Cells use explicit grid placement, so instead of reordering elements the dragged
    // column gets a Relative() offset. On drop, onReorderColumns fires.
    struct ColumnDragState {
        tachyon::PointerDrag          press;               
        tachyon::ID                   tableID   = tachyon::ID::Invalid();
        int                       fromCol   = -1;
        int                       toCol     = -1;
        int32_t                   offsetX   = 0;       
        std::vector<tachyon::IntRect> headerRects;
        int                       minTarget = 0;
        int                       maxTarget = 0;
        tachyon::ID                   sectionBodyID = tachyon::ID::Invalid();
        int32_t                   startScrollX  = 0;

        bool IsDragging() const { return press.dragging; }
    };
 
    // ---- Persistent tree reorder drop state (survives across frames) ----
    // Drives the drop indicator line; targetDepth indents it so After and Inside differ visibly.
    struct TreeDropState {
        tachyon::ID           targetRowID  = tachyon::ID::Invalid();
        TreeDropPosition  position     = TreeDropPosition::None;
        int               targetDepth  = 0;
    };
 
    // ---- Table: row x column data grid ----
    //
    // Transient state of one VirtualTable call. Event handlers run at end of frame and
    // must never read it; they capture TableState pointers instead.
    struct TableEmit
    {
        // Inputs
        VirtualTableColumn*  columns     = nullptr;       
        size_t               columnCount = 0;
        TableState*          userState   = nullptr;
 
        // Per-table derived values, filled by VirtualTable's prologue
        bool    dragActive            = false;
        bool    cellMode              = false;
        int32_t lastColDragFixedWidth = 0;
        int     draggedCol            = -1;
        bool    anyHorzOverflow      = false;
        bool    anyVertOverflow      = false;
        bool    showHeaders          = true;
        bool    columnSeparators     = true;

        StyleRef cellStyleRef        = {};
 
        tachyon::EventHandler            sharedRowHandler;
        tachyon::EventHandler            sharedCellHandler;
 
        // Current position, read by Cell()/TreeCell()
        int               currentCol     = 0;
        tachyon::ID           currentRowID   = tachyon::ID::Invalid();
        tachyon::EventHandler currentRowHandler;
        int               directGridRow  = 0;
        int               directColStart = 0;

        bool                isRecording = false;
        tachyon::ID             containerID = tachyon::ID::Invalid();
        StyleRef            style       = {};
        LayoutOverride      constraints = {};
        int                 rowCount    = 0;
        std::vector<std::vector<std::function<void()>>> columnCells;
    };

}