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_mode.hpp"
#include "../layout/module.hpp"
#include "../geometry/module.hpp"
#include "../observer/module.hpp"
#include "../time/module.hpp"
#include "../settings/module.hpp"
#include "../numeric/module.hpp"
#include "../GUI/module.hpp"
#include "../generator.hpp"
#include <memory>
#include <vector>
#include <string>
#include <ranges>
 
namespace hi { inline namespace v1 {
 
class widget : public widget_intf {
public:
    observer<widget_mode> mode = widget_mode::enabled;
 
    observer<bool> hover = false;
 
    observer<bool> focus = false;
 
    int semantic_layer = 0;
 
    int logical_layer = 0;
 
    observer<extent2> minimum = extent2{};
 
    observer<extent2> maximum = extent2::large();
 
    explicit widget(widget *parent) noexcept;
 
    virtual ~widget();
    widget(const widget&) = delete;
    widget& operator=(const widget&) = delete;
    widget(widget&&) = delete;
    widget& operator=(widget&&) = delete;
 
    using widget_intf::children;
    [[nodiscard]] generator<widget_intf &> children(bool include_invisible) noexcept override
    {
        co_return;
    }
 
    [[nodiscard]] hitbox hitbox_test(point2 position) const noexcept override
    {
        return {};
    }
 
    [[nodiscard]] virtual hitbox hitbox_test_from_parent(point2 position) const noexcept
    {
        return hitbox_test(_layout.from_parent * position);
    }
 
    [[nodiscard]] virtual hitbox hitbox_test_from_parent(point2 position, hitbox sibling_hitbox) const noexcept
    {
        return std::max(sibling_hitbox, hitbox_test(_layout.from_parent * position));
    }
 
    [[nodiscard]] bool accepts_keyboard_focus(keyboard_focus_group group) const noexcept override
    {
        hi_axiom(loop::main().on_thread());
        return false;
    }
 
    [[nodiscard]] box_constraints update_constraints() noexcept override
    {
        _layout = {};
        return {*minimum, *minimum, *maximum};
    }
 
    void set_layout(widget_layout const& context) noexcept override
    {
        _layout = context;
    }
 
    widget_layout const& layout() const noexcept override
    {
        return _layout;
    }
 
    void draw(draw_context const& context) noexcept override {}
 
    bool process_event(gui_event const& event) const noexcept override
    {
        if (parent != nullptr) {
            return parent->process_event(event);
        } else {
            return true;
        }
    }
 
    void request_redraw() const noexcept override
    {
        process_event({gui_event_type::window_redraw, layout().clipping_rectangle_on_window()});
    }
 
    bool handle_event(gui_event const& event) noexcept override;
 
    bool handle_event_recursive(
        gui_event const& event,
        std::vector<widget_id> const& reject_list = std::vector<widget_id>{}) noexcept override;
 
    [[nodiscard]] virtual widget_id find_next_widget(
        widget_id current_keyboard_widget,
        keyboard_focus_group group,
        keyboard_focus_direction direction) const noexcept override;
 
    [[nodiscard]] widget_id find_first_widget(keyboard_focus_group group) const noexcept override;
 
    [[nodiscard]] widget_id find_last_widget(keyboard_focus_group group) const noexcept override;
 
    [[nodiscard]] bool is_first(keyboard_focus_group group) const noexcept;
 
    [[nodiscard]] bool is_last(keyboard_focus_group group) const noexcept;
 
    using widget_intf::scroll_to_show;
    void scroll_to_show(hi::aarectangle rectangle) noexcept override;
 
    void set_window(gui_window *window) noexcept override
    {
        if (parent) {
            return parent->set_window(window);
        } else {
            return;
        }
    }
 
    [[nodiscard]] gui_window *window() const noexcept override
    {
        if (parent) {
            return parent->window();
        } else {
            return nullptr;
        }
    }
 
    [[nodiscard]] hi::theme const &theme() const noexcept
    {
        hilet w = window();
        hi_assert_not_null(w);
        return w->theme;
    }
 
    [[nodiscard]] gfx_surface const *surface() const noexcept
    {
        if (auto w = window()) {
            return w->surface.get();
        } 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]] aarectangle make_overlay_rectangle(aarectangle requested_rectangle) const noexcept;
};
 
}} // namespace hi::v1