gui_region.hpp

#ifndef LXGUI_GUI_REGION_HPP
#define LXGUI_GUI_REGION_HPP
 
#include "lxgui/gui_anchor.hpp"
#include "lxgui/gui_bounds2.hpp"
#include "lxgui/gui_color.hpp"
#include "lxgui/gui_exception.hpp"
#include "lxgui/gui_region_core_attributes.hpp"
#include "lxgui/gui_vector2.hpp"
#include "lxgui/lxgui.hpp"
#include "lxgui/utils.hpp"
#include "lxgui/utils_maths.hpp"
#include "lxgui/utils_observer.hpp"
 
#include <array>
#include <lxgui/extern_sol2_object.hpp>
#include <optional>
#include <unordered_map>
#include <vector>
 
namespace sol {
 
class state;
 
}
namespace lxgui::gui {
 
struct addon;
class manager;
class registry;
class factory;
class layout_node;
 
class frame;
class frame_renderer;
 
class region : public utils::enable_observer_from_this<region> {
    friend factory;
    friend frame;
 
public:
    explicit region(utils::control_block& block, manager& mgr, const region_core_attributes& attr);
 
    ~region() override;
 
    region(const region&) = delete;
 
    region(region&&) = delete;
 
    region& operator=(const region&) = delete;
 
    region& operator=(region&&) = delete;
 
    virtual void render() const;
 
    virtual void update(float delta);
 
    virtual std::string serialize(const std::string& tab) const;
 
    virtual void copy_from(const region& obj);
 
    virtual void notify_borders_need_update();
 
    virtual void notify_scaling_factor_updated();
 
    const std::string& get_name() const;
 
    const std::string& get_raw_name() const;
 
    utils::observer_ptr<const frame> get_parent() const {
        return parent_;
    }
 
    const utils::observer_ptr<frame>& get_parent() {
        return parent_;
    }
 
    virtual utils::owner_ptr<region> release_from_parent();
 
    void destroy();
 
    void set_alpha(float alpha);
 
    float get_alpha() const;
 
    float get_effective_alpha() const;
 
    void show();
 
    void hide();
 
    void set_shown(bool is_shown);
 
    bool is_shown() const;
 
    bool is_visible() const;
 
    bool is_valid() const;
 
    virtual void set_dimensions(const vector2f& dimensions);
 
    virtual void set_width(float abs_width);
 
    virtual void set_height(float abs_height);
 
    void set_relative_dimensions(const vector2f& dimensions);
 
    void set_relative_width(float rel_width);
 
    void set_relative_height(float rel_height);
 
    const vector2f& get_dimensions() const;
 
    vector2f get_apparent_dimensions() const;
 
    bool is_apparent_width_defined() const;
 
    bool is_apparent_height_defined() const;
 
    virtual bool is_in_region(const vector2f& position) const;
 
    const std::string& get_region_type() const;
 
    bool is_region_type(const std::string& type_name) const;
 
    template<typename ObjectType>
    bool is_region_type() const {
        return is_region_type(ObjectType::class_name);
    }
 
    bool is_region_type(const region& obj) const {
        return is_region_type(obj.get_region_type());
    }
 
    float get_bottom() const;
 
    vector2f get_center() const;
 
    float get_left() const;
 
    float get_right() const;
 
    float get_top() const;
 
    const bounds2f& get_borders() const;
 
    void clear_all_anchors();
 
    void set_all_anchors(const utils::observer_ptr<region>& obj);
 
    void set_all_anchors(const std::string& obj_name);
 
    void set_anchor(const anchor_data& a);
 
    template<typename... Args>
    void set_anchor(Args&&... args) {
        constexpr auto set_anchor_overload =
            static_cast<void (region::*)(const anchor_data&)>(&region::set_anchor);
        (this->*set_anchor_overload)(anchor_data{std::forward<Args>(args)...});
    }
 
    bool depends_on(const region& obj) const;
 
    std::size_t get_anchor_count() const;
 
    anchor& modify_anchor(point p);
 
    const anchor& get_anchor(point p) const;
 
    const std::array<std::optional<anchor>, 9>& get_anchors() const;
 
    float round_to_pixel(
        float value, utils::rounding_method method = utils::rounding_method::nearest) const;
 
    vector2f round_to_pixel(
        const vector2f&        position,
        utils::rounding_method method = utils::rounding_method::nearest) const;
 
    void add_anchored_object(region& obj);
 
    void remove_anchored_object(region& obj);
 
    bool is_virtual() const;
 
    void set_manually_inherited(bool manually_inherited);
 
    bool is_manually_inherited() const;
 
    virtual utils::observer_ptr<const frame_renderer> get_effective_frame_renderer() const;
 
    utils::observer_ptr<frame_renderer> get_effective_frame_renderer() {
        return utils::const_pointer_cast<frame_renderer>(
            const_cast<const region*>(this)->get_effective_frame_renderer());
    }
 
    virtual void notify_renderer_need_redraw();
 
    const std::vector<utils::observer_ptr<region>>& get_anchored_objects() const;
 
    virtual void notify_loaded();
 
    bool is_loaded() const;
 
    virtual void notify_visible();
 
    virtual void notify_invisible();
 
    void set_addon(const addon* a);
 
