gui_manager.hpp

#ifndef LXGUI_GUI_MANAGER_HPP
#define LXGUI_GUI_MANAGER_HPP
 
#include "lxgui/input_keys.hpp"
#include "lxgui/lxgui.hpp"
#include "lxgui/utils_observer.hpp"
#include "lxgui/utils_signal.hpp"
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace sol {
 
class state;
 
}
namespace lxgui::input {
 
class source;
class window;
class dispatcher;
class world_dispatcher;
 
} // namespace lxgui::input
 
namespace lxgui::gui {
 
class renderer;
class localizer;
class factory;
class root;
class virtual_root;
class addon_registry;
class event_emitter;
 
class manager : utils::enable_observer_from_this<manager> {
public:
    manager(
        utils::control_block&          block,
        std::unique_ptr<input::source> src,
        std::unique_ptr<renderer>      rdr);
 
    ~manager() override;
 
    // Non-copiable, non-movable
    manager(const manager&) = delete;
    manager(manager&&)      = delete;
    manager& operator=(const manager&) = delete;
    manager& operator=(manager&&) = delete;
 
    void set_interface_scaling_factor(float scaling_factor);
 
    float get_interface_scaling_factor() const;
 
    void enable_caching(bool enable_caching);
 
    void toggle_caching();
 
    bool is_caching_enabled() const;
 
    void add_addon_directory(const std::string& directory);
 
    void clear_addon_directory_list();
 
    void add_localization_directory(const std::string& directory);
 
    void clear_localization_directory_list();
 
    utils::signal<void(sol::state&)> on_create_lua;
 
    std::string print_ui() const;
 
    void load_ui();
 
    void close_ui();
 
    void close_ui_now();
 
    void reload_ui();
 
    void reload_ui_now();
 
    bool is_loaded() const;
 
    void render_ui() const;
 
    void update_ui(float delta);
 
    sol::state& get_lua();
 
    const sol::state& get_lua() const;
 
    const renderer& get_renderer() const {
        return *renderer_;
    }
 
    renderer& get_renderer() {
        return *renderer_;
    }
 
    const input::window& get_window() const {
        return *window_;
    }
 
    input::window& get_window() {
        return *window_;
    }
 
    const input::dispatcher& get_input_dispatcher() const {
        return *input_dispatcher_;
    }
 
    input::dispatcher& get_input_dispatcher() {
        return *input_dispatcher_;
    }
 
    const input::world_dispatcher& get_world_input_dispatcher() const {
        return *world_input_dispatcher_;
    }
 
    input::world_dispatcher& get_world_input_dispatcher() {
        return *world_input_dispatcher_;
    }
 
    const event_emitter& get_event_emitter() const {
        return *event_emitter_;
    }
 
    event_emitter& get_event_emitter() {
        return *event_emitter_;
    }
 
    localizer& get_localizer() {
        return *localizer_;
    }
 
    const localizer& get_localizer() const {
        return *localizer_;
    }
 
    root& get_root() {
        return *root_;
    }
 
    const root& get_root() const {
        return *root_;
    }
 
    virtual_root& get_virtual_root() {
        return *virtual_root_;
    }
 
    const virtual_root& get_virtual_root() const {
        return *virtual_root_;
    }
 
    factory& get_factory() {
        return *factory_;
    }
 
    const factory& get_factory() const {
        return *factory_;
    }
 
    addon_registry* get_addon_registry() {
        return addon_registry_.get();
    }
 
    const addon_registry* get_addon_registry() const {
        return addon_registry_.get();
    }
 
private:
    void create_lua_();
 
    void read_files_();
 
    // Persistent state
    float                    scaling_factor_      = 1.0f;
    float                    base_scaling_factor_ = 1.0f;
    bool                     enable_caching_      = false;
    std::vector<std::string> localization_directory_list_;
    std::vector<std::string> gui_directory_list_;
 
    // Implementations
    std::unique_ptr<input::source> input_source_;
    std::unique_ptr<renderer>      renderer_;
 
    // IO
    std::unique_ptr<input::window>           window_;
    std::unique_ptr<input::dispatcher>       input_dispatcher_;
    std::unique_ptr<input::world_dispatcher> world_input_dispatcher_;
    std::unique_ptr<event_emitter>           event_emitter_;
 
    // UI state
    std::unique_ptr<factory>        factory_;
    std::unique_ptr<localizer>      localizer_;
    std::unique_ptr<sol::state>     lua_;
    utils::owner_ptr<root>          root_;
    utils::owner_ptr<virtual_root>  virtual_root_;
    std::unique_ptr<addon_registry> addon_registry_;
 
    bool is_loaded_          = false;
    bool reload_ui_flag_     = false;
    bool close_ui_flag_      = false;
    bool is_first_iteration_ = true;
};
 
} // namespace lxgui::gui
 
#endif