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 "widget.hpp"
#include "../macros.hpp"
#include <coroutine>
 
hi_export_module(hikogui.widgets.overlay_widget);
 
hi_export namespace hi {
inline namespace v1 {

class overlay_widget : public widget {
public:
    using super = widget;
 
    ~overlay_widget() {}

    overlay_widget() noexcept : super() {}
 
    void set_widget(std::unique_ptr<widget> new_widget) noexcept
    {
        if (new_widget) {
            new_widget->set_parent(this);
        }
        auto old_widget = std::exchange(_content, std::move(new_widget));
        if (old_widget) {
            old_widget->set_parent(nullptr);
        }
 
        ++global_counter<"overlay_widget:set_widget:constrain">;
        process_event({gui_event_type::window_reconstrain});
    }

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

    [[nodiscard]] generator<widget_intf&> children(bool include_invisible) noexcept override
    {
        if (_content) {
            co_yield *_content;
        }
    }
 
    [[nodiscard]] box_constraints update_constraints() noexcept override
    {
        _layout = {};
        _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().border_width();
 
        auto const content_rectangle = context.rectangle();
        _content_shape = box_shape{_content_constraints, content_rectangle, theme().baseline_adjustment()};
 
        // The content should not draw in the border of the overlay, so give a tight clipping rectangle.
        _content->set_layout(_layout.transform(_content_shape, context.rectangle()));
    }
 
    void draw(draw_context const& context) noexcept override
    {
        if (mode() > widget_mode::invisible) {
            if (overlaps(context, layout())) {
                draw_background(context);
            }
            _content->draw(context);
        }
    }
 
    [[nodiscard]] color background_color() const noexcept override
    {
        return theme().fill_color(_layout.layer + 1);
    }
 
    [[nodiscard]] color foreground_color() const noexcept override
    {
        return theme().border_color(_layout.layer + 1);
    }
 
    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 {};
        }
    }
 
    bool handle_event(gui_event const& event) noexcept override
    {
        // Short-cut event handling, no-events should be passed below the overlay.
        return true;
    }
private:
    std::unique_ptr<widget> _content;
    box_constraints _content_constraints;
    box_shape _content_shape;
 
    void draw_background(draw_context const& context) noexcept
    {
        context.draw_box(
            layout(), layout().rectangle(), background_color(), foreground_color(), theme().border_width(), border_side::outside);
    }
};
 
} // namespace v1
} // namespace hi::v1