widget.hpp

// Copyright Take Vos 2023.
// 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_id.hpp"
#include "widget_mode.hpp"
#include "widget_state.hpp"
#include "widget_layout.hpp"
#include "hitbox.hpp"
#include "keyboard_focus_group.hpp"
#include "gui_event.hpp"
#include "widget_draw_context.hpp"
#include "../theme/module.hpp"
#include "../geometry/module.hpp"
#include "../layout/box_constraints.hpp"
#include "../observer.hpp"
#include "../generator.hpp"
#include "../loop.hpp"
 
namespace hi { inline namespace v1 {
class gui_window;
class gfx_surface;
 
class widget {
public:
    using callback_token = notifier<void()>::callback_token;
    using awaiter_type = notifier<void()>::awaiter_type;
 
    widget_id id = {};
 
    widget *parent = nullptr;
 
    gfx_surface *surface = nullptr;
 
    observer<widget_mode> mode = widget_mode::enabled;
 
    observer<bool> hover = false;
 
    observer<bool> clicked = false;
 
    observer<bool> focus = false;
 
    observer<widget_state> state = widget_state::off;
 
    size_t semantic_layer = 0_uz;
 
    observer<extent2i> minimum = extent2i{};
 
    observer<extent2i> maximum = extent2i::large();
 
    widget_layout layout;
 
    virtual ~widget() {}
    widget(widget *parent) noexcept : parent(parent), id(narrow_cast<uint32_t>(++global_counter<"widget::id">))
    {
        hi_axiom(loop::main().on_thread());
 
        if (parent) {
            semantic_layer = parent->semantic_layer + 1;
        }
 
        _mode_cbt = mode.subscribe([&](auto...) {
            ++global_counter<"widget:mode:constrain">;
            process_event({gui_event_type::window_reconstrain});
        });
    }
 
    widget(widget const&) = delete;
    widget(widget&&) = delete;
    widget& operator=(widget&&) = delete;
    widget& operator=(widget const&) = 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
    {
        return false;
    }
 
    void reset_layout(gfx_surface *new_surface, float new_scale) noexcept
    {
        layout = {};
        surface = new_surface;
        _scale = narrow_cast<int>(std::round(new_scale * -4.0));
    }
 
    [[nodiscard]] virtual box_constraints update_constraints() noexcept
    {
        return {*minimum, *minimum, *maximum};
    }
 
    virtual void set_layout(widget_layout const& context) noexcept
    {
        layout = context;
    }
 
    virtual void draw(widget_draw_context& context) noexcept {};
 
    [[nodiscard]] virtual sub_theme_selector_type sub_theme_selector() const noexcept
    {
        auto s = theme_state{};
        if (*mode == widget_mode::disabled) {
            s |= theme_state::disabled;
        } else if (*clicked) {
            s |= theme_state::active;
        } else if (*hover) {
            s |= theme_state::hover;
        } else {
            s |= theme_state::enabled;
        }
 
        if (*focus) {
            s |= theme_state::focus;
        }
 
        if (*state != widget_state::off) {
            s |= theme_state::on;
        }
 
        s |= static_cast<theme_state>((semantic_layer % 4) * to_underlying(theme_state::layer_1));
        return sub_theme_selector_type{s, _scale};
    }
 
    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
    {
        hi_axiom(loop::main().on_thread());
 
        switch (event.type()) {
            using enum hi::gui_event_type;
        case keyboard_enter:
            focus = true;
            scroll_to_show(layout.rectangle());
            ++global_counter<"widget:keyboard_enter:redraw">;
            request_redraw();
            return true;
 
        case keyboard_exit:
            focus = false;
            ++global_counter<"widget:keyboard_exit:redraw">;
            request_redraw();
            return true;
 
        case mouse_enter:
            hover = true;
            ++global_counter<"widget:mouse_enter:redraw">;
            request_redraw();
            return true;
 
        case mouse_exit:
            hover = false;
            ++global_counter<"widget:mouse_exit:redraw">;
            request_redraw();
            return true;
 
        case gui_widget_next:
            process_event(
                gui_event::window_set_keyboard_target(id, keyboard_focus_group::normal, keyboard_focus_direction::forward));
            return true;
 
        case gui_widget_prev:
            process_event(
                gui_event::window_set_keyboard_target(id, keyboard_focus_group::normal, keyboard_focus_direction::backward));
            return true;
 
        case gui_activate_next:
            process_event(gui_activate);
            return process_event(gui_widget_next);
 
        case gui_event_type::gui_toolbar_next:
            if (*mode >= widget_mode::partial and accepts_keyboard_focus(keyboard_focus_group::toolbar) and
                not is_last(keyboard_focus_group::toolbar)) {
                process_event(
                    gui_event::window_set_keyboard_target(id, keyboard_focus_group::toolbar, keyboard_focus_direction::forward));
                return true;
            }
            break;
 
        case gui_event_type::gui_toolbar_prev:
            if (*mode >= widget_mode::partial and accepts_keyboard_focus(keyboard_focus_group::toolbar) and
                not is_first(keyboard_focus_group::toolbar)) {
                process_event(
                    gui_event::window_set_keyboard_target(id, keyboard_focus_group::toolbar, keyboard_focus_direction::backward));
                return true;
            }
            break;
 
        default:;
        }
 
        return false;
    }
 
