gui_frame.hpp

#ifndef LXGUI_GUI_FRAME_HPP
#define LXGUI_GUI_FRAME_HPP
 
#include "lxgui/gui_backdrop.hpp"
#include "lxgui/gui_event_receiver.hpp"
#include "lxgui/gui_frame_core_attributes.hpp"
#include "lxgui/gui_layered_region.hpp"
#include "lxgui/gui_region.hpp"
#include "lxgui/gui_strata.hpp"
#include "lxgui/input_keys.hpp"
#include "lxgui/lxgui.hpp"
#include "lxgui/utils.hpp"
#include "lxgui/utils_meta.hpp"
#include "lxgui/utils_signal.hpp"
#include "lxgui/utils_view.hpp"
 
#include <functional>
#include <limits>
#include <list>
#include <lxgui/extern_sol2_protected_function.hpp>
#include <magic_enum/magic_enum.hpp>
#include <optional>
#include <set>
#include <unordered_map>
#include <vector>
 
namespace lxgui::gui {
 
class frame_renderer;
class frame;
 
struct layer_container {
    bool                                             is_disabled = false;
    std::vector<utils::observer_ptr<layered_region>> region_list;
};
 
struct script_info {
    std::string file_name;
    std::size_t line_nbr = 0;
};
 
using script_signature = void(frame&, const event_data&);
 
using script_signal = utils::signal<script_signature>;
 
using script_function = script_signal::function_type;
 
using script_list_view = script_signal::slot_list_view;
 
class frame : public region {
public:
    using base = region;
 
    using child_list      = std::list<utils::owner_ptr<frame>>;
    using child_list_view = utils::view::
        adaptor<child_list, utils::view::smart_ptr_dereferencer, utils::view::non_null_filter>;
    using const_child_list_view = utils::view::adaptor<
        const child_list,
        utils::view::smart_ptr_dereferencer,
        utils::view::non_null_filter>;
 
    using region_list      = std::list<utils::owner_ptr<layered_region>>;
    using region_list_view = utils::view::
        adaptor<region_list, utils::view::smart_ptr_dereferencer, utils::view::non_null_filter>;
    using const_region_list_view = utils::view::adaptor<
        const region_list,
        utils::view::smart_ptr_dereferencer,
        utils::view::non_null_filter>;
 
    explicit frame(utils::control_block& block, manager& mgr, const frame_core_attributes& attr);
 
    ~frame() override;
 
    void render() const override;
 
    void update(float delta) final;
 
    std::string serialize(const std::string& tab) const override;
 
    virtual bool can_use_script(const std::string& script_name) const;
 
    void copy_from(const region& obj) override;
 
    void create_title_region();
 
    void set_draw_layer_enabled(layer layer_id, bool enable) {
        if (enable) {
            enable_draw_layer(layer_id);
        } else {
            disable_draw_layer(layer_id);
        }
    }
 
    void disable_draw_layer(layer layer_id);
 
    void enable_draw_layer(layer layer_id);
 
    void set_mouse_enabled(bool is_mouse_enabled);
 
    void enable_mouse() {
        set_mouse_enabled(true);
    }
 
    void disable_mouse() {
        set_mouse_enabled(false);
    }
 
    void set_mouse_click_enabled(bool is_mouse_enabled);
 
    void enable_mouse_click() {
        set_mouse_click_enabled(true);
    }
 
    void disable_mouse_click() {
        set_mouse_click_enabled(false);
    }
 
    void set_mouse_move_enabled(bool is_mouse_enabled);
 
    void enable_mouse_move() {
        set_mouse_move_enabled(true);
    }
 
    void disable_mouse_move() {
        set_mouse_move_enabled(false);
    }
 
    void set_mouse_wheel_enabled(bool is_mouse_wheel_enabled);
 
    void enable_mouse_wheel() {
        set_mouse_wheel_enabled(true);
    }
 
    void disable_mouse_wheel() {
        set_mouse_wheel_enabled(false);
    }
 
    void set_keyboard_enabled(bool is_keyboard_enabled);
 
    void enable_keyboard() {
        set_keyboard_enabled(true);
    }
 
    void disable_keyboard() {
        set_keyboard_enabled(false);
    }
 
    void set_key_capture_enabled(const std::string& key_name, bool enable) {
        if (enable) {
            enable_key_capture(key_name);
        } else {
            disable_key_capture(key_name);
        }
    }
 
    void set_key_capture_enabled(input::key key_id, bool enable) {
        if (enable) {
            enable_key_capture(key_id);
        } else {
            disable_key_capture(key_id);
        }
    }
 
