GuiLayout.h

/****************************************************************************
 * libgui
 * Daryl Borth 2026
 * GuiLayout.h
 *
 * Layout containers: GuiRow, GuiColumn, GuiGrid and GuiOverlay. They are
 * GuiWindows that position and size their children from rules instead of
 * pixel offsets. Drawing, input, focus and triggers are the ordinary GuiWindow
 * ones; a container only decides where its children go. The D-pad moves the
 * selection through nested containers by on-screen position.
 *
 * Sizes are in design-canvas pixels. A container's width or height of 0 means
 * "fit the content" on that axis. Layout re-runs by itself when a child's size,
 * visibility or the container's rules change, so a label whose text changes
 * simply reflows.
 ***************************************************************************/
#pragma once

struct GuiItem {
    float growWeight;       
    bool hasAlignH;            
    bool hasAlignV;         
    LAYOUT_ALIGN alignH;
    LAYOUT_ALIGN alignV;
    bool isBackground;      
 
    GuiItem() : growWeight(0), hasAlignH(false), hasAlignV(false),
        alignH(LAYOUT_ALIGN::START), alignV(LAYOUT_ALIGN::START), isBackground(false) {}

    GuiItem& grow(float weight = 1.0f) { growWeight = weight; return *this; }
    GuiItem& stretch() { return at(LAYOUT_ALIGN::STRETCH, LAYOUT_ALIGN::STRETCH); }
    GuiItem& alignStart() { return at(LAYOUT_ALIGN::START, LAYOUT_ALIGN::START); }
    GuiItem& alignCentre() { return at(LAYOUT_ALIGN::CENTRE, LAYOUT_ALIGN::CENTRE); }
    GuiItem& alignEnd() { return at(LAYOUT_ALIGN::END, LAYOUT_ALIGN::END); }
    GuiItem& at(LAYOUT_ALIGN h, LAYOUT_ALIGN v) { alignH = h; alignV = v; hasAlignH = hasAlignV = true; return *this; }
    GuiItem& background() { isBackground = true; return *this; }
};

class GuiLayout : public GuiWindow
{
    public:
        GuiLayout& add(GuiElement* e, const GuiItem& item = GuiItem());
        GuiLayout& add(GuiElement& e, const GuiItem& item = GuiItem()) { return add(&e, item); }
        GuiLayout& addGap(float size);
        GuiLayout& addSpace(float weight = 1.0f);
        GuiLayout& setPadding(float all);
        GuiLayout& setPadding(float horizontal, float vertical);
        GuiLayout& setPadding(float left, float top, float right, float bottom);
        GuiLayout& setSpacing(float s);
        GuiLayout& setSpacing(float x, float y);
        GuiLayout& setJustify(LAYOUT_JUSTIFY j);
        GuiLayout& setAlignItems(LAYOUT_ALIGN a);
        GuiLayout& setFixedSize(int w, int h);
        GuiLayout& size(int w, int h) { return setFixedSize(w, h); }
        GuiLayout& gap(float s) { return setSpacing(s); }
        GuiLayout& gap(float x, float y) { return setSpacing(x, y); }
        GuiLayout& pad(float all) { return setPadding(all); }
        GuiLayout& pad(float horizontal, float vertical) { return setPadding(horizontal, vertical); }
        GuiLayout& pad(float left, float top, float right, float bottom) { return setPadding(left, top, right, bottom); }
        GuiLayout& align(LAYOUT_ALIGN a) { return setAlignItems(a); }
        GuiLayout& justifyContent(LAYOUT_JUSTIFY j) { return setJustify(j); }
        void invalidate();
        void clear();
 
        void remove(GuiElement* e) override;
        void layout() override;
        void draw() override;
        void update(InputController * c) override;
        void getNaturalSize(int& w, int& h) override;
        void setLayoutSize(int w, int h) override;
        void collectNavigable(std::vector<GuiElement*>& out) override;
 
    protected:
        struct Entry {
            GuiElement * e;          
            GuiItem item;
            float gapSize;           
            int natW, natH;         
            int baseW, baseH;      
            int assignedW, assignedH;
            bool haveAssigned;
            int lastW, lastH;      
            bool lastVisible;
            Entry() : e(nullptr), gapSize(0), natW(0), natH(0), baseW(0), baseH(0), assignedW(0), assignedH(0),
                haveAssigned(false), lastW(-1), lastH(-1), lastVisible(true) {}
        };
 
        GuiLayout();
        virtual GuiLayoutResult solve(const std::vector<Entry*>& visible, float fixedW, float fixedH) = 0;
 
        GuiInsets padding;
        float spacingX;
        float spacingY;
        LAYOUT_JUSTIFY justify;
        LAYOUT_ALIGN alignItems;
 
    private:
        void syncEntries();
 
        std::vector<Entry> entries;
        std::vector<Entry*> visibleScratch; 
        int userFixedW, userFixedH;
        int assignedW, assignedH;
        int naturalW, naturalH;
        bool dirty;
        bool settled;                       
};

class GuiRow : public GuiLayout
{
    public:
        GuiRow(int w = 0, int h = 0);
    protected:
        GuiLayoutResult solve(const std::vector<Entry*>& visible, float fixedW, float fixedH) override;
};

class GuiColumn : public GuiLayout
{
    public:
        GuiColumn(int w = 0, int h = 0);
    protected:
        GuiLayoutResult solve(const std::vector<Entry*>& visible, float fixedW, float fixedH) override;
};

class GuiGrid : public GuiLayout
{
    public:
        GuiGrid(int columns, int w = 0, int h = 0);
    protected:
        GuiLayoutResult solve(const std::vector<Entry*>& visible, float fixedW, float fixedH) override;
    private:
        int columns;
};

class GuiOverlay : public GuiLayout
{
    public:
        GuiOverlay(int w = 0, int h = 0);
    protected:
        GuiLayoutResult solve(const std::vector<Entry*>& visible, float fixedW, float fixedH) override;
};