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 "../GFX/gfx_device.hpp"
#include "../thread.hpp"
#include "../unfair_recursive_mutex.hpp"
#include "../event_queue.hpp"
#include <span>
#include <memory>
#include <mutex>
#include <thread>
#include <vector>
 
namespace tt {
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<tt::vertical_sync> vertical_sync;
    std::unique_ptr<tt::font_book> font_book;
    std::unique_ptr<tt::theme_book> theme_book;
    std::unique_ptr<tt::keyboard_bindings> keyboard_bindings;
 
 
    thread_id const thread_id;
 
    [[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);
    }
 
    virtual int loop() = 0;
 
    virtual void exit(int exit_code) = 0;
 
    tt::event_queue const &event_queue() const noexcept
    {
        return *_event_queue;
    }
 
    void run_from_event_queue(std::invocable auto &&function) noexcept
    {
        event_queue().emplace(std::forward<decltype(function)>(function));
    }
 
    void run(std::invocable auto &&function) noexcept
    {
        if (is_gui_thread()) {
            function();
        } else {
            run_from_event_queue(std::forward<decltype(function)>(function));
        }
    }
 
    gui_window &add_window(std::unique_ptr<gui_window> window);
 
    template<typename... Args>
    gui_window &make_window(Args &&...args)
    {
        tt_axiom(is_gui_thread());
 
        // XXX abstract away the _win32 part.
        auto window = std::make_unique<gui_window_win32>(*this, std::forward<Args>(args)...);
        window->init();
 
        return add_window(std::move(window));
    }
 
    ssize_t num_windows();
 
    void render(utc_nanoseconds display_time_point)
    {
        tt_axiom(is_gui_thread());
 
        for (auto &window : _windows) {
            window->render(display_time_point);
            if (window->is_closed()) {
                window->deinit();
                window = nullptr;
            }
        }
        std::erase(_windows, nullptr);
 
        ttlet num_windows = std::size(_windows);
        if (num_windows == 0 && num_windows != _previous_num_windows) {
            // If last_window_closed() creates a new window we should
            // let it do that before entering the event queue again.
            // win32 is a bit picky about running without windows.
            if (auto delegate = _delegate.lock()) {
                if (auto exit_code = delegate->last_window_closed(*this)) {
                    this->exit(*exit_code);
                }
            } else {
                this->exit(0);
            }
        }
        _previous_num_windows = num_windows;
    }
 
    [[nodiscard]] bool is_gui_thread() const noexcept
    {
        return thread_id == current_thread_id();
    }
 
    void set_theme(tt::theme const &new_theme) noexcept;
 
    tt::theme const &theme() const noexcept;
 
    void set_theme_mode(tt::theme_mode mode) noexcept;
 
    void request_constrain() noexcept;
 
protected:
    gui_system(
        std::shared_ptr<tt::event_queue> event_queue,
        std::unique_ptr<gfx_system> gfx,
        std::unique_ptr<tt::vertical_sync> vertical_sync,
        std::unique_ptr<tt::font_book> font_book,
        std::unique_ptr<tt::theme_book> theme_book,
        std::unique_ptr<tt::keyboard_bindings> keyboard_bindings,
        std::weak_ptr<gui_system_delegate> delegate = {}) noexcept;
 
    std::shared_ptr<tt::event_queue> _event_queue;
 
private:
    std::weak_ptr<gui_system_delegate> _delegate;
 
    std::vector<std::unique_ptr<gui_window>> _windows;
    size_t _previous_num_windows = 0;
 
    tt::theme const *_theme = nullptr;
};
 
} // namespace tt