gui_factory.hpp

#ifndef LXGUI_GUI_FACTORY_HPP
#define LXGUI_GUI_FACTORY_HPP
 
#include "lxgui/lxgui.hpp"
#include "lxgui/utils_observer.hpp"
 
#include <functional>
#include <string>
#include <unordered_map>
 
namespace sol {
 
class state;
 
}
namespace lxgui::gui {
 
class region;
struct region_core_attributes;
struct frame_core_attributes;
class layered_region;
class frame;
class registry;
class frame_renderer;
class manager;
 
class factory {
private:
    template<typename T>
    static utils::owner_ptr<region>
    create_new_object(manager& mgr, const region_core_attributes& attr) {
        return utils::make_owned<T>(mgr, attr);
    }
 
    template<typename T>
    static utils::owner_ptr<frame>
    create_new_frame(manager& mgr, const frame_core_attributes& attr) {
        return utils::make_owned<T>(mgr, attr);
    }
 
    template<typename T>
    static utils::owner_ptr<layered_region>
    create_new_layered_region(manager& mgr, const region_core_attributes& attr) {
        return utils::make_owned<T>(mgr, attr);
    }
 
public:
    explicit factory(manager& mgr);
 
    // Non-copiable, non-movable
    factory(const factory&) = delete;
    factory(factory&&)      = delete;
    factory& operator=(const factory&) = delete;
    factory& operator=(factory&&) = delete;
 
    utils::owner_ptr<region> create_region(registry& reg, const region_core_attributes& attr);
 
    utils::owner_ptr<frame> create_frame(registry& reg, const frame_core_attributes& attr);
 
    utils::owner_ptr<layered_region>
    create_layered_region(registry& reg, const region_core_attributes& attr);
 
    template<
        typename ObjectType,
        typename Enable =
            typename std::enable_if<std::is_base_of<gui::region, ObjectType>::value>::type>
    void register_region_type() {
        if constexpr (std::is_base_of_v<gui::layered_region, ObjectType>) {
            custom_region_list_[ObjectType::class_name] = &create_new_layered_region<ObjectType>;
        } else if constexpr (std::is_base_of_v<gui::frame, ObjectType>) {
            custom_frame_list_[ObjectType::class_name] = &create_new_frame<ObjectType>;
        } else {
            custom_object_list_[ObjectType::class_name] = &create_new_object<ObjectType>;
        }
 
        custom_lua_regs_[ObjectType::class_name] = &ObjectType::register_on_lua;
    }
 
    template<
        typename ObjectType,
        typename FunctionType,
        typename Enable =
            typename std::enable_if<std::is_base_of<gui::region, ObjectType>::value>::type>
    void register_region_type(FunctionType&& factory_func) {
        if constexpr (std::is_base_of_v<gui::layered_region, ObjectType>) {
            custom_region_list_[ObjectType::class_name] =
                [factory_func =
                     std::move(factory_func)](manager& mgr, const region_core_attributes& attr) {
                    return factory_func(mgr, attr);
                };
        } else if constexpr (std::is_base_of_v<gui::frame, ObjectType>) {
            custom_frame_list_[ObjectType::class_name] =
                [factory_func =
                     std::move(factory_func)](manager& mgr, const frame_core_attributes& attr) {
                    return factory_func(mgr, attr);
                };
        } else {
            custom_object_list_[ObjectType::class_name] =
                [factory_func =
                     std::move(factory_func)](manager& mgr, const region_core_attributes& attr) {
                    return factory_func(mgr, attr);
                };
        }
 
        custom_lua_regs_[ObjectType::class_name] = &ObjectType::register_on_lua;
    }
 
    void register_on_lua(sol::state& lua);
 
private:
    bool finalize_object_(registry& reg, region& object, const region_core_attributes& attr);
 
    void apply_inheritance_(region& object, const region_core_attributes& attr);
 
    manager& manager_;
 
    template<typename T>
    using string_map = std::unordered_map<std::string, T>;
 
    string_map<std::function<utils::owner_ptr<region>(manager&, const region_core_attributes&)>>
        custom_object_list_;
 
    string_map<std::function<utils::owner_ptr<frame>(manager&, const frame_core_attributes&)>>
        custom_frame_list_;
 
    string_map<
        std::function<utils::owner_ptr<layered_region>(manager&, const region_core_attributes&)>>
        custom_region_list_;
 
    string_map<std::function<void(sol::state&)>> custom_lua_regs_;
};
 
} // namespace lxgui::gui
 
#endif