widget.hpp

Go to the documentation of this file.

// Copyright Take Vos 2019-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 "widget_layout.hpp"
#include "widget_mode.hpp"
#include "../GFX/draw_context.hpp"
#include "../GUI/theme.hpp"
#include "../GUI/hitbox.hpp"
#include "../GUI/keyboard_focus_direction.hpp"
#include "../GUI/keyboard_focus_group.hpp"
#include "../GUI/gui_event.hpp"
#include "../GUI/widget_id.hpp"
#include "../layout/box_constraints.hpp"
#include "../geometry/module.hpp"
#include "../observer.hpp"
#include "../chrono.hpp"
#include "../generator.hpp"
#include "../cache.hpp"
#include "../os_settings.hpp"
#include "../tagged_id.hpp"
#include <memory>
#include <vector>
#include <string>
#include <ranges>
 
namespace hi { inline namespace v1 {
class gui_window;
class gfx_surface;
 
class widget : public std::enable_shared_from_this<widget> {
public:
    widget *parent = nullptr;
 
    widget_id id = {};
 
    observer<widget_mode> mode = widget_mode::enabled;
 
    observer<bool> hover = false;
 
    observer<bool> focus = false;
 
    int semantic_layer = 0;
 
    int logical_layer = 0;
 
    observer<extent2i> minimum = extent2i{};
 
    observer<extent2i> maximum = extent2i::large();
 
    explicit widget(widget *parent) noexcept;
 
    virtual ~widget();
    widget(const widget&) = delete;
    widget& operator=(const widget&) = delete;
    widget(widget&&) = delete;
    widget& operator=(widget&&) = delete;
 
    [[nodiscard]] virtual generator<widget const&> children(bool include_invisible) const noexcept
    {
        co_return;
    }
 
    [[nodiscard]] generator<widget&> children(bool include_invisible) noexcept
    {
        for (auto& child : const_cast<widget const *>(this)->children(include_invisible)) {
            co_yield const_cast<widget&>(child);
        }
    }
 
    [[nodiscard]] virtual hitbox hitbox_test(point2i position) const noexcept
    {
        return {};
    }
 
    [[nodiscard]] virtual hitbox hitbox_test_from_parent(point2i position) const noexcept
    {
        return hitbox_test(_layout.from_parent * position);
    }
 
    [[nodiscard]] virtual hitbox hitbox_test_from_parent(point2i position, hitbox sibling_hitbox) const noexcept
    {
        return std::max(sibling_hitbox, hitbox_test(_layout.from_parent * position));
    }
 
    [[nodiscard]] virtual bool accepts_keyboard_focus(keyboard_focus_group group) const noexcept
    {
        hi_axiom(loop::main().on_thread());
        return false;
    }
 
    virtual [[nodiscard]] box_constraints update_constraints() noexcept
    {
        _layout = {};
        return {*minimum, *minimum, *maximum};
    }
 
    virtual void set_layout(widget_layout const& context) noexcept
    {
        _layout = context;
    }
 
    widget_layout const& layout() const noexcept
    {
        return _layout;
    }
 
    virtual void draw(draw_context const& context) noexcept {}
 
    virtual bool process_event(gui_event const& event) const noexcept
    {
        if (parent != nullptr) {
            return parent->process_event(event);
        } else {
            return true;
        }
    }
 
    virtual void request_redraw() const noexcept
    {
        process_event({gui_event_type::window_redraw, layout().clipping_rectangle_on_window()});
    }
 
    virtual bool handle_event(gui_event const& event) noexcept;
 
    virtual bool
    handle_event_recursive(gui_event const& event, std::vector<widget_id> const& reject_list = std::vector<widget_id>{}) noexcept;
 
    [[nodiscard]] virtual widget_id find_next_widget(
        widget_id current_keyboard_widget,
        keyboard_focus_group group,
        keyboard_focus_direction direction) const noexcept;
 
    [[nodiscard]] widget_id find_first_widget(keyboard_focus_group group) const noexcept;
 
    [[nodiscard]] widget_id find_last_widget(keyboard_focus_group group) const noexcept;
 
    [[nodiscard]] bool is_first(keyboard_focus_group group) const noexcept;
 
    [[nodiscard]] bool is_last(keyboard_focus_group group) const noexcept;
 
    virtual void scroll_to_show(hi::aarectanglei rectangle) noexcept;
 
    void scroll_to_show() noexcept
    {
        scroll_to_show(layout().rectangle());
    }
 
    [[nodiscard]] std::vector<widget_id> parent_chain() const noexcept;
 
    [[nodiscard]] virtual gui_window *window() const noexcept
    {
        if (parent) {
            return parent->window();
        } else {
            return nullptr;
        }
    }
 
    [[nodiscard]] virtual hi::theme const& theme() const noexcept
    {
        hi_assert_not_null(parent);
        return parent->theme();
    }
 
    [[nodiscard]] virtual gfx_surface const *surface() const noexcept
    {
        if (parent) {
            return parent->surface();
        } else {
            return nullptr;
        }
    }
 
    [[nodiscard]] virtual color background_color() const noexcept;
 
    [[nodiscard]] virtual color foreground_color() const noexcept;
 
    [[nodiscard]] virtual color focus_color() const noexcept;
 
    [[nodiscard]] virtual color accent_color() const noexcept;
 
    [[nodiscard]] virtual color label_color() const noexcept;
 
protected:
    widget_layout _layout;
 
    decltype(mode)::callback_token _mode_cbt;
 
    [[nodiscard]] aarectanglei make_overlay_rectangle(aarectanglei requested_rectangle) const noexcept;
};
 
inline widget *get_if(widget *start, widget_id id, bool include_invisible) noexcept
{
    hi_assert_not_null(start);
 
    if (start->id == id) {
        return start;
    }
    for (auto& child : start->children(include_invisible)) {
        if (hilet r = get_if(&child, id, include_invisible); r != nullptr) {
            return r;
        }
    }
    return nullptr;
}
 
inline widget& get(widget& start, widget_id id, bool include_invisible)
{
    if (auto r = get_if(std::addressof(start), id, include_invisible); r != nullptr) {
        return *r;
    }
    throw not_found_error("get widget by id");
}
 
}} // namespace hi::v1