    const addon* get_addon() const;
 
    std::string parse_file_name(const std::string& file_name) const;
 
    manager& get_manager() {
        return manager_;
    }
 
    const manager& get_manager() const {
        return manager_;
    }
 
    registry& get_registry();
 
    const registry& get_registry() const;
 
    void remove_glue();
 
    virtual void parse_layout(const layout_node& node);
 
    static void register_on_lua(sol::state& lua);
 
    template<typename ObjectType>
    friend const ObjectType* down_cast(const region* self);
 
    template<typename ObjectType>
    friend ObjectType* down_cast(region* self);
 
    static constexpr const char* class_name = "Region";
 
protected:
    // Layout parsing
    virtual void                  parse_attributes_(const layout_node& node);
    virtual void                  parse_size_node_(const layout_node& node);
    virtual void                  parse_anchor_node_(const layout_node& node);
    color                         parse_color_node_(const layout_node& node);
    vector2<std::optional<float>> parse_offset_node_(const layout_node& node);
    vector2<float>                parse_offset_node_or_(const layout_node& node, float fallback);
 
    std::pair<anchor_type, vector2<std::optional<float>>>
    parse_dimension_node_(const layout_node& node);
 
    void read_anchors_(
        float& left, float& right, float& top, float& bottom, float& x_center, float& y_center)
        const;
 
    bool make_borders_(float& min, float& max, float center, float size) const;
 
    virtual void update_borders_();
 
    sol::state&       get_lua_();
    const sol::state& get_lua_() const;
 
    template<typename T>
    void create_glue_(T& self);
 
    template<typename T>
    static const std::vector<std::string>& get_type_list_impl_();
 
    virtual const std::vector<std::string>& get_type_list_() const;
 
    void        set_lua_member_(std::string key, sol::stack_object value);
    sol::object get_lua_member_(const std::string& key) const;
 
    void set_virtual_();
 
    void set_name_(const std::string& name);
 
    virtual void set_parent_(utils::observer_ptr<frame> parent);
 
    template<typename T>
    void initialize_(T& self, const region_core_attributes& attr);
 
    manager& manager_;
 
    const addon* addon_ = nullptr;
 
    std::string name_;
    std::string raw_name_;
 
    utils::observer_ptr<frame> parent_ = nullptr;
 
    bool is_manually_inherited_ = false;
    bool is_virtual_            = false;
    bool is_loaded_             = false;
    bool is_valid_              = true;
 
    std::array<std::optional<anchor>, 9> anchor_list_;
    bounds2<bool>                        defined_borders_;
    bounds2f                             borders_;
 
    float alpha_      = 1.0f;
    bool  is_shown_   = true;
    bool  is_visible_ = true;
 
    vector2f dimensions_;
 
    std::vector<utils::observer_ptr<region>> anchored_object_list_;
};
 
template<typename ObjectType>
const ObjectType* down_cast(const region* self) {
    const ObjectType* object = dynamic_cast<const ObjectType*>(self);
    if (self && !object && self->is_region_type(ObjectType::class_name)) {
        throw gui::exception(
            self->get_region_type(), "cannot use down_cast() to " +
                                         std::string(ObjectType::class_name) +
                                         " as object is being destroyed");
    }
    return object;
}
 
template<typename ObjectType>
const ObjectType& down_cast(const region& self) {
    const ObjectType* object = dynamic_cast<const ObjectType*>(self);
    if (!object) {
        if (self.is_region_type(ObjectType::class_name)) {
            throw gui::exception(
                self.get_region_type(), "cannot use down_cast() to " +
                                            std::string(ObjectType::class_name) +
                                            " as object is being destroyed");
        } else {
            throw gui::exception(
                self.get_region_type(), "cannot use down_cast() to " +
                                            std::string(ObjectType::class_name) +
                                            " as object is not of the right type");
        }
    }
    return *object;
}
 
template<typename ObjectType>
ObjectType* down_cast(region* self) {
    return const_cast<ObjectType*>(down_cast<ObjectType>(const_cast<const region*>(self)));
}
 
template<typename ObjectType>
ObjectType& down_cast(region& self) {
    return const_cast<ObjectType&>(down_cast<ObjectType>(const_cast<const region&>(self)));
}
 
template<typename ObjectType>
utils::owner_ptr<ObjectType> down_cast(utils::owner_ptr<region>&& object) {
    return utils::owner_ptr<ObjectType>(std::move(object), down_cast<ObjectType>(object.get()));
}
 
template<typename ObjectType>
utils::observer_ptr<ObjectType> down_cast(const utils::observer_ptr<region>& object) {
    return utils::observer_ptr<ObjectType>(object, down_cast<ObjectType>(object.get()));
}
 
template<typename ObjectType>
utils::observer_ptr<ObjectType> down_cast(utils::observer_ptr<region>&& object) {
    return utils::observer_ptr<ObjectType>(std::move(object), down_cast<ObjectType>(object.get()));
}
 
template<typename ObjectType>
utils::observer_ptr<ObjectType> observer_from(ObjectType* self) {
    if (self)
        return utils::static_pointer_cast<ObjectType>(self->region::observer_from_this());
    else
        return nullptr;
}
 
} // namespace lxgui::gui
 
#endif