spk_scrollable_area.hpp

#pragma once
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <limits>
#include <stdexcept>
#include <string>
#include <utility>
 
#include "structure/design_pattern/spk_contract_provider.hpp"
#include "structure/system/event/spk_mouse_event.hpp"
#include "structure/widget/spk_container_widget.hpp"
#include "structure/widget/spk_scroll_bar.hpp"
#include "structure/widget/spk_widget.hpp"
 
namespace spk
{
    template <typename TContent>
    class ScrolableArea : public Widget
    {
    private:
        struct ScrollLayout
        {
            bool showV = false;
            bool showH = false;
 
            Vector2UInt viewportSize = Vector2UInt::Zero;
 
            Extend2D vBar{};
            Extend2D hBar{};
 
            float vThumbRatio = 1.0f;
            float hThumbRatio = 1.0f;
 
            Vector2Int contentAnchor = {0, 0};
            Vector2UInt contentSize = Vector2UInt::Zero;
        };
 
        ContainerWidget _contentContainer;
        TContent _content;
 
        ScrollBar _horizontalScrollBar;
        ScrollBar _verticalScrollBar;
 
        Vector2UInt _lastViewportSize = Vector2UInt::Zero;
 
        spk::ObservableValue<float>::Contract _horizontalRatioContract;
        spk::ObservableValue<float>::Contract _verticalRatioContract;
 
    private:
        static Vector2UInt::value_type _subtractOrZero(Vector2UInt::value_type p_value, Vector2UInt::value_type p_amount)
        {
            return (p_amount >= p_value ? 0 : p_value - p_amount);
        }
 
        static Vector2UInt _resolveContentSize(const Vector2UInt &p_minimal, const Vector2UInt &p_desired, const Vector2UInt &p_maximal)
        {
            constexpr Vector2UInt::value_type MaxValue = std::numeric_limits<Vector2UInt::value_type>::max();
            const Vector2UInt fallback = Vector2UInt::max(p_minimal, p_desired);
            Vector2UInt result = p_maximal;
 
            if (result.x == MaxValue)
            {
                result.x = fallback.x;
            }
            if (result.y == MaxValue)
            {
                result.y = fallback.y;
            }
 
            return result;
        }
 
        static Vector2UInt _availableSize(const Vector2UInt &p_base, bool p_showVertical, bool p_showHorizontal, Vector2UInt::value_type p_scrollbarThickness)
        {
            Vector2UInt available = p_base;
            if (p_showVertical)
            {
                available.x = _subtractOrZero(available.x, p_scrollbarThickness);
            }
            if (p_showHorizontal)
            {
                available.y = _subtractOrZero(available.y, p_scrollbarThickness);
            }
            return (available);
        }
 
        static std::pair<bool, bool> _resolveVisibility(const Vector2UInt &p_containerSize, const Vector2UInt &p_contentSize, Vector2UInt::value_type p_scrollbarThickness)
        {
            bool showV = false;
            bool showH = false;
 
            bool dirty = true;
            while (dirty)
            {
                const Vector2UInt avail = _availableSize(p_containerSize, showV, showH, p_scrollbarThickness);
 
                const bool needV = (p_contentSize.y > avail.y);
                const bool needH = (p_contentSize.x > avail.x);
 
                dirty = (needV != showV) || (needH != showH);
                showV = needV;
                showH = needH;
            }
 
            return {showV, showH};
        }
 
        ScrollLayout _computeLayout() const
        {
            ScrollLayout out;
 
            const Extend2D g = geometry();
            const Vector2UInt containerSize = g.size;
            const Vector2UInt::value_type thickness = scrollBarWidth();
 
            out.contentSize = _resolveContentSize(
                _content.sizeHint().minimal(),
                _content.sizeHint().desired(),
                _content.sizeHint().maximal());
 
            std::tie(out.showV, out.showH) = _resolveVisibility(containerSize, out.contentSize, thickness);
            out.viewportSize = _availableSize(containerSize, out.showV, out.showH, thickness);
 
            if (out.showV)
            {
                out.vBar = Extend2D{
                    {static_cast<int>(containerSize.x) - static_cast<int>(thickness), 0},
                    {thickness, _subtractOrZero(containerSize.y, out.showH ? thickness : 0)}};
            }
 
            if (out.showH)
            {
                out.hBar = Extend2D{
                    {0, static_cast<int>(containerSize.y) - static_cast<int>(thickness)},
                    {_subtractOrZero(containerSize.x, out.showV ? thickness : 0), thickness}};
            }
 
            out.hThumbRatio = (out.contentSize.x == 0) ? 1.0f : std::clamp(static_cast<float>(out.viewportSize.x) / static_cast<float>(out.contentSize.x), 0.0f, 1.0f);
 
            out.vThumbRatio = (out.contentSize.y == 0) ? 1.0f : std::clamp(static_cast<float>(out.viewportSize.y) / static_cast<float>(out.contentSize.y), 0.0f, 1.0f);
 
            const float hRatio = out.showH ? _horizontalScrollBar.slider().ratioValue() : 0.0f;
            const float vRatio = out.showV ? _verticalScrollBar.slider().ratioValue() : 0.0f;
 
            const float hRange = (out.contentSize.x > out.viewportSize.x) ? float(out.contentSize.x - out.viewportSize.x) : 0.0f;
            const float vRange = (out.contentSize.y > out.viewportSize.y) ? float(out.contentSize.y - out.viewportSize.y) : 0.0f;
 
            const int32_t hOffset = static_cast<int32_t>(std::lround(hRange * hRatio));
            const int32_t vOffset = static_cast<int32_t>(std::lround(vRange * vRatio));
 
            out.contentAnchor = spk::Vector2Int::Zero;
            out.contentAnchor.x -= hOffset;
            out.contentAnchor.y -= vOffset;
 
            return (out);
        }
 
