spk_linear_layout.hpp

#pragma once
 
#include <algorithm>
#include <cstdint>
#include <limits>
#include <set>
#include <type_traits>
#include <vector>
 
#include "structure/widget/spk_layout.hpp"
#include "type/spk_orientation.hpp"
#include "type/spk_text_aligmnent.hpp"
 
namespace spk
{
    template <Orientation TOrientation>
    class LinearLayout : public Layout
    {
    private:
        spk::HorizontalAlignment _horizontalAlignment = spk::HorizontalAlignment::Centered;
        spk::VerticalAlignment _verticalAlignment = spk::VerticalAlignment::Centered;
 
        void _setupSizeHint()
        {
            sizeHint().configureMinimalGenerator([&]() {
                return (_computeMinimalSize());
            });
            sizeHint().configureDesiredGenerator([&]() {
                return (_computeMinimalSize());
            });
        }
 
        template <typename THorizontal, typename TVertical, typename... TArgs>
        auto _executeOrientationDefined(THorizontal &&p_horizontalFunction, TVertical &&p_verticalFunction, TArgs &&...p_args) const
            -> decltype(auto)
        {
            if constexpr (TOrientation == Orientation::Horizontal)
            {
                return std::forward<THorizontal>(p_horizontalFunction)(
                    std::forward<TArgs>(p_args)...);
            }
            else
            {
                return std::forward<TVertical>(p_verticalFunction)(
                    std::forward<TArgs>(p_args)...);
            }
        }
 
        spk::Vector2UInt _baseElementSize(const Element &p_element) const
        {
            const spk::Vector2UInt &desired = p_element.element->sizeHint().desired();
            const spk::Vector2UInt &minimal = p_element.element->sizeHint().minimal();
 
            return (spk::Vector2UInt{
                (p_element.sizePolicy.horizontal == SizePolicy::Desired ? desired.x : minimal.x),
                (p_element.sizePolicy.vertical == SizePolicy::Desired ? desired.y : minimal.y)});
        }
 
        spk::Vector2UInt _computeMinimalSize() const
        {
            spk::Vector2UInt result = _elements().empty() ? spk::Vector2UInt{0, 0} : padding() * (_elements().size() - 1);
 
            for (size_t i = 0; i < _elements().size(); i++)
            {
                const spk::Vector2UInt &tmpSize = _baseElementSize(_elements()[i]);
 
                switch (TOrientation)
                {
                case Orientation::Vertical:
                    result.x = std::max(result.x, tmpSize.x);
                    result.y += tmpSize.y;
                    break;
                case Orientation::Horizontal:
                    result.y = std::max(result.y, tmpSize.y);
                    result.x += tmpSize.x;
                    break;
                }
            }
 
            return result;
        }
 
        static constexpr bool _isVertical()
        {
            return TOrientation == Orientation::Vertical;
        }
 
        std::int64_t _crossAxisOffset(const std::int64_t &p_difference) const
        {
            return _executeOrientationDefined(
                [&]() -> std::int64_t {
                    switch (_verticalAlignment)
                    {
                    case spk::VerticalAlignment::Top:
                        return 0;
                    case spk::VerticalAlignment::Down:
                        return p_difference;
                    case spk::VerticalAlignment::Centered:
                    default:
                        return p_difference / 2;
                    }
                },
                [&]() -> std::int64_t {
                    switch (_horizontalAlignment)
                    {
                    case spk::HorizontalAlignment::Left:
                        return 0;
                    case spk::HorizontalAlignment::Right:
                        return p_difference;
                    case spk::HorizontalAlignment::Centered:
                    default:
                        return p_difference / 2;
                    }
                });
        }
 
        static SizePolicy::Value _secondaryAxisPolicy(const SizePolicy::Value &p_mainPolicy)
        {
            switch (p_mainPolicy)
            {
            case SizePolicy::Desired:
            case SizePolicy::Minimum:
                return (p_mainPolicy);
            default:
                return (SizePolicy::Extend);
            }
        }
 
        using Layout::addElement;
        using Layout::setPadding;
 
