overlay_widget.hpp

Go to the documentation of this file.

// 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 "../GUI/module.hpp"
 
namespace hi { inline namespace v1 {

template<fixed_string Name = "">
class overlay_widget final : public widget {
public:
    using super = widget;
    constexpr static auto prefix = Name / "overlay";
 
    ~overlay_widget() {}

    overlay_widget(widget *parent) noexcept : super(parent)
    {
        if (parent) {
            // The overlay-widget will reset the semantic_layer as it is the bottom
            // layer of this virtual-window. However the draw-layer should be above
            // any other widget drawn.
            semantic_layer = 0;
        }
    }
 
    void set_widget(std::unique_ptr<widget> new_widget) noexcept
    {
        _content = std::move(new_widget);
        ++global_counter<"overlay_widget:set_widget:constrain">;
        process_event({gui_event_type::window_reconstrain});
    }

    template<typename Widget, typename... Args>
    Widget& make_widget(Args&&...args) noexcept
    {
        hi_axiom(loop::main().on_thread());
        hi_assert(_content == nullptr);
 
        auto tmp = std::make_unique<Widget>(this, std::forward<Args>(args)...);
        auto& ref = *tmp;
        set_widget(std::move(tmp));
        return ref;
    }

    [[nodiscard]] generator<widget const&> children(bool include_invisible) const noexcept override
    {
        co_yield *_content;
    }
 
    [[nodiscard]] box_constraints update_constraints() noexcept override
    {
        _content_constraints = _content->update_constraints();
        return _content_constraints;
    }
 
    void set_layout(widget_layout const& context) noexcept override
    {
        layout = context;
 
        // The clipping rectangle of the overlay matches the rectangle exactly, with a border around it.
        layout.clipping_rectangle = context.rectangle() + theme<prefix>.border_width(this);
 
        hilet content_rectangle = context.rectangle();
        _content_shape = box_shape{_content_constraints, content_rectangle, theme<prefix>.cap_height(this)};
 
        // The content should not draw in the border of the overlay, so give a tight clipping rectangle.
        _content->set_layout(layout.transform(_content_shape, 1.0f, context.rectangle()));
    }
 
    void draw(widget_draw_context& context) noexcept override
    {
        if (*mode > widget_mode::invisible) {
            if (overlaps(context, layout)) {
                draw_background(context);
            }
            _content->draw(context);
        }
    }
 
    void scroll_to_show(hi::aarectangle rectangle) noexcept override
    {
        // An overlay is in an absolute position on the window,
        // so do not forward the scroll_to_show message to its parent.
    }
 
    [[nodiscard]] hitbox hitbox_test(point2 position) const noexcept override
    {
        hi_axiom(loop::main().on_thread());
 
        if (*mode >= widget_mode::partial) {
            return _content->hitbox_test_from_parent(position);
        } else {
            return {};
        }
    }
private:
    std::unique_ptr<widget> _content;
    box_constraints _content_constraints;
    box_shape _content_shape;
 
    void draw_background(widget_draw_context& context) noexcept
    {
        context.draw_box(
            layout,
            layout.rectangle(),
            theme<prefix>.background_color(this),
            theme<prefix>.border_color(this),
            theme<prefix>.border_width(this),
            border_side::outside);
    }
};
 
}} // namespace hi::v1