row_column_widget.hpp

Go to the documentation of this file.

// Copyright Take Vos 2020-2022.
// 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 "../GUI/module.hpp"
#include "../geometry/module.hpp"
#include "../layout/row_column_layout.hpp"
#include <memory>
#include <type_traits>
 
namespace hi { inline namespace v1 {
 
template<fixed_string Prefix, axis Axis>
class row_column_widget final : public widget {
public:
    static_assert(Axis == axis::horizontal or Axis == axis::vertical);
 
    using super = widget;
    constexpr static hi::axis axis = Axis;
    constexpr static auto prefix = Prefix;
 
    ~row_column_widget() {}
 
    row_column_widget(widget *parent) noexcept : super(parent)
    {
        hi_axiom(loop::main().on_thread());
 
        if (parent) {
            semantic_layer = parent->semantic_layer;
        }
    }
 
    template<typename Widget, typename... Args>
    Widget& make_widget(Args&&...args)
    {
        auto tmp = std::make_unique<Widget>(this, std::forward<Args>(args)...);
        auto& ref = *tmp;
        _children.push_back(std::move(tmp));
 
        ++global_counter<"row_column_widget:make_widget:constrain">;
        process_event({gui_event_type::window_reconstrain});
        return ref;
    }
 
    void clear() noexcept
    {
        hi_axiom(loop::main().on_thread());
        _children.clear();
        ++global_counter<"row_column_widget:clear:constrain">;
        process_event({gui_event_type::window_reconstrain});
    }
 
    [[nodiscard]] generator<widget const&> children(bool include_invisible) const noexcept override
    {
        for (hilet& child : _children) {
            co_yield *child.value;
        }
    }
 
    [[nodiscard]] box_constraints update_constraints() noexcept override
    {
        for (auto& child : _children) {
            child.set_constraints(child.value->update_constraints());
        }
 
        return _children.constraints(os_settings::left_to_right());
    }
 
    void set_layout(widget_layout const& context) noexcept override
    {
        if (compare_store(layout, context)) {
            _children.set_layout(context.shape, theme<prefix>.cap_height(this));
 
            for (hilet& child : _children) {
                child.value->set_layout(context.transform(child.shape, 0.0f));
            }
        }
    }
 
    void draw(widget_draw_context& context) noexcept override
    {
        if (*mode > widget_mode::invisible) {
            for (hilet& child : _children) {
                child.value->draw(context);
            }
        }
    }
 
    hitbox hitbox_test(point2 position) const noexcept override
    {
        hi_axiom(loop::main().on_thread());
 
        if (*mode >= widget_mode::partial) {
            auto r = hitbox{};
            for (hilet& child : _children) {
                r = child.value->hitbox_test_from_parent(position, r);
            }
            return r;
        } else {
            return {};
        }
    }
private:
    row_column_layout<Axis, std::unique_ptr<widget>> _children;
};
 
template<fixed_string Name = "">
using row_widget = row_column_widget<Name / "row", axis::x>;
 
template<fixed_string Name = "">
using column_widget = row_column_widget<Name / "column", axis::y>;
 
}} // namespace hi::v1