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 "../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 = {};
 
    widget_intf *parent = nullptr;
 
    notifier<void()> notifier;
 
    observer<widget_state> state;
 
    virtual ~widget_intf()
    {
        release_widget_id(id);
    }
 
    widget_intf(widget_intf const *parent) noexcept :
        id(make_widget_id()), parent(const_cast<widget_intf *>(parent))
    {
        // This lambda allows the state to be set once before it will trigger
        // notifications.
        _state_cbt = state.subscribe([&](widget_state new_state) {
            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;
        });
    }
 
    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);
    }
 
    virtual void set_window(gui_window *window) noexcept = 0;
 
    [[nodiscard]] virtual gui_window *window() const noexcept = 0;
 
    [[nodiscard]] virtual generator<widget_intf&> children(bool include_invisible) noexcept = 0;
 
    [[nodiscard]] virtual generator<widget_intf const&> children(bool include_invisible) 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 (to_bool(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;
 
    widget_layout _layout;
};
 
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");
}
 
} // namespace v1
} // namespace hi::v1