GuiUi.h

/****************************************************************************
 * libgui
 * Daryl Borth 2026
 * GuiUi.h
 *
 * The builder layer. A UiScope creates and owns a page's elements, so a screen
 * is built by describing it: no `new`, no `delete`, no helper structs holding
 * the pieces. Widgets here (GuiLabel, GuiChip, GuiTextButton, GuiCard) take
 * their look from GuiTheme, draw with no image assets, and report clicks and
 * focus through callbacks. Text, visibility and enabled state can be bound to
 * a function that is re-evaluated every frame.
 *
 *   UiScope ui;
 *   ui.column().gap(8)
 *     .add(ui.label("Controllers").fontSize(28))
 *     .add(ui.card().onClick([&]{ OpenPlayer(1); })
 *            .add(ui.label().bind([&]{ return DeviceName(1); })));
 *   ui.attachTo(page);
 *
 * Everything the scope made is destroyed with it, children before parents
 * or the other way round; the elements unhook themselves.
 ***************************************************************************/
#pragma once

typedef std::function<void()> UiCallback;

#if defined(__GNUC__)
std::string GuiFormat(const char * fmt, ...) __attribute__((format(printf, 1, 2)));
#else
std::string GuiFormat(const char * fmt, ...);
#endif
 
class UiScope;

class GuiLabel : public GuiText
{
    public:
        GuiLabel(UiScope& scope, const char * text = "");
        GuiLabel& fontSize(int px);
        GuiLabel& textColor(PixelColor c);
        GuiLabel& nudgeY(int n) { setNudgeY(n); return *this; }
        GuiLabel& muted();
        GuiLabel& accent();
        GuiLabel& bind(std::function<std::string()> fn);
        GuiLabel& visibleWhen(std::function<bool()> fn);
    private:
        UiScope& ui;
};

class GuiChip : public GuiOverlay
{
    public:
        GuiChip(UiScope& scope, const char * text = "");
        void setText(const char * t) { label.setText(t); }
        GuiChip& bind(std::function<std::string()> fn);
        GuiChip& visibleWhen(std::function<bool()> fn);
    private:
        UiScope& ui;
        GuiShape backdrop;
        GuiLabel label;
};

class GuiTextButton : public GuiButton
{
    public:
        GuiTextButton(UiScope& scope, const char * text);
        GuiTextButton& size(int w, int h);
        GuiTextButton& fontSize(int px);
        GuiTextButton& onClick(UiCallback fn);
        GuiTextButton& onFocus(UiCallback fn);
        GuiTextButton& style(const GuiShapeStyle& s);
        GuiTextButton& rounded(float radius);
        GuiTextButton& textNudge(int n) { text.setNudgeY(n); textLit.setNudgeY(n); return *this; }
        GuiTextButton& litTextColor(PixelColor c) { textLit.textColor(c); return *this; }
        GuiTextButton& disabled(bool d = true);
        void setText(const char * t);
        GuiTextButton& bind(std::function<std::string()> fn);
        GuiTextButton& visibleWhen(std::function<bool()> fn);
        GuiTextButton& enabledWhen(std::function<bool()> fn);
 
        void update(InputController * c) override;
        void setLayoutSize(int w, int h) override;
    private:
        UiScope& ui;
        GuiShape shape;
        GuiLabel text;
        GuiLabel textLit;
        UiCallback clickCb;
        UiCallback focusCb;
        bool wasSelected;
};

class GuiCardSurface : public GuiButton
{
    public:
        GuiCardSurface();
        void setLayoutSize(int w, int h) override;
        GuiShape shape;
};

class GuiCard : public GuiOverlay
{
    public:
        GuiCard(UiScope& scope);
        GuiCard& onClick(UiCallback fn);
        GuiCard& onFocus(UiCallback fn);
        GuiCard& style(const GuiShapeStyle& s);
        GuiCard& corners(const GuiCorners& c);
        GuiCard& selectable(bool s);
        GuiCard& disabled(bool d = true);
        GuiCard& visibleWhen(std::function<bool()> fn);
        void select() { surface.setState(STATE::SELECTED); }
        void deselect() { surface.resetState(); }
        bool isSelected() { const STATE s = surface.getState(); return s == STATE::SELECTED || s == STATE::HELD; }
        GuiCard& enabledWhen(std::function<bool()> fn);
        GuiCard& size(int w, int h) { setFixedSize(w, h); return *this; }
        GuiCard& pad(float all) { setPadding(all); return *this; }
        GuiCard& pad(float horizontal, float vertical) { setPadding(horizontal, vertical); return *this; }
        GuiCard& add(GuiElement& e, const GuiItem& item = GuiItem()) { GuiLayout::add(&e, item); return *this; }
        GuiCard& add(GuiElement * e, const GuiItem& item = GuiItem()) { GuiLayout::add(e, item); return *this; }
 
        void update(InputController * c) override;
    private:
        UiScope& ui;
        GuiCardSurface surface;
        UiCallback clickCb;
        UiCallback focusCb;
        bool wasSelected;
};

class UiScope
{
    public:
        UiScope();
        ~UiScope();
        UiScope(const UiScope&) = delete;
        UiScope& operator=(const UiScope&) = delete;

        template<class T, class... Args>
        T& make(Args&&... args)
        {
            Held<T> * h = new Held<T>(std::forward<Args>(args)...);
            holders.push_back(h);
            h->value.setRemoveOnDestroy(true); // unhooks from its parent if destroyed first
            return h->value;
        }
        template<class T, class... Args>
        T& own(Args&&... args)
        {
            Held<T> * h = new Held<T>(std::forward<Args>(args)...);
            holders.push_back(h);
            return h->value;
        }
 
        GuiRow& row() { return make<GuiRow>(); }
        GuiColumn& column() { return make<GuiColumn>(); }
        GuiGrid& grid(int columns) { return make<GuiGrid>(columns); }
        GuiOverlay& overlay() { return make<GuiOverlay>(); }
        GuiLabel& label(const char * text = "") { return make<GuiLabel>(*this, text); }
        GuiChip& chip(const char * text = "") { return make<GuiChip>(*this, text); }
        GuiTextButton& button(const char * text) { return make<GuiTextButton>(*this, text); }
        GuiCard& card() { return make<GuiCard>(*this); }
        GuiGlyph& glyph(GLYPH kind, const char * letter = "") { return make<GuiGlyph>(kind, letter); }

        void bind(UiCallback fn);
        void visibleWhen(GuiElement& e, std::function<bool()> fn);
        void enabledWhen(GuiElement& e, std::function<bool()> fn);

        const GuiTheme& theme() const { return GuiTheme::current(); }
        void setTrigger(GuiTrigger * t) { trig = t ? t : &primary; }
        GuiTrigger * trigger() { return trig; }
        void setSounds(GuiSound * over, GuiSound * click) { soundOver = over; soundClick = click; }
        GuiSound * getSoundOver() { return soundOver; }
        GuiSound * getSoundClick() { return soundClick; }

        void attachTo(GuiWindow& window);
        void runBindings();
 
    private:
        struct Holder { virtual ~Holder() {} };
        template<class T>
        struct Held : Holder
        {
            template<class... A> Held(A&&... a) : value(std::forward<A>(a)...) {}
            T value;
        };
        class Runner;
 
        std::vector<Holder*> holders;
        std::vector<UiCallback> bindings;
        GuiTrigger primary;
        GuiTrigger * trig;
        GuiSound * soundOver;
        GuiSound * soundClick;
        Runner * runner;
};