gui_root.hpp

#ifndef LXGUI_GUI_ROOT_HPP
#define LXGUI_GUI_ROOT_HPP
 
#include "lxgui/gui_anchor.hpp"
#include "lxgui/gui_frame_container.hpp"
#include "lxgui/gui_frame_renderer.hpp"
#include "lxgui/gui_key_binder.hpp"
#include "lxgui/gui_registry.hpp"
#include "lxgui/gui_vector2.hpp"
#include "lxgui/input_signals.hpp"
#include "lxgui/lxgui.hpp"
#include "lxgui/utils_observer.hpp"
#include "lxgui/utils_signal.hpp"
 
#include <list>
#include <memory>
 
namespace lxgui::input {
 
class world_dispatcher;
 
}
 
namespace lxgui::gui {
 
class region;
class frame;
class manager;
class renderer;
 
class root :
    public utils::enable_observer_from_this<root>,
    public frame_renderer,
    public frame_container {
public:
    explicit root(utils::control_block& block, manager& mgr);
 
    ~root() override;
 
    // Non-copiable, non-movable
    root(const root&)            = delete;
    root(root&&)                 = delete;
    root& operator=(const root&) = delete;
    root& operator=(root&&)      = delete;
 
    vector2f get_target_dimensions() const override;
 
    void render() const;
 
    void enable_caching(bool enable);
 
    void toggle_caching();
 
    bool is_caching_enabled() const;
 
    void update(float delta);
 
    void notify_scaling_factor_updated();
 
    void notify_hovered_frame_dirty();
 
    const utils::observer_ptr<frame>& get_hovered_frame() {
        return hovered_frame_;
    }
 
    utils::observer_ptr<const frame> get_hovered_frame() const {
        return hovered_frame_;
    }
 
    bool is_hovered(const frame& obj) const {
        return hovered_frame_.get() == &obj;
    }
 
    const utils::observer_ptr<frame>& get_dragged_frame() {
        return dragged_frame_;
    }
 
    utils::observer_ptr<const frame> get_dragged_frame() const {
        return dragged_frame_;
    }
 
    bool is_dragged(const frame& obj) const {
        return dragged_frame_.get() == &obj;
    }
 
    void start_moving(
        utils::observer_ptr<region> obj,
        anchor*                     a                     = nullptr,
        constraint                  constraint            = constraint::none,
        std::function<void()>       apply_constraint_func = nullptr);
 
    void stop_moving();
 
    bool is_moving(const region& obj) const;
 
    void start_sizing(utils::observer_ptr<region> obj, point p);
 
    void stop_sizing();
 
    bool is_sizing(const region& obj) const;
 
    void request_focus(utils::observer_ptr<frame> receiver);
 
    void release_focus(const frame& receiver);
 
    void clear_focus();
 
    bool is_focused() const;
 
    utils::observer_ptr<const frame> get_focused_frame() const;
 
    utils::observer_ptr<frame> get_focused_frame() {
        return utils::const_pointer_cast<frame>(const_cast<const root*>(this)->get_focused_frame());
    }
 
    manager& get_manager() {
        return manager_;
    }
 
    const manager& get_manager() const {
        return manager_;
    }
 
    registry& get_registry() {
        return object_registry_;
    }
 
    const registry& get_registry() const {
        return object_registry_;
    }
 
    key_binder& get_key_binder() {
        return key_binder_;
    }
 
    const key_binder& get_key_binder() const {
        return key_binder_;
    }
 
private:
    void create_caching_render_target_();
    void create_strata_cache_render_target_(strata_data& strata_obj);
 
    void clear_hovered_frame_();
    void update_hovered_frame_();
    void
    set_hovered_frame_(utils::observer_ptr<frame> obj, const vector2f& mouse_pos = vector2f::zero);
 
    void on_window_resized_(const vector2ui& dimensions);
    bool on_mouse_moved_(const input::mouse_moved_data& args);
    bool on_mouse_wheel_(const input::mouse_wheel_data& args);
    bool on_drag_start_(const input::mouse_drag_start_data& args);
    bool on_drag_stop_(const input::mouse_drag_stop_data& args);
    bool on_text_entered_(const input::text_entered_data& args);
    bool on_key_state_changed_(input::key key, bool is_down, bool is_repeat);
    bool on_mouse_button_state_changed_(
        input::mouse_button button_id,
        bool                is_down,
        bool                is_double_click,
        bool                was_dragged,
        const vector2f&     mouse_pos);
 
    manager&                 manager_;
    renderer&                renderer_;
    registry                 object_registry_;
    key_binder               key_binder_;
    input::world_dispatcher& world_input_dispatcher_;
 
    // Rendering
    vector2ui screen_dimensions_;
 
    bool caching_enabled_ = false;
 
    std::shared_ptr<render_target> target_;
    quad                           screen_quad_;
 
    // IO
    std::vector<utils::scoped_connection> connections_;
 
    // Mouse IO
    utils::observer_ptr<frame> hovered_frame_     = nullptr;
    utils::observer_ptr<frame> dragged_frame_     = nullptr;
    utils::observer_ptr<frame> start_click_frame_ = nullptr;
 
    utils::observer_ptr<region> moved_object_ = nullptr;
    utils::observer_ptr<region> sized_object_ = nullptr;
    vector2f                    mouse_movement_;
 
    anchor*               moved_anchor_ = nullptr;
    vector2f              movement_start_position_;
    constraint            constraint_ = constraint::none;
    std::function<void()> apply_constraint_func_;
 
    vector2f resize_start_;
    bool     is_resizing_width_       = false;
    bool     is_resizing_height_      = false;
    bool     is_resizing_from_right_  = false;
    bool     is_resizing_from_bottom_ = false;
 
    // Keyboard IO
    std::vector<utils::observer_ptr<frame>> focus_stack_;
};
 
} // namespace lxgui::gui
 
#endif