widget_intf.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 "hitbox.hpp"
#include "widget_layout.hpp"
#include "widget_id.hpp"
#include "widget_state.hpp"
#include "keyboard_focus_group.hpp"
#include "../layout/layout.hpp"
#include "../GFX/GFX.hpp"
#include "../telemetry/telemetry.hpp"
#include "../theme/theme.hpp"
#include "../macros.hpp"
#include <coroutine>
 
hi_export_module(hikogui.GUI : widget_intf);
 
hi_export namespace hi {
inline namespace v1 {
class gui_window;
 
class widget_intf {
public:
    widget_id id = {};

    hi::style style = {};
 
    gui_window *window = nullptr;

    notifier<void()> notifier;

    observer<widget_state> state;
 
    virtual ~widget_intf()
    {
        release_widget_id(id);
    }
 
    widget_intf() noexcept : id(make_widget_id())
    {
        _style_cbt = style.subscribe([&](style_modify_mask mask, bool path_has_changed) {
            if (path_has_changed) {
                // When the path has changed of a style, the style of the children
                // may change as well. Therefor we update the parent-path of the
                // children to trigger a re-evaluation of the style.
                ++global_counter<"widget:style:path">;
                for (auto &child : children()) {
                    child.style.set_parent_path(style.path());
                }
            }
 
            if (to_bool(mask & style_modify_mask::layout)) {
                // The layout has changed which means its size may have changed
                // which would require a re-layout and re-constrain of the widget.
                ++global_counter<"widget:style:reconstrain">;
                process_event({gui_event_type::window_reconstrain});
 
            } else if (to_bool(mask & style_modify_mask::redraw)) {
                // The color attributes, or border magnitude has changed which
                // should only change the widget visually and not the layout.
                ++global_counter<"widget:style:redraw">;
                request_redraw();
            }
        });
 
        // This lambda allows the state to be set once before it will trigger
        // notifications.
        _state_cbt = state.subscribe([&](widget_state new_state) {
            style.set_pseudo_class(new_state.pseudo_class());
 
            static std::optional<widget_state> old_state = std::nullopt;
 
            if (old_state) {
                if (need_reconstrain(*old_state, *state)) {
                    ++global_counter<"widget:state:reconstrain">;
                    process_event({gui_event_type::window_reconstrain});
 
                } else if (need_relayout(*old_state, *state)) {
                    ++global_counter<"widget:state:relayout">;
                    process_event({gui_event_type::window_relayout});
 
                } else if (need_redraw(*old_state, *state)) {
                    ++global_counter<"widget:state:redraw">;
                    request_redraw();
                }
            }
            old_state = *state;
        });
    }

    [[nodiscard]] widget_intf *parent() const noexcept
    {
        return _parent;
    }

    virtual void set_parent(widget_intf *new_parent) noexcept;

    template<forward_of<void()> Func>
    [[nodiscard]] callback<void()> subscribe(Func&& func, callback_flags flags = callback_flags::synchronous) noexcept
    {
        return notifier.subscribe(std::forward<Func>(func), flags);
    }

    [[nodiscard]] auto operator co_await() const noexcept
    {
        return notifier.operator co_await();
    }
 
    [[nodiscard]] size_t layer() const noexcept
    {
        return state->layer();
    }
 
    void set_layer(size_t new_layer) noexcept
    {
        state->set_layer(new_layer);
    }
 
    [[nodiscard]] widget_mode mode() const noexcept
    {
        return state->mode();
    }
 
    void set_mode(widget_mode new_mode) noexcept
    {
        state->set_mode(new_mode);
    }
 
    [[nodiscard]] widget_value value() const noexcept
    {
        return state->value();
    }
 
    void set_value(widget_value new_value) noexcept
    {
        state->set_value(new_value);
    }
 
    [[nodiscard]] widget_phase phase() const noexcept
    {
        return state->phase();
    }
 
    void set_pressed(bool pressed) noexcept
    {
        state->set_pressed(pressed);
    }
 
    void set_hover(bool hover) noexcept
    {
        state->set_hover(hover);
    }
 
    void set_active(bool active) noexcept
    {
        state->set_active(active);
    }
 
    [[nodiscard]] bool focus() const noexcept
    {
        return state->focus();
    }
 
    void set_focus(bool new_focus) noexcept
    {
        state->set_focus(new_focus);
    }

    [[nodiscard]] virtual generator<widget_intf&> children(bool include_invisible = true) noexcept = 0;

    [[nodiscard]] virtual generator<widget_intf const&> children(bool include_invisible = true) const noexcept final
    {
        for (auto& child : const_cast<widget_intf *>(this)->children(include_invisible)) {
            co_yield child;
        }
    }

    [[nodiscard]] virtual box_constraints update_constraints() noexcept = 0;

    virtual void set_layout(widget_layout const& context) noexcept = 0;

    [[nodiscard]] widget_layout const& layout() const noexcept
    {
        return _layout;
    }

    virtual void draw(draw_context const& context) noexcept = 0;

    [[nodiscard]] virtual hitbox hitbox_test(point2 position) const noexcept = 0;

    [[nodiscard]] virtual bool accepts_keyboard_focus(keyboard_focus_group group) const noexcept = 0;

    virtual void request_redraw() const noexcept = 0;

    virtual bool process_event(gui_event const& event) const noexcept = 0;

    virtual bool handle_event(gui_event const& event) noexcept = 0;

    virtual bool handle_event_recursive(
        gui_event const& event,
        std::vector<widget_id> const& reject_list = std::vector<widget_id>{}) noexcept = 0;

    [[nodiscard]] virtual widget_id find_next_widget(
        widget_id current_keyboard_widget,
        keyboard_focus_group group,
        keyboard_focus_direction direction) const noexcept = 0;

    [[nodiscard]] std::vector<widget_id> parent_chain() const noexcept
    {
        std::vector<widget_id> chain;
 
        if (auto w = this) {
            chain.push_back(w->id);
            while ((w = w->parent())) {
                chain.push_back(w->id);
            }
        }
 
        return chain;
    }

    virtual void scroll_to_show(hi::aarectangle rectangle) noexcept = 0;

    void scroll_to_show() noexcept
    {
        scroll_to_show(layout().rectangle());
    }
 
protected:
    callback<void(widget_state)> _state_cbt;
    hi::style::callback_type _style_cbt;
 
    widget_layout _layout;
 
private:
    widget_intf *_parent = nullptr;
};
 
inline widget_intf *get_if(widget_intf *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 (auto const r = get_if(&child, id, include_invisible); r != nullptr) {
            return r;
        }
    }
    return nullptr;
}
 
inline widget_intf& get(widget_intf& 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_intf&> Func>
inline void apply(widget_intf& start, Func &&func, bool include_invisible = true)
{
    auto todo = std::vector<widget_intf *>{&start};
 
    while (not todo.empty()) {
        auto *tmp = todo.back();
        todo.pop_back();
 
        func(*tmp);
 
        for (auto &child : tmp->children(include_invisible)) {
            todo.push_back(&child);
        }
    }
}
 
inline void apply_window_data(widget_intf& start, gui_window *new_window, unit::pixel_density const& new_density, style::attributes_from_theme_type const& new_attributes_from_theme)
{
    apply(start, [&](widget_intf& w) {
        w.window = new_window;
        w.style.set_pixel_density(new_density);
        w.style.set_attributes_from_theme(new_attributes_from_theme);
    });
}
 
inline void widget_intf::set_parent(widget_intf *new_parent) noexcept
{
    _parent = new_parent;
    apply_window_data(
        *this,
        new_parent ? new_parent->window : nullptr,
        new_parent ? new_parent->style.pixel_density() : unit::pixel_density{},
        new_parent ? new_parent->style.attributes_from_theme() : style::attributes_from_theme_type{});
 
    // The path will automatically propagate to the child widgets.
    style.set_parent_path(new_parent ? new_parent->style.path() : style_path{});
}
 
 
} // namespace v1
} // namespace hi