SplitPanel.h

Go to the documentation of this file.

//
// SplitPanel.h
//
 
#ifndef MALENA_SPLITPANEL_H
#define MALENA_SPLITPANEL_H
 
#pragma once
 
#include <Malena/Core/malena_export.h>
#include <Malena/Core/Component.h>
#include <Malena/Core/Core.h>
#include <Malena/Manifests/Manifest.h>
#include <Malena/Resources/FontManager.h>
#include <Malena/Traits/Settings/SplitPanelSettings.h>
#include <Malena/Traits/Theme/SplitPanelTheme.h>
#include <Malena/Traits/Theme/Themeable.h>
#include <SFML/Graphics/RectangleShape.hpp>
#include <SFML/Graphics/RenderTarget.hpp>
#include <functional>
#include <memory>
#include <vector>
#include <type_traits>
#include <SFML/System/Vector2.hpp>
#include <Malena/Utilities/HasSetSize.h>
 
namespace ml
{
    class MALENA_API SplitPanelManifest : public ml::Manifest
    {
    public:
        enum class Flag  {};
        enum class State { IDLE, DIVIDER_HOVER, DIVIDER_DRAG };
    };

    class MALENA_API SplitPanel : public ComponentWith<SplitPanelManifest>,
                       public SplitPanelSettings,
                       public SplitPanelTheme,
                       public Themeable
    {
    public:
        using Flag        = SplitPanelManifest::Flag;
        using State       = SplitPanelManifest::State;
        using Orientation = SplitPanelSettings::Orientation;
        using HandleStyle = SplitPanelSettings::HandleStyle;
 
    private:
        struct Pane
        {
            std::unique_ptr<ml::Core>         content;
            std::function<void(sf::Vector2f)> resizeFn;   
            float                             size     = 0.f;   
            float                             minSize  = 0.f;   
            float                             maxSize  = 0.f;   
        };
 
        std::vector<Pane> _panes;
 
        sf::Vector2f _position = {0.f, 0.f};
        sf::Vector2f _size     = {400.f, 300.f};
 
        int   _hoveredDivider = -1;
        int   _draggingDiv    = -1;
        float _dragStartMouse = 0.f;
        float _dragStartSizeA = 0.f;
        float _dragStartSizeB = 0.f;
        bool  _prevMouseDown  = false;
 
        std::function<void(std::size_t, float)> _onDividerMoved;
 
        // ── Internal ──────────────────────────────────────────────────────────
        float totalAvailable()           const;
        float dividerPos(int divIdx)     const;
        int   hitTestDivider(const sf::Vector2f& wp) const;
        void  layoutPanes();
        void  distributeSizes();
        void  drawDivider(sf::RenderTarget& target,
                          const sf::RenderStates& states,
                          int divIdx, bool hovered, bool dragging) const;
 
    protected:
        void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
        void onThemeApplied(const Theme& theme) override;
 
    public:
        explicit SplitPanel(Orientation orientation = Orientation::HORIZONTAL,
                            const sf::Font& font = FontManager<>::getDefault());
 
        SplitPanel(const SplitPanel&)            = delete;
        SplitPanel& operator=(const SplitPanel&) = delete;
 
        // ── Apply ─────────────────────────────────────────────────────────────
 
        template<typename S>
        void applySettings(const S& s)
        {
            static_assert(std::is_base_of_v<SplitPanelSettings, S>,
                "applySettings() requires SplitPanelSettings");
            static_cast<SplitPanelSettings&>(*this) = s;
            layoutPanes();
        }
 
        template<typename T>
        void applyTheme(const T& t)
        {
            static_assert(std::is_base_of_v<SplitPanelTheme, T>,
                "applyTheme() requires SplitPanelTheme");
            static_cast<SplitPanelTheme&>(*this) = t;
        }
 
        template<typename St>
        void applyStyle(const St& s)
        {
            static_assert(std::is_base_of_v<SplitPanelSettings, St> &&
                          std::is_base_of_v<SplitPanelTheme, St>,
                "applyStyle() requires SplitPanelSettings and SplitPanelTheme");
            static_cast<SplitPanelSettings&>(*this) = s;
            static_cast<SplitPanelTheme&>(*this)    = s;
            layoutPanes();
        }
 
        // ── Pane management ───────────────────────────────────────────────────

        template<typename T>
        T& addPane(std::unique_ptr<T> content, float initialSize = 0.f)
        {
            static_assert(std::is_base_of_v<ml::Core, T>,
                "addPane() content must derive from ml::Core");
 
            T* ptr = content.get();
 
            Pane pane;
            pane.content  = std::move(content);
            pane.size     = initialSize;
 
            if constexpr (detail::has_setSize<T>::value)
                pane.resizeFn = [ptr](sf::Vector2f sz){ ptr->setSize(sz); };
 
            _panes.push_back(std::move(pane));
            distributeSizes();
            layoutPanes();
 
            return *ptr;
        }

        void setPaneMinSize(std::size_t index, float minSize);

        void setPaneMaxSize(std::size_t index, float maxSize);

        void setDividerPosition(std::size_t dividerIndex, float position);

        [[nodiscard]] std::size_t paneCount() const { return _panes.size(); }
 
        // ── Callback ─────────────────────────────────────────────────────────

        void onDividerMoved(std::function<void(std::size_t, float)> cb);
 
        // ── Size / position ───────────────────────────────────────────────────
 
        void setSize(const sf::Vector2f& size);
        [[nodiscard]] sf::Vector2f getSize() const { return _size; }
 
        void          setPosition(const sf::Vector2f& position) override;
        sf::Vector2f  getPosition()     const override;
        sf::FloatRect getGlobalBounds() const override;
    };
 
    template<typename MANIFEST>
    class SplitPanelWith : public SplitPanel, public Customizable<MANIFEST>
    { public: using SplitPanel::SplitPanel; };
 
} // namespace ml
#endif // MALENA_SPLITPANEL_H