grid_layout.hpp

// Copyright Take Vos 2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "../required.hpp"
#include "../assert.hpp"
#include "../math.hpp"
#include <tuple>
#include <vector>
#include <cstddef>
#include <functional>
 
namespace hi::inline v1 {
 
class grid_layout {
public:
    grid_layout(grid_layout const &) = delete;
    grid_layout(grid_layout &&) = delete;
    grid_layout &operator=(grid_layout const &) = delete;
    grid_layout &operator=(grid_layout &&) = delete;
 
    grid_layout() noexcept {}
 
    void clear() noexcept
    {
        _num_cells = 0;
        _constraints.clear();
        _cells.clear();
    }
 
    void add_constraint(std::size_t first, std::size_t last, float minimum, float preferred, float maximum, float margin_before, float margin_after) noexcept
    {
        _num_cells = std::max(_num_cells, last);
        _constraints.emplace_back(first, last, minimum, preferred, maximum, margin_before, margin_after);
    }
 
    void add_constraint(std::size_t index, float minimum, float preferred, float maximum, float margin_before, float margin_after) noexcept
    {
        return add_constraint(index, index + 1, minimum, preferred, maximum, margin_before, margin_after);
    }
 
    void commit_constraints() noexcept;
 
    [[nodiscard]] std::size_t num_cells() const noexcept
    {
        return _num_cells;
    }
 
    [[nodiscard]] float minimum() const noexcept
    {
        return _minimum;
    }
 
    [[nodiscard]] float preferred() const noexcept
    {
        return _preferred;
    }
 
    [[nodiscard]] float maximum() const noexcept
    {
        return _maximum;
    }
 
    [[nodiscard]] float margin_before() const noexcept
    {
        return _cells.front().margin;
    }
 
    [[nodiscard]] float margin_after() const noexcept
    {
        return _cells.back().margin;
    }
 
    void layout(float size) noexcept;
 
    [[nodiscard]] float get_position(std::size_t index) const noexcept
    {
        hi_axiom(index < num_cells());
        return get_position(_cells.begin(), _cells.begin() + index);
    }
 
    [[nodiscard]] float get_size(std::size_t first, std::size_t last) const noexcept
    {
        hi_axiom(first <= last);
        hi_axiom(last <= _cells.size());
        return get_size(_cells.begin() + first, _cells.begin() + last);
    }
 
    [[nodiscard]] float get_size(std::size_t index) const noexcept
    {
        return get_size(index, index + 1);
    }
 
    std::pair<float, float> get_position_and_size(std::size_t first, std::size_t last) const noexcept
    {
        return {get_position(first), get_size(first, last)};
    }
 
    std::pair<float, float> get_position_and_size(std::size_t index) const noexcept
    {
        return get_position_and_size(index, index + 1);
    }
 
    std::pair<float, float> get_positions(std::size_t first, std::size_t last) const noexcept
    {
        hilet position = get_position(first);
        hilet size = get_size(first, last);
        return {position, position + size};
    }
 
    std::pair<float, float> get_positions(std::size_t index) const noexcept
    {
        return get_positions(index, index + 1);
    }
 
private:
    struct constraint_type {
        std::size_t first;
        std::size_t last;
        float minimum;
        float preferred;
        float maximum;
        float margin_before;
        float margin_after;
 
        [[nodiscard]] bool is_single_cell() const noexcept
        {
            return first == last - 1;
        }
 
        [[nodiscard]] bool is_span() const noexcept
        {
            return not is_single_cell();
        }
    };
 
    struct cell_type {
        float size;
 
        float margin;
 
        float minimum;
 
        float preferred;
 
        float maximum;
 
        cell_type() noexcept :
            size(0.0f), margin(0.0f), minimum(0.0f), preferred(0.0f), maximum(std::numeric_limits<float>::infinity())
        {
        }
 
        void fix_constraint() noexcept
        {
            inplace_max(maximum, minimum);
            inplace_clamp(preferred, minimum, maximum);
        }
 
        void set_constraint(constraint_type const &constraint) noexcept
        {
            inplace_max(minimum, constraint.minimum);
            inplace_max(preferred, constraint.preferred);
            inplace_min(maximum, constraint.maximum);
        }
 
        [[nodiscard]] bool holds_invariant() const noexcept
        {
            return minimum <= preferred and preferred <= maximum;
        }
    };
 
    using contraint_vector_type = std::vector<constraint_type>;
    using cell_vector_type = std::vector<cell_type>;
    using cell_iterator = cell_vector_type::iterator;
    using cell_const_iterator = cell_vector_type::const_iterator;
 
    std::size_t _num_cells = 0;
    float _minimum = 0.0f;
    float _preferred = 0.0f;
    float _maximum = 0.0f;
    contraint_vector_type _constraints;
    cell_vector_type _cells;
 
    [[nodiscard]] float get_position(cell_const_iterator begin, cell_const_iterator first) const noexcept
    {
        auto it = begin;
        auto position = 0.0f;
        while (it != first) {
            position += it->size;
            ++it;
            position += it->margin;
        }
        return position;
    }
 
    [[nodiscard]] static float get_size(cell_const_iterator first, cell_const_iterator last) noexcept
    {
        if (first == last) {
            return 0.0f;
        }
 
        auto it = first;
        auto size = it->size;
        ++it;
        for (; it != last; ++it) {
            size += it->margin;
            size += it->size;
        }
        return size;
    }
 
    void constrain_cells_by_singles() noexcept;
    void constrain_cells_by_spans(std::function<float(constraint_type const &)> const &predicate) noexcept;
    [[nodiscard]] bool holds_invariant() const noexcept;
};
 
} // namespace hi::inline v1