gui_system.hpp

// Copyright Take Vos 2020, 2021.
// 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 "../unicode/unicode_bidi_class.hpp"
#include "../GFX/gfx_device.hpp"
#include "../thread.hpp"
#include "../unfair_recursive_mutex.hpp"
#include "../observable.hpp"
#include <span>
#include <memory>
#include <mutex>
#include <thread>
#include <vector>
 
namespace hi::inline v1 {
class gfx_system;
class vertical_sync;
class font_book;
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::font_book> font_book;
    std::unique_ptr<hi::theme_book> theme_book;
    std::unique_ptr<hi::keyboard_bindings> keyboard_bindings;
 
    thread_id const thread_id;
 
    unicode_bidi_class writing_direction = unicode_bidi_class::L;
 
    observable<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);
 
    template<typename... Args>
    std::shared_ptr<gui_window> make_window(Args &&...args)
    {
        hi_axiom(is_gui_thread());
 
        // XXX abstract away the _win32 part.
        auto window = std::make_shared<gui_window_win32>(*this, std::forward<Args>(args)...);
        window->init();
 
        return add_window(std::move(window));
    }
 
    [[nodiscard]] bool is_gui_thread() const noexcept
    {
        return thread_id == current_thread_id();
    }
 
    void request_reconstrain() noexcept;
 
protected:
    gui_system(
        std::unique_ptr<gfx_system> gfx,
        std::unique_ptr<hi::font_book> font_book,
        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