        std::vector<Element> _pullElementOnPriority(const SizePolicy::Value &p_value)
        {
            std::vector<Element> result;
 
            for (const auto &element : _elements())
            {
                if (_executeOrientationDefined(
                        [&](const Element &p_e) -> bool {
                            return (p_e.sizePolicy.horizontal == p_value);
                        },
                        [&](const Element &p_e) -> bool {
                            return (p_e.sizePolicy.vertical == p_value);
                        },
                        element) == true)
                {
                    result.push_back(element);
                }
            }
 
            return (result);
        }
 
        spk::Vector2UInt _getSpaceToAssign(const spk::Extend2D &p_extend)
        {
            spk::Vector2UInt result = p_extend.size - sizeHint().minimal();
 
            _executeOrientationDefined(
                [&]() {
                    result.y = 0;
                },
                [&]() {
                    result.x = 0;
                });
 
            return (result);
        }
 
        using MainAxisViewRegionSize = std::vector<size_t>;
        using SecondaryAxisViewRegionSize = std::vector<size_t>;
 
        size_t _computeSizeToAssign(const spk::Extend2D &p_extend, MainAxisViewRegionSize &p_mainAxisViewRegionSize)
        {
            size_t result = _executeOrientationDefined(
                [&]() {
                    return (p_extend.size.x);
                },
                [&]() {
                    return (p_extend.size.y);
                });
 
            if (p_mainAxisViewRegionSize.empty() == false)
            {
                result -= (p_mainAxisViewRegionSize.size() - 1) * _executeOrientationDefined(
                                                                      [&]() {
                                                                          return (padding().x);
                                                                      },
                                                                      [&]() {
                                                                          return (padding().y);
                                                                      });
            }
 
            for (const auto &size : p_mainAxisViewRegionSize)
            {
                if (result <= size)
                {
                    return (0);
                }
                else
                {
                    result -= size;
                }
            }
 
            return (result);
        }
 
        using ElementIndexVector = std::vector<size_t>;
 
        ElementIndexVector _getElementWithSizePolicy(const SizePolicy::Value &p_value)
        {
            ElementIndexVector result;
 
            for (size_t i = 0; i < _elements().size(); i++)
            {
                if (_executeOrientationDefined(
                        [&](const Element &p_e) {
                            return p_e.sizePolicy.horizontal == p_value;
                        },
                        [&](const Element &p_e) {
                            return p_e.sizePolicy.vertical == p_value;
                        },
                        _elements()[i]) == true)
                {
                    result.push_back(i);
                }
            }
 
            return (result);
        }
 
        size_t _updateViewRegionSize(const size_t &p_spaceToAssign, MainAxisViewRegionSize &p_mainAxisViewRegionSize, const SizePolicy::Value &p_value)
        {
            size_t sizeLeft = p_spaceToAssign;
            ElementIndexVector targetElements = _getElementWithSizePolicy(p_value);
 
            if (targetElements.empty())
            {
                return (sizeLeft);
            }
 
            for (size_t i = 0; i < targetElements.size(); i++)
            {
                size_t index = targetElements[i];
                size_t currentSize = p_mainAxisViewRegionSize[index];
            }
 
            size_t sizeToAdd = sizeLeft / targetElements.size();
 
            for (size_t i = 0; i < targetElements.size();)
            {
                size_t index = targetElements[i];
                size_t currentSize = p_mainAxisViewRegionSize[index];
                const Element &tmpElement = _elements()[index];
                size_t elementMaxSize = _executeOrientationDefined(
                    [&](const Element &p_e) -> size_t {
                        return (p_e.element->sizeHint().maximal().x);
                    },
                    [&](const Element &p_e) -> size_t {
                        return (p_e.element->sizeHint().maximal().y);
                    },
                    tmpElement);
 
                if (elementMaxSize <= currentSize + sizeToAdd)
                {
                    p_mainAxisViewRegionSize[targetElements[i]] = elementMaxSize;
                    targetElements.erase(targetElements.begin() + i);
                    i = 0;
                    if (sizeLeft < elementMaxSize)
                    {
                        return 0;
                    }
                    sizeLeft -= (elementMaxSize - currentSize);
                    if (targetElements.empty())
                    {
                        return sizeLeft;
                    }
                    sizeToAdd = sizeLeft / targetElements.size();
                }
                else
                {
                    i++;
                }
            }
 
            for (size_t i = 0; i < targetElements.size(); i++)
            {
                size_t index = targetElements[i];
                size_t currentSize = p_mainAxisViewRegionSize[index];
 
                p_mainAxisViewRegionSize[targetElements[i]] = currentSize + sizeToAdd;
                sizeLeft -= sizeToAdd;
            }
 
            return (sizeLeft);
        }
 