    void enable_key_capture(const std::string& key_name);
 
    void enable_key_capture(input::key key_id);
 
    void disable_key_capture(const std::string& key_name);
 
    void disable_key_capture(input::key key_id);
 
    void disable_key_capture();
 
    bool has_script(const std::string& script_name) const;
 
    utils::observer_ptr<layered_region> add_region(utils::owner_ptr<layered_region> reg);
 
    template<
        typename RegionType,
        typename Enable =
            typename std::enable_if<std::is_base_of<gui::layered_region, RegionType>::value>::type>
    utils::observer_ptr<RegionType> add_region(utils::owner_ptr<RegionType> reg) {
        return utils::static_pointer_cast<RegionType>(
            add_region(utils::static_pointer_cast<layered_region>(std::move(reg))));
    }
 
    utils::owner_ptr<layered_region> remove_region(const utils::observer_ptr<layered_region>& reg);
 
    utils::observer_ptr<layered_region>
    create_layered_region(layer layer_id, region_core_attributes attr);
 
    template<
        typename RegionType,
        typename Enable =
            typename std::enable_if<std::is_base_of<gui::layered_region, RegionType>::value>::type>
    utils::observer_ptr<RegionType>
    create_layered_region(layer layer_id, region_core_attributes attr) {
        attr.object_type = RegionType::class_name;
 
        return utils::static_pointer_cast<RegionType>(
            create_layered_region(layer_id, std::move(attr)));
    }
 
    template<
        typename RegionType,
        typename Enable =
            typename std::enable_if<std::is_base_of<gui::layered_region, RegionType>::value>::type>
    utils::observer_ptr<RegionType> create_layered_region(layer layer_id, const std::string& name) {
        region_core_attributes attr;
        attr.name        = name;
        attr.object_type = RegionType::class_name;
 
        return utils::static_pointer_cast<RegionType>(
            create_layered_region(layer_id, std::move(attr)));
    }
 
    utils::observer_ptr<frame> create_child(frame_core_attributes attr);
 
    template<
        typename FrameType,
        typename Enable =
            typename std::enable_if<std::is_base_of<gui::frame, FrameType>::value>::type>
    utils::observer_ptr<FrameType> create_child(frame_core_attributes attr) {
        attr.object_type = FrameType::class_name;
 
        return utils::static_pointer_cast<FrameType>(create_child(std::move(attr)));
    }
 
    template<
        typename FrameType,
        typename Enable =
            typename std::enable_if<std::is_base_of<gui::frame, FrameType>::value>::type>
    utils::observer_ptr<FrameType> create_child(const std::string& name) {
        frame_core_attributes attr;
        attr.name        = name;
        attr.object_type = FrameType::class_name;
 
        return utils::static_pointer_cast<FrameType>(create_child(std::move(attr)));
    }
 
    utils::observer_ptr<frame> add_child(utils::owner_ptr<frame> child);
 
    template<
        typename FrameType,
        typename Enable =
            typename std::enable_if<std::is_base_of<gui::frame, FrameType>::value>::type>
    utils::observer_ptr<FrameType> add_child(utils::owner_ptr<FrameType> child) {
        return utils::static_pointer_cast<FrameType>(
            add_child(utils::static_pointer_cast<frame>(std::move(child))));
    }
 
    utils::owner_ptr<frame> remove_child(const utils::observer_ptr<frame>& child);
 
    child_list_view get_children();
 
    const_child_list_view get_children() const;
 
    utils::observer_ptr<const frame> get_child(const std::string& name) const;
 
    utils::observer_ptr<frame> get_child(const std::string& name) {
        return utils::const_pointer_cast<frame>(const_cast<const frame*>(this)->get_child(name));
    }
 
    template<
        typename FrameType,
        typename Enable =
            typename std::enable_if<std::is_base_of<gui::frame, FrameType>::value>::type>
    utils::observer_ptr<const FrameType> get_child(const std::string& name) const {
        return down_cast<FrameType>(get_child(name));
    }
 
    template<
        typename FrameType,
        typename Enable =
            typename std::enable_if<std::is_base_of<gui::frame, FrameType>::value>::type>
    utils::observer_ptr<FrameType> get_child(const std::string& name) {
        return down_cast<FrameType>(get_child(name));
    }
 
    region_list_view get_regions();
 
    const_region_list_view get_regions() const;
 
    utils::observer_ptr<const layered_region> get_region(const std::string& name) const;
 
