gui_system.hpp

// Copyright Take Vos 2020-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "gui_window.hpp"
#include "gui_window_win32.hpp"
#include "gui_system_delegate.hpp"
#include "widget_intf.hpp"
#include "../unicode/module.hpp"
#include "../GFX/module.hpp"
#include "../utility/module.hpp"
#include "../observer/module.hpp"
#include <span>
#include <memory>
#include <mutex>
#include <thread>
#include <vector>
#include <concepts>
#include <utility>
 
namespace hi::inline v1 {
class gfx_system;
class vertical_sync;
class theme_book;
class keyboard_bindings;
 
class gui_system {
public:
    static inline os_handle instance;
 
    std::unique_ptr<gfx_system> gfx;
    std::unique_ptr<hi::theme_book> theme_book;
    std::unique_ptr<hi::keyboard_bindings> keyboard_bindings;
 
    thread_id const thread_id;
 
    observer<std::string> selected_theme = "default";
 
    [[nodiscard]] static std::unique_ptr<gui_system> make_unique(std::weak_ptr<gui_system_delegate> delegate = {}) noexcept;
 
    virtual ~gui_system();
 
    gui_system(const gui_system&) = delete;
    gui_system& operator=(const gui_system&) = delete;
    gui_system(gui_system&&) = delete;
    gui_system& operator=(gui_system&&) = delete;
 
    virtual void init() noexcept
    {
        if (auto delegate = _delegate.lock()) {
            delegate->init(*this);
        }
    }
 
    virtual void deinit() noexcept
    {
        if (auto delegate = _delegate.lock()) {
            delegate->deinit(*this);
        }
    }
 
    void set_delegate(std::weak_ptr<gui_system_delegate> delegate) noexcept
    {
        _delegate = std::move(delegate);
    }
 
    std::shared_ptr<gui_window> add_window(std::shared_ptr<gui_window> window);
 
    [[nodiscard]] std::shared_ptr<gui_window> make_window_with_widget(std::unique_ptr<widget_intf> widget)
    {
        hi_axiom(loop::main().on_thread());
 
        // XXX abstract away the _win32 part.
        return add_window(std::make_shared<gui_window_win32>(*this, std::move(widget)));
    }
 
    template<std::derived_from<widget_intf> Widget, typename... Args>
    [[nodiscard]] std::pair<std::shared_ptr<gui_window>, Widget&> make_window(Args&&...args)
    {
        auto widget = std::make_unique<Widget>(std::forward<Args>(args)...);
        auto& widget_ref = *widget;
 
        return {make_window_with_widget(std::move(widget)), widget_ref};
    }
 
    void request_reconstrain() noexcept;
 
protected:
    gui_system(
        std::unique_ptr<gfx_system> gfx,
        std::unique_ptr<hi::theme_book> theme_book,
        std::unique_ptr<hi::keyboard_bindings> keyboard_bindings,
        std::weak_ptr<gui_system_delegate> delegate = {}) noexcept;
 
private:
    std::weak_ptr<gui_system_delegate> _delegate;
 
    hi::theme const *_theme = nullptr;
};
 
} // namespace hi::inline v1