gui_window.hpp

// Copyright Take Vos 2019-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_state.hpp"
#include "gui_window_size.hpp"
#include "gui_window_delegate.hpp"
#include "gui_system_globals.hpp"
#include "mouse_cursor.hpp"
#include "hit_box.hpp"
#include "mouse_event.hpp"
#include "keyboard_event.hpp"
#include "subpixel_orientation.hpp"
#include "keyboard_focus_direction.hpp"
#include "keyboard_focus_group.hpp"
#include "../text/gstring.hpp"
#include "../logger.hpp"
#include "../geometry/axis_aligned_rectangle.hpp"
#include "../cpu_utc_clock.hpp"
#include "../label.hpp"
#include <unordered_set>
#include <memory>
#include <mutex>
 
namespace tt {
class gui_device;
class gui_system;
class window_widget;
 
class gui_window {
public:
    gui_system &system;
 
    gui_window_state state = gui_window_state::no_device;
 
    mouse_cursor currentmouse_cursor = mouse_cursor::None;
 
    std::atomic<bool> requestLayout = true;
 
    std::atomic<bool> requestResize = true;
 
    std::atomic<bool> resizing = false;
 
    std::atomic<bool> active = false;
 
    gui_window_size size_state = gui_window_size::normal;
 
    extent2 extent;
 
    std::weak_ptr<gui_window_delegate> delegate;
 
    label title;
 
    subpixel_orientation subpixel_orientation = subpixel_orientation::BlueRight;
 
    float dpi = 72.0;
 
    std::shared_ptr<window_widget> widget;
 
    gui_window(gui_system &system, std::weak_ptr<gui_window_delegate> const &delegate, label const &title);
    virtual ~gui_window();
 
    gui_window(gui_window const &) = delete;
    gui_window &operator=(gui_window const &) = delete;
    gui_window(gui_window &&) = delete;
    gui_window &operator=(gui_window &&) = delete;
 
    virtual void init();
 
    void request_redraw(aarectangle rectangle) noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        _request_redraw_rectangle |= rectangle;
    }
 
    void request_redraw() noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        request_redraw(aarectangle{extent});
    }
 
    [[nodiscard]] float fontScale() const noexcept
    {
        return dpi / (window_scale() * 72.0f);
    }
 
    void set_device(gui_device *device);
 
    void unset_device()
    {
        set_device({});
    }
 
    gui_device *device() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _device;
    }
 
    virtual void render(hires_utc_clock::time_point displayTimePoint) = 0;
 
    bool is_closed();
 
    template<typename T, typename... Args>
    std::shared_ptr<T> make_widget(size_t column_nr, size_t row_nr, Args &&...args);
 
    template<typename T, typename... Args>
    std::shared_ptr<T> make_widget(std::string_view address, Args &&...args);
 
    template<typename T, horizontal_alignment Alignment = horizontal_alignment::left, typename... Args>
    std::shared_ptr<T> make_toolbar_widget(Args &&...args);
 
    virtual void set_cursor(mouse_cursor cursor) = 0;
 
    void set_resize_border_priority(bool left, bool right, bool bottom, bool top) noexcept;
 
    virtual void close_window() = 0;
 
    virtual void minimize_window() = 0;
 
    virtual void maximize_window() = 0;
 
    virtual void normalize_window() = 0;
 
    virtual void set_window_size(extent2 extent) = 0;
 
    [[nodiscard]] virtual std::string get_text_from_clipboard() const noexcept = 0;
 
    virtual void set_text_on_clipboard(std::string str) noexcept = 0;
 
    void update_mouse_target(std::shared_ptr<tt::widget> new_target_widget, point2 position = {}) noexcept;
 
    void update_keyboard_target(
        std::shared_ptr<tt::widget> widget,
        keyboard_focus_group group = keyboard_focus_group::normal) noexcept;
 
    void update_keyboard_target(
        std::shared_ptr<tt::widget> const &widget,
        keyboard_focus_group group,
        keyboard_focus_direction direction) noexcept;
 
    [[nodiscard]] virtual extent2 virtual_screen_size() const noexcept = 0;
 
    [[nodiscard]] translate2 window_to_screen() const noexcept
    {
        return translate2{_screen_rectangle.left(), _screen_rectangle.bottom()};
    }
 
    [[nodiscard]] translate2 screen_to_window() const noexcept
    {
        return ~window_to_screen();
    }
 
protected:
    gui_device *_device = nullptr;
 
    aarectangle _screen_rectangle;
 
    bool _request_setting_change = true;
 
    aarectangle _request_redraw_rectangle = aarectangle{};
 
    virtual void create_window(const std::u8string &title, extent2 extent) = 0;
 
    [[nodiscard]] float window_scale() const noexcept;
 
    virtual void window_changed_size(extent2 new_extent);
 
    virtual void teardown() = 0;
 
    virtual void build() = 0;
 
    [[nodiscard]] virtual bool handle_event(tt::command command) noexcept;
 
    [[nodiscard]] virtual bool handle_event(std::vector<tt::command> const &commands) noexcept
    {
        for (ttlet command : commands) {
            if (handle_event(command)) {
                return true;
            }
        }
        return false;
    }
 
    [[nodiscard]] virtual bool handle_event(mouse_event const &event) noexcept
    {
        return false;
    }
 
    [[nodiscard]] virtual bool handle_event(keyboard_event const &event) noexcept
    {
        return false;
    }
 
    bool send_event(mouse_event const &event) noexcept;
 
    bool send_event(keyboard_event const &event) noexcept;
 
    bool send_event(KeyboardState _state, keyboard_modifiers modifiers, keyboard_virtual_key key) noexcept;
 
    bool send_event(grapheme grapheme, bool full = true) noexcept;
 
    bool send_event(char32_t c, bool full = true) noexcept;
 
private:
    std::weak_ptr<tt::widget> _mouse_target_widget = {};
 
    std::weak_ptr<tt::widget> _keyboard_target_widget = {};
 
    template<typename Event>
    bool send_event_to_widget(std::shared_ptr<tt::widget> target_widget, Event const &event) noexcept;
};
 
} // namespace tt