    utils::observer_ptr<layered_region> get_region(const std::string& name) {
        return utils::const_pointer_cast<layered_region>(
            const_cast<const frame*>(this)->get_region(name));
    }
 
    template<
        typename RegionType,
        typename Enable =
            typename std::enable_if<std::is_base_of<gui::layered_region, RegionType>::value>::type>
    utils::observer_ptr<RegionType> get_region(const std::string& name) {
        return down_cast<RegionType>(get_region(name));
    }
 
    float get_effective_scale() const;
 
    int get_level() const;
 
    std::optional<strata> get_strata() const;
 
    strata get_effective_strata() const;
 
    utils::observer_ptr<const frame> get_top_level_parent() const;
 
    utils::observer_ptr<frame> get_top_level_parent() {
        return utils::const_pointer_cast<frame>(
            const_cast<const frame*>(this)->get_top_level_parent());
    }
 
    const backdrop* get_backdrop() const;
 
    backdrop* get_backdrop();
 
    backdrop& get_or_create_backdrop();
 
    const bounds2f& get_abs_hit_rect_insets() const;
 
    const bounds2f& get_rel_hit_rect_insets() const;
 
    vector2f get_max_dimensions() const;
 
    vector2f get_min_dimensions() const;
 
    std::size_t get_child_count() const;
 
    std::size_t get_child_count_upper_bound() const;
 
    std::size_t get_layered_region_count() const;
 
    std::size_t get_layered_region_count_upper_bound() const;
 
    float get_scale() const;
 
    utils::observer_ptr<const region> get_title_region() const {
        return title_region_;
    }
 
    utils::observer_ptr<region> get_title_region() {
        return title_region_;
    }
 
    bool is_clamped_to_screen() const;
 
    bool is_in_region(const vector2f& position) const override;
 
    virtual utils::observer_ptr<const frame>
    find_topmost_frame(const std::function<bool(const frame&)>& predicate) const;
 
    utils::observer_ptr<frame>
    find_topmost_frame(const std::function<bool(const frame&)>& predicate) {
        return utils::const_pointer_cast<frame>(
            const_cast<const frame*>(this)->find_topmost_frame(predicate));
    }
 
    bool is_mouse_move_enabled() const;
 
    bool is_mouse_click_enabled() const;
 
    bool is_mouse_wheel_enabled() const;
 
    bool is_drag_enabled(const std::string& button_name) const;
 
    bool is_key_capture_enabled(const std::string& key_name) const;
 
    bool is_keyboard_enabled() const;
 
    bool is_movable() const;
 
    bool is_resizable() const;
 
    bool is_top_level() const;
 
    bool is_user_placed() const;
 
    static std::string get_adjusted_script_name(const std::string& script_name);
 
    utils::connection add_script(
        const std::string& script_name, std::string content, script_info info = script_info{}) {
        if (!check_script_(script_name))
            return {};
        return define_script_(script_name, content, true, info);
    }
 
    utils::connection add_script(
        const std::string&      script_name,
        sol::protected_function handler,
        script_info             info = script_info{}) {
        if (!check_script_(script_name))
            return {};
        return define_script_(script_name, std::move(handler), true, info);
    }
 
    utils::connection add_script(
        const std::string& script_name, script_function handler, script_info info = script_info{}) {
        if (!check_script_(script_name))
            return {};
        return define_script_(script_name, std::move(handler), true, info);
    }
 
    template<typename DerivedType = void, typename Function>
    utils::connection add_script(
        const std::string& script_name, Function&& handler, script_info info = script_info{}) {
 
        return add_script(
            script_name,
            script_function(
                [handler = std::move(handler)](frame& self, const event_data& data) mutable {
                    constexpr bool use_automatic_cast = std::is_same_v<DerivedType, void>;
 
                    using derived_type = std::decay_t<std::conditional_t<
                        use_automatic_cast, utils::first_function_argument<Function>, DerivedType>>;
 
                    constexpr bool use_no_cast = std::is_same_v<derived_type, frame>;
 
                    if constexpr (use_no_cast) {
                        handler(self, data);
                    } else if constexpr (use_automatic_cast) {
                        handler(down_cast<derived_type>(self), data);
                    } else {
                        handler(static_cast<derived_type&>(self), data);
                    }
                }),
            info);
    }
 
    utils::connection set_script(
        const std::string& script_name, std::string content, script_info info = script_info{}) {
        if (!check_script_(script_name))
            return {};
        return define_script_(script_name, content, false, info);
    }
 
