Core.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.
 
//
// Created by Dave Smith on 10/4/25.
//
 
#ifndef MALENA_UICOMPONENTBASE_H
#define MALENA_UICOMPONENTBASE_H
 
#include <Malena/Core/malena_export.h>
#include <SFML/Graphics.hpp>
#include <functional>
#include <type_traits>
#include <vector>
 
#include <Malena/Traits/Communication/Subscribable.h>
#include <Malena/Traits/Interaction/Draggable.h>
#include <Malena/Traits/Spatial/Positionable.h>
#include <Malena/Traits/State/Flaggable.h>
 
#include <Malena/Traits/Interaction/Keyable.h>
#include <Malena/Traits/Interaction/Scrollable.h>
#include <Malena/Traits/Lifecycle/Updatable.h>
#include <Malena/Traits/Interaction/Clickable.h>
#include <Malena/Traits/Interaction/Focusable.h>
#include <Malena/Traits/Interaction/Hoverable.h>
 
#include <Malena/Traits/Communication/Unsubscribable.h>
 
namespace ml
{
    enum class Layer : int
    {
        Background = 0,
        Content    = 100,
        Overlay    = 200,
    };

    class MALENA_API Core : public virtual Subscribable,
                 public virtual Flaggable,
                 public virtual Positionable,
                 public virtual Clickable,
                 public virtual Hoverable,
                 public virtual Focusable,
                 public virtual Keyable,
                 public virtual Scrollable,
                 // public virtual Draggable,
                 public virtual Updatable,
                 public Unsubscribable
 
    {
    public:
        Core();
        virtual ~Core();
 
        virtual sf::RenderStates getRenderStates() const { return sf::RenderStates(); }
 
        // ── Enabled state ──────────────────────────────────────────────────
        // Two-flag model: effective enabled = _selfEnabled && _parentEnabled,
        // mirrored into Flag::ENABLED (what hit-testing filters on). This keeps
        // "a component I explicitly disabled stays disabled when its parent is
        // re-enabled" working.
        //
        // To REACT to an enable/disable change (sync visuals/colors, reset a
        // hover state, close a popup, …), override onEnabledChanged(bool
        // effective) — it fires on BOTH the direct (setEnabled) and cascade
        // (setParentEnabled) paths. Do NOT override setEnabled/setParentEnabled
        // to do that work, or the cascade path silently skips it. Controls do
        // NOT keep a separate "disabled" flag; disabled is read live from
        // Flag::ENABLED, so the flag and the visuals can never disagree.

        void setEnabled(bool enabled);

        void setParentEnabled(bool enabled);
 
        virtual void setVisible(bool visible);
        virtual void setActive(bool active);

        void setVisibilityIndependent(bool independent) { setFlag(Flag::VISIBILITY_INDEPENDENT, independent); }
        bool isVisibilityIndependent() const { return checkFlag(Flag::VISIBILITY_INDEPENDENT); }

        virtual void onWindowResize(unsigned int /*width*/, unsigned int /*height*/) {}
        bool isEnabled() const;
        bool isVisible() const;

        bool isEffectivelyVisible() const;

        static constexpr int DefaultLayer = 100;

        struct Child
        {
            Core* component;
            int   layer;
        };
 
        void addComponent(Core& child);
        void addComponent(Core& child, int layer);

        template<typename E,
                 typename = std::enable_if_t<std::is_enum_v<E>>>
        void addComponent(Core& child, E layer)
        {
            addComponent(child, static_cast<int>(layer));
        }
 
        void removeComponent(Core& child);

        Core* topmostMatching(const std::function<bool(Core&)>& accept);

        template<typename... Children>
        void addComponents(Children&... children)
        {
            static_assert((std::is_base_of_v<Core, Children> && ...),
                "addComponents() requires Core-derived arguments");
            (addComponent(children), ...);
        }

        template<typename... Children>
        void addComponents(int layer, Children&... children)
        {
            static_assert((std::is_base_of_v<Core, Children> && ...),
                "addComponents() requires Core-derived arguments");
            (addComponent(children, layer), ...);
        }

        template<typename E, typename... Children,
                 typename = std::enable_if_t<std::is_enum_v<E>>>
        void addComponents(E layer, Children&... children)
        {
            static_assert((std::is_base_of_v<Core, Children> && ...),
                "addComponents() requires Core-derived arguments");
            (addComponent(children, static_cast<int>(layer)), ...);
        }
 
        static void linkChild(Core* parent, Core* child);
        static void unlinkAll(Core* core);
 
    protected:
        virtual void onEnabledChanged(bool enabled) {}

        const std::vector<Child>& getChildren() const { return _children; }

        void drawChildren(sf::RenderTarget& target, sf::RenderStates states) const;
 
    private:
        bool _selfEnabled   = true;
        bool _parentEnabled = true;
 
        void applyEnabled(bool selfEnabled, bool parentEnabled);
 
        // ── Per-instance parent/child topology ──────────────────────────────
        // Replaces the static _childMap. Single-parent: a Core may appear in
        // at most one parent's _children vector at a time. linkChild silently
        // moves a child if its previous parent differs.
        Core*               _parent = nullptr;
        std::vector<Child>  _children;
 
        // Reentrancy guard for cascades that may indirectly trigger
        // removeComponent / linkChild. Mutations while iterating defer until
        // the depth returns to zero.
        int                                     _iterDepth = 0;
        std::vector<std::function<void()>>      _pendingOps;
 
        void doRemoveChild(Core* child);
        void runPendingIfDepthZero();
 
        // Insert a child keeping _children sorted by layer ascending, with
        // registration order preserved within a layer. O(n) positional insert,
        // not a full re-sort. Sets the child's _parent. Caller guarantees the
        // child is not already present.
        void insertChildSorted(Core& child, int layer);
 
        static bool isDescendantOf(Core* ancestor, Core* component);
        friend class AppManager;
    };
 
} // namespace ml
 
#endif // MALENA_UICOMPONENTBASE_H