        void _applyLayout(const ScrollLayout &p_layout)
        {
            _lastViewportSize = p_layout.viewportSize;
 
            _contentContainer.setGeometry({{0, 0}, p_layout.viewportSize});
 
            _horizontalScrollBar.slider().setThumbSizeRatio(p_layout.hThumbRatio);
            _verticalScrollBar.slider().setThumbSizeRatio(p_layout.vThumbRatio);
 
            if (p_layout.showV)
            {
                _verticalScrollBar.setGeometry(p_layout.vBar);
                _verticalScrollBar.activate();
            }
            else
            {
                auto block = _verticalScrollBar.slider().ratio().onEdition().block();
                _verticalScrollBar.slider().setRatio(0.0f);
                _verticalScrollBar.deactivate();
            }
 
            if (p_layout.showH)
            {
                _horizontalScrollBar.setGeometry(p_layout.hBar);
                _horizontalScrollBar.activate();
            }
            else
            {
                auto block = _horizontalScrollBar.slider().ratio().onEdition().block();
                _horizontalScrollBar.slider().setRatio(0.0f);
                _horizontalScrollBar.deactivate();
            }
 
            _content.setGeometry({p_layout.contentAnchor, p_layout.contentSize});
        }
 
    protected:
        void _onGeometryChange() override
        {
            _applyLayout(_computeLayout());
        }

        void _onMouseWheelEvent(MouseWheelEvent &p_event) override
        {
            const ScrollLayout layout = _computeLayout();
            if (layout.showV == false || layout.viewportSize.y == 0)
            {
                return;
            }
 
            const float contentHeight = static_cast<float>(layout.contentSize.y);
            const float viewportHeight = static_cast<float>(layout.viewportSize.y);
            const float verticalRange = contentHeight > viewportHeight ? contentHeight - viewportHeight : 0.0f;
            if (verticalRange <= 0.0f)
            {
                return;
            }
 
            constexpr float ScrollFactor = 0.25f;
            const float scrollPixels = std::max(1.0f, viewportHeight * ScrollFactor);
            const float ratioDelta = -p_event.wheel * (scrollPixels / verticalRange);
            if (ratioDelta == 0.0f)
            {
                return;
            }
 
            _verticalScrollBar.slider().adjustRatio(ratioDelta);
            p_event.isConsumed = true;
        }
 
    public:
        template <typename... TContentArguments>
        ScrolableArea(const std::wstring &p_name, Widget *p_parent, TContentArguments &&...p_contentArgs) :
            Widget(p_name, p_parent),
            _contentContainer(p_name + L"/ScrolableArea_ContentContainer", this),
            _horizontalScrollBar(p_name + L"/ScrolableArea_HorizontalScrollBar", this),
            _verticalScrollBar(p_name + L"/ScrolableArea_VerticalScrollBar", this),
            _content(p_name + L"/ScrolableArea_ContentContainer/Content", &_contentContainer, std::forward<TContentArguments>(p_contentArgs)...)
        {
            _horizontalScrollBar.setMinimalWidth(32);
            _verticalScrollBar.setMinimalWidth(32);
 
            _contentContainer.setLayer(0);
            _contentContainer.activate();
            _content.setLayer(0);
            _content.activate();
 
            _horizontalScrollBar.setOrientation(Orientation::Horizontal);
            _horizontalScrollBar.setButtonVisibility(Enablement::Disable);
 
            _verticalScrollBar.setOrientation(Orientation::Vertical);
            _verticalScrollBar.setButtonVisibility(Enablement::Disable);
 
            sizeHint().configureMinimalGenerator([this]() {
                const Vector2UInt viewport = _content.sizeHint().minimal();
                const Vector2UInt extent = _resolveContentSize(
                    _content.sizeHint().minimal(),
                    _content.sizeHint().desired(),
                    _content.sizeHint().maximal());
                const Vector2UInt::value_type thickness = scrollBarWidth();
 
                bool showV = false;
                bool showH = false;
                std::tie(showV, showH) = _resolveVisibility(viewport, extent, thickness);
 
                Vector2UInt result = viewport;
                if (showV == true)
                {
                    result.x += thickness;
                }
                if (showH == true)
                {
                    result.y += thickness;
                }
                return (result);
            });
 
            sizeHint().configureMaximalGenerator([this]() {
                return _resolveContentSize(
                    _content.sizeHint().minimal(),
                    _content.sizeHint().desired(),
                    _content.sizeHint().maximal());
            });
 
            _horizontalRatioContract = _horizontalScrollBar.slider().ratio().onEdition().subscribe([this]() {
                requireGeometryChange();
            });
            _verticalRatioContract = _verticalScrollBar.slider().ratio().onEdition().subscribe([this]() {
                requireGeometryChange();
            });
 
            activate();
        }

        void setScrollBarWidth(const size_t p_scrollBarWidth)
        {
            _verticalScrollBar.setMinimalWidth(p_scrollBarWidth);
            _horizontalScrollBar.setMinimalWidth(p_scrollBarWidth);
            sizeHint().release();
        }

        size_t scrollBarWidth() const
        {
            return (std::max(_verticalScrollBar.minimalWidth(), _horizontalScrollBar.minimalWidth()));
        }

        TContent &content()
        {
            return (_content);
        }

        const TContent &content() const
        {
            return (_content);
        }
    };
}