    virtual bool
    handle_event_recursive(gui_event const& event, std::vector<widget_id> const& reject_list = std::vector<widget_id>{}) noexcept
    {
        hi_axiom(loop::main().on_thread());
 
        auto handled = false;
 
        for (auto& child : children(false)) {
            handled |= child.handle_event_recursive(event, reject_list);
        }
 
        if (not std::ranges::any_of(reject_list, [&](hilet& x) {
                return x == id;
            })) {
            handled |= handle_event(event);
        }
 
        return handled;
    }
 
    [[nodiscard]] virtual widget_id find_next_widget(
        widget_id current_keyboard_widget,
        keyboard_focus_group group,
        keyboard_focus_direction direction) const noexcept
    {
        hi_axiom(loop::main().on_thread());
 
        auto found = false;
 
        if (not current_keyboard_widget and accepts_keyboard_focus(group)) {
            // If there was no current_keyboard_widget, then return this if it accepts focus.
            return id;
 
        } else if (current_keyboard_widget == id) {
            found = true;
        }
 
        auto children_ = std::vector<widget const *>{};
        for (auto& child : children(false)) {
            children_.push_back(std::addressof(child));
        }
 
        if (direction == keyboard_focus_direction::backward) {
            std::reverse(begin(children_), end(children_));
        }
 
        for (auto *child : children_) {
            hi_axiom_not_null(child);
 
            if (found) {
                // Find the first focus accepting widget.
                if (auto tmp = child->find_next_widget({}, group, direction)) {
                    return tmp;
                }
 
            } else {
                auto tmp = child->find_next_widget(current_keyboard_widget, group, direction);
                if (tmp == current_keyboard_widget) {
                    // The current widget was found, but no next widget available in the child.
                    // Try the first widget that does accept keyboard focus.
                    found = true;
 
                } else if (tmp != nullptr) {
                    // Return the next widget that was found in the child-widget.
                    return tmp;
                }
            }
        }
 
        if (found) {
            // Either:
            // 1. current_keyboard_widget was nullptr; this widget, nor its child widgets accept focus.
            // 2. current_keyboard_wigget was this; none of the child widgets accept focus.
            // 3. current_keyboard_widget is a child; none of the following widgets accept focus.
            return current_keyboard_widget;
        }
 
        return std::nullopt;
    }
 
    [[nodiscard]] widget_id find_first_widget(keyboard_focus_group group) const noexcept
    {
        hi_axiom(loop::main().on_thread());
 
        for (auto& child : children(false)) {
            if (child.accepts_keyboard_focus(group)) {
                return child.id;
            }
        }
        return std::nullopt;
    }
 
    [[nodiscard]] widget_id find_last_widget(keyboard_focus_group group) const noexcept
    {
        hi_axiom(loop::main().on_thread());
 
        auto found = widget_id{};
        for (auto& child : children(false)) {
            if (child.accepts_keyboard_focus(group)) {
                found = child.id;
            }
        }
 
        return found;
    }
 
    [[nodiscard]] bool is_first(keyboard_focus_group group) const noexcept
    {
        hi_axiom(loop::main().on_thread());
        return parent->find_first_widget(group) == id;
    }
 
    [[nodiscard]] bool is_last(keyboard_focus_group group) const noexcept
    {
        hi_axiom(loop::main().on_thread());
        return parent->find_last_widget(group) == id;
    }
 
    virtual void scroll_to_show(hi::aarectanglei rectangle) noexcept
    {
        hi_axiom(loop::main().on_thread());
 
        if (parent) {
            parent->scroll_to_show(layout.to_parent * rectangle);
        }
    }
 
    [[nodiscard]] std::vector<widget_id> parent_chain() const noexcept
    {
        hi_axiom(loop::main().on_thread());
 
        std::vector<widget_id> chain;
 
        if (auto w = this) {
            chain.push_back(w->id);
            while (to_bool(w = w->parent)) {
                chain.push_back(w->id);
            }
        }
 
        return chain;
    }
 
    [[nodiscard]] virtual bool is_tab_button() const noexcept
    {
        return false;
    }
 
    template<forward_of<void()> Callback>
    [[nodiscard]] callback_token subscribe(Callback&& callback, callback_flags flags = callback_flags::synchronous) const noexcept
    {
        return _state_changed.subscribe(std::forward<Callback>(callback), flags);
    }
 
    [[nodiscard]] awaiter_type operator co_await() const noexcept
    {
        return _state_changed.operator co_await();
    }
 
protected:
    int _scale = -4;
 
    mutable notifier<void()> _state_changed;
 
    [[nodiscard]] aarectanglei make_overlay_rectangle(aarectanglei requested_rectangle) const noexcept
    {
        hi_axiom(loop::main().on_thread());
 
        // Move the request_rectangle to window coordinates.
        hilet requested_window_rectangle = translate2i{layout.clipping_rectangle_on_window()} * requested_rectangle;
 
        hilet window_bounds = aarectanglei{layout.window_size} - theme<"window">.margin(this);
        hilet response_window_rectangle = fit(window_bounds, requested_window_rectangle);
        return layout.from_window * response_window_rectangle;
    }
 
private:
    decltype(mode)::callback_token _mode_cbt;
};
 
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");
}
 
template<std::invocable<widget&> F>
inline void apply(widget& start, bool include_invisible, F const& f)
{
    for (auto& child : start.children(include_invisible)) {
        apply(child, include_invisible, f);
    }
    f(start);
}
 
template<std::invocable<widget&> F>
inline void apply(widget& start, F const& f)
{
    return apply(start, true, f);
}
 
}} // namespace hi::v1