spk_grid_layout.hpp

#pragma once
 
#include <algorithm>
#include <cstddef>
#include <limits>
#include <numeric>
#include <stdexcept>
#include <vector>
 
#include "structure/graphics/spk_extend_2d.hpp"
#include "structure/math/spk_vector2.hpp"
#include "structure/widget/spk_layout.hpp"
 
namespace spk
{
    class GridLayout : public Layout
    {
    private:
        using Layout::addElement;
        using Layout::clear;
 
        spk::Vector2UInt _nbCells = {0, 0};
 
        static const Vector2UInt &_positionOf(const Element &p_e)
        {
            const auto *ptr = std::any_cast<Vector2UInt>(&p_e.extraData);
            if (ptr == nullptr)
            {
                throw std::logic_error("GridLayout element extraData is not a Vector2UInt");
            }
            return *ptr;
        }
 
        void _setupSizeHint()
        {
            sizeHint().configureMinimalGenerator([&]() {
                return (_computeMinimalSize());
            });
            sizeHint().configureDesiredGenerator([&]() {
                return (_computeMinimalSize());
            });
        }
 
        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)});
        }
 
        using AxisSizeContainer = std::vector<spk::Vector2UInt::value_type>;
        struct GridSizeContainer
        {
            std::vector<spk::Vector2UInt::value_type> xAxisSizes;
            std::vector<spk::Vector2UInt::value_type> yAxisSizes;
 
            GridSizeContainer() = default;
            GridSizeContainer(const spk::Vector2UInt &p_gridSize) :
                xAxisSizes(p_gridSize.x, 0),
                yAxisSizes(p_gridSize.y, 0)
            {
            }
        };
 
        struct AxisState
        {
            AxisSizeContainer::value_type size = 0;
            AxisSizeContainer::value_type maximal = std::numeric_limits<AxisSizeContainer::value_type>::max();
            Layout::SizePolicy::Value policy = Layout::SizePolicy::Minimum;
            bool hasElement = false;
            bool hasDesired = false;
        };
 
        static Layout::SizePolicy::Value _strongerPolicy(Layout::SizePolicy::Value p_current, Layout::SizePolicy::Value p_candidate)
        {
            const auto rank = [](Layout::SizePolicy::Value p_value) {
                switch (p_value)
                {
                case Layout::SizePolicy::Extend:
                    return 3;
                case Layout::SizePolicy::Standard:
                    return 2;
                case Layout::SizePolicy::Minimum:
                    return 1;
                default:
                    return 0;
                }
            };
            return (rank(p_candidate) > rank(p_current) ? p_candidate : p_current);
        }
 
        std::vector<size_t> _collectAxisCandidates(const std::vector<AxisState> &p_states, Layout::SizePolicy::Value p_policy) const
        {
            const AxisSizeContainer::value_type axisUnlimited = std::numeric_limits<AxisSizeContainer::value_type>::max();
            std::vector<size_t> candidateIndices;
            candidateIndices.reserve(p_states.size());
 
            for (size_t i = 0; i < p_states.size(); ++i)
            {
                const AxisState &state = p_states[i];
                const bool canGrow = (state.maximal == axisUnlimited || state.size < state.maximal);
 
                if (state.hasElement == true &&
                    state.hasDesired == false &&
                    state.policy == p_policy &&
                    canGrow == true)
                {
                    candidateIndices.push_back(i);
                }
            }
 
            return candidateIndices;
        }
 
        AxisSizeContainer::value_type _consumeAxisShare(AxisSizeContainer::value_type &p_spaceToAssign, const std::vector<size_t> &p_candidateIndices, std::vector<AxisState> &p_states) const
        {
            const AxisSizeContainer::value_type axisUnlimited = std::numeric_limits<AxisSizeContainer::value_type>::max();
            AxisSizeContainer::value_type share = p_spaceToAssign / p_candidateIndices.size();
            if (share == 0)
            {
                share = 1;
            }
 
            AxisSizeContainer::value_type consumed = 0;
            for (size_t index : p_candidateIndices)
            {
                if (p_spaceToAssign == 0)
                {
                    break;
                }
 
                AxisState &state = p_states[index];
                AxisSizeContainer::value_type available = axisUnlimited;
 
                if (state.maximal != axisUnlimited)
                {
                    if (state.size >= state.maximal)
                    {
                        continue;
                    }
                    available = state.maximal - state.size;
                }
 
                if (available == 0)
                {
                    continue;
                }
 
                AxisSizeContainer::value_type increment = std::min(share, available);
                increment = std::min(increment, p_spaceToAssign);
 
                state.size += increment;
                p_spaceToAssign -= increment;
                consumed += increment;
            }
 
            return consumed;
        }
 
        void _updateAxisState(AxisState &p_state, AxisSizeContainer::value_type p_baseSize, AxisSizeContainer::value_type p_maximalSize, Layout::SizePolicy::Value p_value)
        {
            p_state.hasElement = true;
            p_state.size = std::max(p_state.size, p_baseSize);
            p_state.maximal = std::min(p_state.maximal, p_maximalSize);
 
            if (p_value == Layout::SizePolicy::Desired)
            {
                p_state.hasDesired = true;
                p_state.maximal = std::min(p_state.maximal, p_baseSize);
                return;
            }
 
            p_state.policy = _strongerPolicy(p_state.policy, p_value);
        }
 
        void _assignSpaceToAxis(AxisSizeContainer::value_type &p_spaceToAssign, std::vector<AxisState> &p_states, Layout::SizePolicy::Value p_policy) const
        {
            if (p_spaceToAssign == 0)
            {
                return;
            }
 
            while (p_spaceToAssign > 0)
            {
                std::vector<size_t> candidateIndices = _collectAxisCandidates(p_states, p_policy);
                if (candidateIndices.empty())
                {
                    break;
                }
 
                AxisSizeContainer::value_type consumed = _consumeAxisShare(p_spaceToAssign, candidateIndices, p_states);
                if (consumed == 0)
                {
                    break;
                }
            }
        }
 
        GridSizeContainer _computeGridBaseSize() const
        {
            GridSizeContainer result(_nbCells);
 
            for (size_t i = 0; i < _elements().size(); i++)
            {
                const Element &element = _elements()[i];
                const spk::Vector2UInt &elementPosition = _positionOf(element);
                spk::Vector2UInt elementSize = _baseElementSize(element);
 
                result.xAxisSizes[elementPosition.x] = std::max(result.xAxisSizes[elementPosition.x], elementSize.x);
                result.yAxisSizes[elementPosition.y] = std::max(result.yAxisSizes[elementPosition.y], elementSize.y);
            }
 
            return (result);
        }
 
        spk::Vector2UInt _computeTotalGridSize(const GridSizeContainer &p_rawGridSize) const
        {
            using AxisValue = AxisSizeContainer::value_type;
 
            const auto accumulateAxis = [&](const AxisSizeContainer &p_axisSizes, const AxisValue p_padding) {
                const AxisValue totalSize = std::accumulate(p_axisSizes.begin(), p_axisSizes.end(), AxisValue{0});
                if (p_axisSizes.empty() == true)
                {
                    return totalSize;
                }
 
                const AxisValue paddingCount = static_cast<AxisValue>(static_cast<size_t>(p_axisSizes.size() - 1) * static_cast<size_t>(p_padding));
                return (totalSize + paddingCount);
            };
 
            const AxisValue xSize = accumulateAxis(p_rawGridSize.xAxisSizes, padding().x);
            const AxisValue ySize = accumulateAxis(p_rawGridSize.yAxisSizes, padding().y);
 
            return (spk::Vector2UInt{xSize, ySize});
        }
 
        spk::Vector2UInt _computeMinimalSize() const
        {
            return (_computeTotalGridSize(_computeGridBaseSize()));
        }
 
    public:
        GridLayout()
        {
            _setupSizeHint();
        }

        void addElement(const Vector2UInt &p_position, ResizableElement *p_element, const SizePolicy &p_sizePolicy)
        {
            _nbCells = spk::Vector2UInt::max(_nbCells, p_position + 1);
            Layout::addElement(p_element, p_sizePolicy, p_position);
        }

        void clear()
        {
            _nbCells = {0, 0};
            Layout::clear();
        }

        void setGeometry(const Extend2D &p_extend) override
        {
            const GridSizeContainer baseGridSize = _computeGridBaseSize();
            spk::Vector2UInt spaceUsed = _computeTotalGridSize(baseGridSize);
 
            spk::Vector2UInt spaceLeft{
                p_extend.size.x <= spaceUsed.x ? 0 : (p_extend.size.x - spaceUsed.x),
                p_extend.size.y <= spaceUsed.y ? 0 : (p_extend.size.y - spaceUsed.y)};
 
            std::vector<AxisState> xAxisStates(_nbCells.x);
            std::vector<AxisState> yAxisStates(_nbCells.y);
 
            for (size_t i = 0; i < xAxisStates.size(); ++i)
            {
                xAxisStates[i].size = baseGridSize.xAxisSizes[i];
            }
            for (size_t i = 0; i < yAxisStates.size(); ++i)
            {
                yAxisStates[i].size = baseGridSize.yAxisSizes[i];
            }
 
            for (const Element &element : _elements())
            {
                const spk::Vector2UInt position = _positionOf(element);
                const spk::Vector2UInt elementBase = _baseElementSize(element);
                const spk::Vector2UInt elementMaximal = element.element->sizeHint().maximal();
 
                if (position.x < xAxisStates.size())
                {
                    _updateAxisState(xAxisStates[position.x], elementBase.x, elementMaximal.x, element.sizePolicy.horizontal);
                }
                if (position.y < yAxisStates.size())
                {
                    _updateAxisState(yAxisStates[position.y], elementBase.y, elementMaximal.y, element.sizePolicy.vertical);
                }
            }
 
            _assignSpaceToAxis(spaceLeft.x, xAxisStates, SizePolicy::Extend);
            _assignSpaceToAxis(spaceLeft.x, xAxisStates, SizePolicy::Standard);
 
            _assignSpaceToAxis(spaceLeft.y, yAxisStates, SizePolicy::Extend);
            _assignSpaceToAxis(spaceLeft.y, yAxisStates, SizePolicy::Standard);
 
            std::vector<spk::Vector2Int::value_type> xAnchors(_nbCells.x);
            std::vector<spk::Vector2Int::value_type> yAnchors(_nbCells.y);
 
            spk::Vector2Int::value_type currentX = p_extend.anchor.x;
            for (size_t i = 0; i < _nbCells.x; ++i)
            {
                xAnchors[i] = currentX;
                currentX += static_cast<spk::Vector2Int::value_type>(xAxisStates[i].size);
                if (i + 1 < _nbCells.x)
                {
                    currentX += static_cast<spk::Vector2Int::value_type>(padding().x);
                }
            }
 
            spk::Vector2Int::value_type currentY = p_extend.anchor.y;
            for (size_t i = 0; i < _nbCells.y; ++i)
            {
                yAnchors[i] = currentY;
                currentY += static_cast<spk::Vector2Int::value_type>(yAxisStates[i].size);
                if (i + 1 < _nbCells.y)
                {
                    currentY += static_cast<spk::Vector2Int::value_type>(padding().y);
                }
            }
 
            for (const Element &element : _elements())
            {
                const spk::Vector2UInt position = _positionOf(element);
                if (position.x >= xAxisStates.size() || position.y >= yAxisStates.size())
                {
                    continue;
                }
 
                spk::Vector2UInt elementSize{
                    xAxisStates[position.x].size,
                    yAxisStates[position.y].size};
 
                const spk::Vector2UInt elementBase = _baseElementSize(element);
                if (element.sizePolicy.horizontal == SizePolicy::Minimum)
                {
                    elementSize.x = elementBase.x;
                }
 
                if (element.sizePolicy.vertical == SizePolicy::Minimum)
                {
                    elementSize.y = elementBase.y;
                }
 
                element.element->setGeometry({{xAnchors[position.x], yAnchors[position.y]}, elementSize});
            }
        }
    };
}