    public:
        LinearLayout()
        {
            _setupSizeHint();
        }
        ~LinearLayout() override = default;

        template <Orientation TLocalOrientation = TOrientation, typename std::enable_if_t<TLocalOrientation == Orientation::Horizontal, int> = 0>
        void setAlignment(spk::VerticalAlignment p_alignment)
        {
            _verticalAlignment = p_alignment;
        }

        template <Orientation TLocalOrientation = TOrientation, typename std::enable_if_t<TLocalOrientation == Orientation::Vertical, int> = 0>
        void setAlignment(spk::HorizontalAlignment p_alignment)
        {
            _horizontalAlignment = p_alignment;
        }

        template <Orientation TLocalOrientation = TOrientation, typename std::enable_if_t<TLocalOrientation == Orientation::Horizontal, int> = 0>
        spk::VerticalAlignment alignment() const
        {
            return (_verticalAlignment);
        }

        template <Orientation TLocalOrientation = TOrientation, typename std::enable_if_t<TLocalOrientation == Orientation::Vertical, int> = 0>
        spk::HorizontalAlignment alignment() const
        {
            return (_horizontalAlignment);
        }

        void setGeometry(const spk::Extend2D &p_geometry) override
        {
            MainAxisViewRegionSize mainAxisViewRegionSize;
            SecondaryAxisViewRegionSize secondaryAxisViewRegionSize;
 
            mainAxisViewRegionSize.resize(_elements().size());
            secondaryAxisViewRegionSize.resize(_elements().size());
 
            for (size_t i = 0; i < _elements().size(); i++)
            {
                spk::Vector2UInt elementMinSize = _baseElementSize(_elements()[i]);
                spk::Vector2UInt elementMaxSize = _elements()[i].element->sizeHint().maximal();
 
                _executeOrientationDefined(
                    [&]() {
                        mainAxisViewRegionSize[i] = elementMinSize.x;
                        const Layout::SizePolicy::Value crossPolicy = _elements()[i].sizePolicy.vertical;
                        secondaryAxisViewRegionSize[i] = std::min(elementMaxSize.y, (crossPolicy == SizePolicy::Desired || crossPolicy == SizePolicy::Minimum ? elementMinSize.y : p_geometry.height));
                    },
                    [&]() {
                        mainAxisViewRegionSize[i] = elementMinSize.y;
                        const Layout::SizePolicy::Value crossPolicy = _elements()[i].sizePolicy.horizontal;
                        secondaryAxisViewRegionSize[i] = std::min(elementMaxSize.x, (crossPolicy == SizePolicy::Desired || crossPolicy == SizePolicy::Minimum ? elementMinSize.x : p_geometry.width));
                    });
            }
 
            size_t sizeToAssign = _computeSizeToAssign(p_geometry, mainAxisViewRegionSize);
 
            sizeToAssign = _updateViewRegionSize(sizeToAssign, mainAxisViewRegionSize, SizePolicy::Extend);
            sizeToAssign = _updateViewRegionSize(sizeToAssign, mainAxisViewRegionSize, SizePolicy::Standard);
 
            const std::int64_t geometryMainAxisSize = _executeOrientationDefined(
                [&]() -> std::int64_t {
                    return (static_cast<std::int64_t>(p_geometry.size.x));
                },
                [&]() -> std::int64_t {
                    return (static_cast<std::int64_t>(p_geometry.size.y));
                });
 
            const std::int64_t geometryCrossAxisSize = _executeOrientationDefined(
                [&]() -> std::int64_t {
                    return (static_cast<std::int64_t>(p_geometry.size.y));
                },
                [&]() -> std::int64_t {
                    return (static_cast<std::int64_t>(p_geometry.size.x));
                });
 
            const std::int64_t clampedCenterOffset = std::clamp<std::int64_t>(
                static_cast<std::int64_t>(0),
                static_cast<std::int64_t>(std::numeric_limits<spk::Vector2Int::value_type>::min()),
                static_cast<std::int64_t>(std::numeric_limits<spk::Vector2Int::value_type>::max()));
 
            spk::Vector2Int anchor = p_geometry.anchor;
            _executeOrientationDefined(
                [&]() {
                    anchor.x += static_cast<spk::Vector2Int::value_type>(clampedCenterOffset);
                },
                [&]() {
                    anchor.y += static_cast<spk::Vector2Int::value_type>(clampedCenterOffset);
                });
            for (size_t i = 0; i < _elements().size(); i++)
            {
                spk::Vector2UInt elementSize = _executeOrientationDefined(
                    [&]() {
                        return (spk::Vector2UInt(mainAxisViewRegionSize[i], secondaryAxisViewRegionSize[i]));
                    },
                    [&]() {
                        return (spk::Vector2UInt(secondaryAxisViewRegionSize[i], mainAxisViewRegionSize[i]));
                    });
 
                spk::Vector2Int elementAnchor = anchor;
                const std::int64_t crossAxisSize = _executeOrientationDefined(
                    [&]() -> std::int64_t {
                        return (static_cast<std::int64_t>(elementSize.y));
                    },
                    [&]() -> std::int64_t {
                        return (static_cast<std::int64_t>(elementSize.x));
                    });
 
                const std::int64_t crossDifference = geometryCrossAxisSize - crossAxisSize;
                const std::int64_t crossAxisOffset = _crossAxisOffset(crossDifference);
                const std::int64_t clampedCrossOffset = std::clamp<std::int64_t>(
                    crossAxisOffset,
                    static_cast<std::int64_t>(std::numeric_limits<spk::Vector2Int::value_type>::min()),
                    static_cast<std::int64_t>(std::numeric_limits<spk::Vector2Int::value_type>::max()));
 
                _executeOrientationDefined(
                    [&]() {
                        elementAnchor.y += static_cast<spk::Vector2Int::value_type>(clampedCrossOffset);
                    },
                    [&]() {
                        elementAnchor.x += static_cast<spk::Vector2Int::value_type>(clampedCrossOffset);
                    });
 
                _elements()[i].element->setGeometry({elementAnchor, elementSize});
 
                _executeOrientationDefined(
                    [&]() {
                        anchor.x += elementSize.x + padding().x;
                    },
                    [&]() {
                        anchor.y += elementSize.y + padding().y;
                    });
            }
        }

        void addElement(ResizableElement *p_object, const SizePolicy::Value &p_sizePolicy)
        {
            const SizePolicy::Value secondaryPolicy = _secondaryAxisPolicy(p_sizePolicy);
            Layout::addElement(p_object, _executeOrientationDefined([&]() -> SizePolicy {
                                   return (SizePolicy{p_sizePolicy, secondaryPolicy});
                               },
                                                                    [&]() -> SizePolicy {
                                                                        return (SizePolicy{secondaryPolicy, p_sizePolicy});
                                                                    }));
        }

        void addElement(ResizableElement *p_object, const SizePolicy &p_sizePolicy)
        {
            Layout::addElement(p_object, p_sizePolicy);
        }

        void setPadding(const uint32_t &p_padding)
        {
            _executeOrientationDefined(
                [&]() {
                    Layout::setPadding({p_padding, 0});
                },
                [&]() {
                    Layout::setPadding({0, p_padding});
                });
        }
    };
 
    using VerticalLayout = LinearLayout<Orientation::Vertical>;
    using HorizontalLayout = LinearLayout<Orientation::Horizontal>;
}