    utils::connection set_script(
        const std::string&      script_name,
        sol::protected_function handler,
        script_info             info = script_info{}) {
        if (!check_script_(script_name))
            return {};
        return define_script_(script_name, std::move(handler), false, info);
    }
 
    utils::connection set_script(
        const std::string& script_name, script_function handler, script_info info = script_info{}) {
        if (!check_script_(script_name))
            return {};
        return define_script_(script_name, std::move(handler), false, info);
    }
 
    template<typename DerivedType = void, typename Function>
    utils::connection set_script(
        const std::string& script_name, Function&& handler, script_info info = script_info{}) {
 
        return set_script(
            script_name,
            script_function(
                [handler = std::move(handler)](frame& self, const event_data& data) mutable {
                    constexpr bool use_automatic_cast = std::is_same_v<DerivedType, void>;
 
                    using derived_type = std::decay_t<std::conditional_t<
                        use_automatic_cast, utils::first_function_argument<Function>, DerivedType>>;
 
                    constexpr bool use_no_cast = std::is_same_v<derived_type, frame>;
 
                    if constexpr (use_no_cast) {
                        handler(self, data);
                    } else if constexpr (use_automatic_cast) {
                        handler(down_cast<derived_type>(self), data);
                    } else {
                        handler(static_cast<derived_type&>(self), data);
                    }
                }),
            info);
    }
 
    script_list_view get_script(const std::string& script_name) const;
 
    void remove_script(const std::string& script_name);
 
    virtual void fire_script(const std::string& script_name, const event_data& data = event_data{});
 
    void set_update_rate(float rate);
 
    float get_update_rate() const;
 
    void register_event(const std::string& event_name);
 
    void unregister_event(const std::string& event_name);
 
    void set_drag_enabled(const std::string& button_name, bool enable) {
        if (enable) {
            enable_drag(button_name);
        } else {
            disable_drag(button_name);
        }
    }
 
    void set_drag_enabled(input::mouse_button button_id, bool enable) {
        if (enable) {
            enable_drag(button_id);
        } else {
            disable_drag(button_id);
        }
    }
 
    void enable_drag(const std::string& button_name);
 
    void enable_drag(input::mouse_button button_id);
 
    void disable_drag(const std::string& button_name);
 
    void disable_drag(input::mouse_button button_id);
 
    void disable_drag();
 
    void set_clamped_to_screen(bool is_clamped_to_screen);
 
    void set_strata(std::optional<strata> strata_id);
 
    void set_backdrop(std::unique_ptr<backdrop> bdrop);
 
    void set_abs_hit_rect_insets(const bounds2f& insets);
 
    void set_rel_hit_rect_insets(const bounds2f& insets);
 
    void set_level(int level_id);
 
    void set_max_dimensions(const vector2f& max);
 
    void set_min_dimensions(const vector2f& min);
 
    void set_max_height(float max_height);
 
    void set_max_width(float max_width);
 
    void set_min_height(float min_height);
 
    void set_min_width(float min_width);
 
    void set_movable(bool is_movable);
 
    utils::owner_ptr<region> release_from_parent() override;
 
    void set_resizable(bool is_resizable);
 
    void set_scale(float scale);
 
    void set_top_level(bool is_top_level);
 
    void raise();
 
    void set_user_placed(bool is_user_placed);
 
    void start_moving();
 
    void stop_moving();
 
    void start_sizing(const point& p);
 
    void stop_sizing();
 
    void enable_auto_focus(bool enable);
 
    bool is_auto_focus_enabled() const;
 
    void set_focus(bool focus);
 
    bool has_focus() const;
 
    void set_frame_renderer(utils::observer_ptr<frame_renderer> rdr);
 
    utils::observer_ptr<const frame_renderer> get_frame_renderer() const {
        return frame_renderer_;
    }
 
    const utils::observer_ptr<frame_renderer>& get_frame_renderer() {
        return frame_renderer_;
    }
 
    utils::observer_ptr<const frame_renderer> get_effective_frame_renderer() const final;
 
    utils::observer_ptr<frame_renderer> get_effective_frame_renderer() {
        return utils::const_pointer_cast<frame_renderer>(
            const_cast<const frame*>(this)->get_effective_frame_renderer());
    }
 
    void notify_renderer_need_redraw() override;
 
    void set_dimensions(const vector2f& dimensions) override;
 
    void set_width(float abs_width) override;
 
    void set_height(float abs_height) override;
 
    virtual void notify_mouse_in_frame(bool mouse_in_frame, const vector2f& mouse_pos);
 
