DynamicPanel.h

Go to the documentation of this file.

// Copyright (c) 2025 Dave R. Smith.
// Malena Framework — Licensed under PolyForm Noncommercial 1.0.0; commercial use requires a paid license. See LICENSE.
 
//
// DynamicPanel — a retained container for data-driven UI you rebuild declaratively.
//
// You describe the contents in an onBuild(builder) callback using text()/button()/
// rect()/input(); the panel POOLS the underlying widgets (reuses them across
// rebuilds, hides leftovers) so nothing is ever destroyed — and it defers the
// actual rebuild to a frame boundary, so calling invalidate() from inside a
// button's own click handler is safe (no rebuild-during-dispatch UAF). Text
// inputs are keyed by a stable id so the same physical field survives a rebuild
// (focus/typing preserved) and are auto-parked when a rebuild stops using them.
//
// This replaces the hand-rolled "pool + _dirty/onUpdate + park at -100000"
// boilerplate that data-driven hooks otherwise re-implement.
//
#ifndef MALENA_DYNAMICPANEL_H
#define MALENA_DYNAMICPANEL_H
 
#include <Malena/Graphics/Layouts/Panel.h>
#include <Malena/Graphics/Controls/RectangleButton.h>
#include <Malena/Graphics/Text/Text.h>
#include <Malena/Graphics/Text/TextInput.h>
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
namespace ml {
 
class MALENA_API DynamicPanel : public Panel
{
public:
    DynamicPanel();
 
    // Non-copyable. Required, not stylistic: __declspec(dllexport) on a class
    // instantiates EVERY member, including the implicit copy assignment — and
    // that cannot be formed for a std::vector<std::unique_ptr<...>> member, so
    // MSVC fails the shared/DLL build with C2280. (Static builds and Clang/GCC
    // never instantiate it, which is why this only broke Windows Shared.)
    // Copying a scene-graph node was never valid anyway.
    DynamicPanel(const DynamicPanel&)            = delete;
    DynamicPanel& operator=(const DynamicPanel&) = delete;

    class MALENA_API Builder
    {
        DynamicPanel& _p;
        friend class DynamicPanel;
        explicit Builder(DynamicPanel& p) : _p(p) {}
    public:
        Text& text(const std::string& s, float x, float y, unsigned size,
                   const sf::Color& color, bool center = false);

        RectangleButton& button(const std::string& label, float x, float y, float w, float h,
                                int style, std::function<void()> onClick);

        RectangleButton& rect(float x, float y, float w, float h, const sf::Color& fill);

        TextInput& input(const std::string& id, const std::string& placeholder,
                         float x, float y, float w, float h, const std::string& value,
                         std::function<void(const std::string&)> onChange);
    };

    void onBuild(std::function<void(Builder&)> fn);

    void setButtonStyler(std::function<void(RectangleButton&, int /*style*/, float /*w*/, float /*h*/)> styler);

    void invalidate() { _dirty = true; }

    bool isRebuildPending() const { return _dirty; }
 
protected:
    void doRebuild();
 
private:
    RectangleButton& acquireButton();
    Text&            acquireText();
 
    std::function<void(Builder&)> _build;
    std::function<void(RectangleButton&, int, float, float)> _styler;
 
    std::vector<std::unique_ptr<RectangleButton>> _buttons;
    std::vector<std::unique_ptr<Text>>            _texts;
    std::map<std::string, std::unique_ptr<TextInput>> _inputs;
 
    std::size_t          _btnUsed = 0, _txtUsed = 0;
    std::set<std::string> _usedInputs;
    bool                 _dirty = false;
};
 
} // namespace ml
 
#endif // MALENA_DYNAMICPANEL_H