row_column_widget.hpp

Go to the documentation of this file.

// Copyright Take Vos 2020.
// 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 "widget.hpp"
#include "row_column_delegate.hpp"
#include "grid_layout.hpp"
#include "../GUI/theme.hpp"
#include "../geometry/axis.hpp"
#include <memory>
 
namespace hi::inline v1 {
 
template<axis Axis>
class row_column_widget final : public widget {
public:
    static_assert(Axis == axis::horizontal or Axis == axis::vertical);
 
    using super = widget;
    using delegate_type = row_column_delegate<Axis>;
    static constexpr hi::axis axis = Axis;
 
    ~row_column_widget()
    {
        if (auto delegate = _delegate.lock()) {
            delegate->deinit(*this);
        }
    }
 
    row_column_widget(gui_window& window, widget *parent, std::weak_ptr<delegate_type> delegate = {}) noexcept :
        super(window, parent), _delegate(std::move(delegate))
    {
        hi_axiom(is_gui_thread());
 
        if (parent) {
            semantic_layer = parent->semantic_layer;
        }
        if (auto d = _delegate.lock()) {
            d->init(*this);
        }
    }
 
    template<typename Widget, typename... Args>
    Widget& make_widget(Args&&...args)
    {
        auto tmp = std::make_unique<Widget>(window, this, std::forward<Args>(args)...);
        auto& ref = *tmp;
        _children.push_back(std::move(tmp));
        request_reconstrain();
        return ref;
    }
 
    void clear() noexcept
    {
        hi_axiom(is_gui_thread());
        _children.clear();
        request_reconstrain();
    }
 
    [[nodiscard]] generator<widget *> children() const noexcept override
    {
        for (hilet& child : _children) {
            co_yield child.get();
        }
    }
 
    widget_constraints const& set_constraints() noexcept override
    {
        _layout = {};
 
        ssize_t index = 0;
 
        auto minimum_thickness = 0.0f;
        auto preferred_thickness = 0.0f;
        auto maximum_thickness = 0.0f;
        float margin_before_thickness = 0.0f;
        float margin_after_thickness = 0.0f;
        widget_baseline baseline = {};
 
        _grid_layout.clear();
        for (hilet& child : _children) {
            update_constraints_for_child(
                *child,
                index++,
                minimum_thickness,
                preferred_thickness,
                maximum_thickness,
                margin_before_thickness,
                margin_after_thickness,
                baseline);
        }
        _grid_layout.commit_constraints();
 
        hi_axiom(index == ssize(_children));
 
        if constexpr (axis == axis::row) {
            return _constraints = {
                       {_grid_layout.minimum(), minimum_thickness},
                       {_grid_layout.preferred(), preferred_thickness},
                       {_grid_layout.maximum(), maximum_thickness},
                       {_grid_layout.margin_before(),
                        margin_before_thickness,
                        _grid_layout.margin_after(),
                        margin_after_thickness},
                       baseline};
        } else {
            return _constraints = {
                       {minimum_thickness, _grid_layout.minimum()},
                       {preferred_thickness, _grid_layout.preferred()},
                       {maximum_thickness, _grid_layout.maximum()},
                       {margin_before_thickness,
                        _grid_layout.margin_before(),
                        margin_after_thickness,
                        _grid_layout.margin_after()}};
        }
    }
 
    void set_layout(widget_layout const& layout) noexcept override
    {
        if (compare_store(_layout, layout)) {
            _grid_layout.layout(axis == axis::row ? layout.width() : layout.height());
        }
 
        ssize_t index = 0;
        for (hilet& child : _children) {
            update_layout_for_child(*child, index++, layout);
        }
 
        hi_axiom(index == ssize(_children));
    }
 
    void draw(draw_context const& context) noexcept override
    {
        if (*mode > widget_mode::invisible) {
            for (hilet& child : _children) {
                child->draw(context);
            }
        }
    }
 
    hitbox hitbox_test(point3 position) const noexcept override
    {
        hi_axiom(is_gui_thread());
 
        if (*mode >= widget_mode::partial) {
            auto r = hitbox{};
            for (hilet& child : _children) {
                r = child->hitbox_test_from_parent(position, r);
            }
            return r;
        } else {
            return {};
        }
    }
private:
    std::vector<std::unique_ptr<widget>> _children;
    std::weak_ptr<delegate_type> _delegate;
    grid_layout _grid_layout;
 
    void update_constraints_for_child(
        widget& child,
        ssize_t index,
        float& minimum_thickness,
        float& preferred_thickness,
        float& maximum_thickness,
        float& margin_before_thickness,
        float& margin_after_thickness,
        widget_baseline& baseline) noexcept
    {
        hi_axiom(is_gui_thread());
 
        hilet& child_constraints = child.set_constraints();
        if (axis == axis::row) {
            _grid_layout.add_constraint(
                index,
                child_constraints.minimum.width(),
                child_constraints.preferred.width(),
                child_constraints.maximum.width(),
                child_constraints.margins.left(),
                child_constraints.margins.right());
 
            inplace_max(minimum_thickness, child_constraints.minimum.height());
            inplace_max(preferred_thickness, child_constraints.preferred.height());
            inplace_max(maximum_thickness, child_constraints.maximum.height());
            inplace_max(margin_before_thickness, child_constraints.margins.top());
            inplace_max(margin_after_thickness, child_constraints.margins.bottom());
            inplace_max(baseline, child_constraints.baseline);
 
        } else {
            _grid_layout.add_constraint(
                index,
                child_constraints.minimum.height(),
                child_constraints.preferred.height(),
                child_constraints.maximum.height(),
                child_constraints.margins.top(),
                child_constraints.margins.bottom(),
                child_constraints.baseline);
 
            inplace_max(minimum_thickness, child_constraints.minimum.width());
            inplace_max(preferred_thickness, child_constraints.preferred.width());
            inplace_max(maximum_thickness, child_constraints.maximum.width());
            inplace_max(margin_before_thickness, child_constraints.margins.left());
            inplace_max(margin_after_thickness, child_constraints.margins.right());
        }
    }
 
    void update_layout_for_child(widget& child, ssize_t index, widget_layout const& context) const noexcept
    {
        hi_axiom(is_gui_thread());
 
        hilet[child_position, child_length] = _grid_layout.get_position_and_size(index);
 
        if (axis == axis::row) {
            hilet child_rectangle = aarectangle{child_position, 0.0f, child_length, layout().height()};
            // The baseline for a row widget is inherited from the context received from the parent.
            child.set_layout(context.transform(child_rectangle, 0.0f));
 
        } else {
            hilet child_rectangle =
                aarectangle{0.0f, layout().height() - child_position - child_length, layout().width(), child_length};
            child.set_layout(context.transform(child_rectangle, 0.0f, _grid_layout.get_baseline(index)));
        }
    }
};
 
using row_widget = row_column_widget<axis::row>;
 
using column_widget = row_column_widget<axis::column>;
 
} // namespace hi::inline v1