    void notify_visible() override;
 
    void notify_invisible() override;
 
    virtual void notify_focus(bool focus);
 
    void notify_loaded() override;
 
    void notify_layers_need_update();
 
    void notify_scaling_factor_updated() override;
 
    void parse_layout(const layout_node& node) final;
 
    static void register_on_lua(sol::state& lua);
 
    static constexpr const char* class_name = "Frame";
 
protected:
    // Layout parsing
    void         parse_attributes_(const layout_node& node) override;
    virtual void parse_all_nodes_before_children_(const layout_node& node);
    virtual void parse_resize_bounds_node_(const layout_node& node);
    virtual void parse_title_region_node_(const layout_node& node);
    virtual void parse_backdrop_node_(const layout_node& node);
    virtual void parse_hit_rect_insets_node_(const layout_node& node);
    virtual void parse_layers_node_(const layout_node& node);
    virtual void parse_frames_node_(const layout_node& node);
    virtual void parse_scripts_node_(const layout_node& node);
 
    const std::vector<std::string>& get_type_list_() const override;
 
    utils::observer_ptr<layered_region>
    parse_region_(const layout_node& node, const std::string& layer_name, const std::string& type);
 
    utils::observer_ptr<frame> parse_child_(const layout_node& node, const std::string& type);
 
    virtual void update_(float delta);
 
    void check_position_();
 
    void add_level_(int amount);
 
    utils::observer_ptr<const frame_renderer> compute_top_level_frame_renderer_() const;
 
    utils::observer_ptr<frame_renderer> compute_top_level_frame_renderer_() {
        return utils::const_pointer_cast<frame_renderer>(
            const_cast<const frame*>(this)->compute_top_level_frame_renderer_());
    }
 
    strata compute_effective_strata_() const;
 
    void notify_strata_changed_(strata new_strata_id);
 
    void notify_frame_renderer_changed_(const utils::observer_ptr<frame_renderer>& new_renderer);
 
    void update_borders_() override;
 
    void set_parent_(utils::observer_ptr<frame> parent) override;
 
    bool check_script_(const std::string& script_name) const;
 
    utils::connection define_script_(
        const std::string& script_name,
        const std::string& content,
        bool               append,
        const script_info& info);
 
    utils::connection define_script_(
        const std::string&      script_name,
        sol::protected_function handler,
        bool                    append,
        const script_info&      info);
 
    utils::connection define_script_(
        const std::string& script_name,
        script_function    handler,
        bool               append,
        const script_info& info);
 
    void on_event_(std::string_view event_name, const event_data& event);
 
    child_list  child_list_;
    region_list region_list_;
 
    static constexpr std::size_t num_layers = magic_enum::enum_count<layer>();
 
    std::array<layer_container, num_layers> layer_list_;
 
    std::unordered_map<std::string, script_signal> signal_list_;
    event_receiver                                 event_receiver_;
 
    std::set<std::string> reg_drag_list_;
    std::set<std::string> reg_key_list_;
 
    int                   level_ = 0;
    std::optional<strata> strata_;
    strata                effective_strata_ = strata::medium;
    bool                  is_top_level_     = false;
 
    utils::observer_ptr<frame_renderer> frame_renderer_           = nullptr;
    utils::observer_ptr<frame_renderer> effective_frame_renderer_ = nullptr;
 
    std::unique_ptr<backdrop> backdrop_;
 
    bool is_mouse_click_enabled_ = false;
    bool is_mouse_move_enabled_  = false;
    bool is_mouse_wheel_enabled_ = false;
    bool is_keyboard_enabled_    = false;
    bool is_movable_             = false;
    bool is_clamped_to_screen_   = false;
    bool is_resizable_           = false;
    bool is_user_placed_         = false;
 
    bounds2f abs_hit_rect_inset_list_ = bounds2f::zero;
    bounds2f rel_hit_rect_inset_list_ = bounds2f::zero;
 
    float min_width_  = 0.0f;
    float max_width_  = std::numeric_limits<float>::infinity();
    float min_height_ = 0.0f;
    float max_height_ = std::numeric_limits<float>::infinity();
 
    float scale_ = 1.0f;
 
    float update_rate_            = 0.0f;
    float time_since_last_update_ = std::numeric_limits<float>::infinity();
 
    bool is_mouse_in_frame_ = false;
 
    utils::owner_ptr<region> title_region_ = nullptr;
 
    bool is_focused_    = false;
    bool is_auto_focus_ = false;
};
 
} // namespace lxgui::gui
 
#endif