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_size.hpp"
#include "gui_window_delegate.hpp"
#include "mouse_cursor.hpp"
#include "hitbox.hpp"
#include "mouse_event.hpp"
#include "keyboard_event.hpp"
#include "keyboard_focus_direction.hpp"
#include "keyboard_focus_group.hpp"
#include "theme.hpp"
#include "../GFX/subpixel_orientation.hpp"
#include "../geometry/axis_aligned_rectangle.hpp"
#include "../widgets/window_widget.hpp"
#include "../widgets/grid_widget.hpp"
#include "../widgets/toolbar_widget.hpp"
#include "../chrono.hpp"
#include "../label.hpp"
#include "../animator.hpp"
#include <unordered_set>
#include <memory>
#include <mutex>
 
namespace hi::inline v1 {
class gfx_device;
class gfx_system;
class gfx_surface;
class gui_system;
class keyboard_bindings;
 
class gui_window {
public:
    using delegate_type = gui_window_delegate;
 
    gui_system &gui;
 
    std::unique_ptr<gfx_surface> surface;
 
    aarectangle rectangle;
 
    mouse_cursor current_mouse_cursor = mouse_cursor::None;
 
    bool resizing = false;
 
    bool active = false;
 
    label title;
 
    float dpi = 72.0;
 
    hi::theme theme = {};
 
    extent2 widget_size;
 
    std::unique_ptr<window_widget> widget;
 
    notifier<void()> closing;
 
    gui_window(gui_system &gui, label const &title, std::weak_ptr<delegate_type> delegate = {}) noexcept;
 
    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();
 
    [[nodiscard]] bool is_gui_thread() const noexcept;
 
    void set_device(gfx_device *device) noexcept;
 
    hi::keyboard_bindings const &keyboard_bindings() const noexcept;
 
    void request_redraw(aarectangle redraw_rectangle) noexcept
    {
        _redraw_rectangle |= redraw_rectangle;
    }
 
    void request_redraw() noexcept
    {
        hi_axiom(is_gui_thread());
        request_redraw(aarectangle{rectangle.size()});
    }
 
    void request_relayout() noexcept
    {
        _relayout.store(true, std::memory_order::relaxed);
    }
 
    void request_reconstrain() noexcept
    {
        _reconstrain.store(true, std::memory_order::relaxed);
    }
 
    void request_resize() noexcept
    {
        _resize.store(true, std::memory_order::relaxed);
    }
 
    virtual void render(utc_nanoseconds displayTimePoint);
 
    [[nodiscard]] grid_widget &content() noexcept
    {
        hi_axiom(is_gui_thread());
        hi_axiom(widget);
        return widget->content();
    }
 
    [[nodiscard]] toolbar_widget &toolbar() noexcept
    {
        hi_axiom(is_gui_thread());
        hi_axiom(widget);
        return widget->toolbar();
    }
 
    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 set_size_state(gui_window_size state) noexcept = 0;
 
    virtual aarectangle workspace_rectangle() const noexcept = 0;
 
    virtual aarectangle fullscreen_rectangle() const noexcept = 0;
 
    virtual hi::subpixel_orientation subpixel_orientation() const noexcept = 0;
 
    gui_window_size size_state() const noexcept
    {
        return _size_state;
    }
 
    virtual void open_system_menu() = 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(hi::widget const *new_target_widget, point2 position = {}) noexcept;
 
    void update_keyboard_target(hi::widget const *widget, keyboard_focus_group group = keyboard_focus_group::normal) noexcept;
 
    void
    update_keyboard_target(hi::widget const *widget, keyboard_focus_group group, keyboard_focus_direction direction) noexcept;
 
    void update_keyboard_target(keyboard_focus_group group, keyboard_focus_direction direction) noexcept;
 
    [[nodiscard]] translate2 window_to_screen() const noexcept
    {
        return translate2{rectangle.left(), rectangle.bottom()};
    }
 
    [[nodiscard]] translate2 screen_to_window() const noexcept
    {
        return ~window_to_screen();
    }
 
protected:
    static constexpr std::chrono::nanoseconds _animation_duration = std::chrono::milliseconds(150);
 
    std::weak_ptr<delegate_type> _delegate;
 
    std::atomic<aarectangle> _redraw_rectangle = aarectangle{};
    std::atomic<bool> _relayout = true;
    std::atomic<bool> _reconstrain = true;
    std::atomic<bool> _resize = true;
 
    gui_window_size _size_state = gui_window_size::normal;
 
    aarectangle _restore_rectangle;
 
    utc_nanoseconds last_forced_redraw = {};
 
    animator<float> _animated_active = _animation_duration;
 
    virtual void create_window(extent2 new_size) = 0;
 
    [[nodiscard]] virtual bool handle_event(hi::command command) noexcept;
 
    [[nodiscard]] virtual bool handle_event(std::vector<hi::command> const &commands) noexcept
    {
        for (hilet 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;
 
private:
    notifier<>::token_type _setting_change_token;
    observable<std::string>::token_type _selected_theme_token;
 
    hi::widget const *_mouse_target_widget = nullptr;
 
    hi::widget const *_keyboard_target_widget = nullptr;
 
    void widget_is_destructing(hi::widget const *sender) noexcept
    {
        if (_mouse_target_widget == sender) {
            _mouse_target_widget = nullptr;
        }
        if (_keyboard_target_widget == sender) {
            _keyboard_target_widget = nullptr;
        }
    }
 
    template<typename Event>
    bool send_event_to_widget(hi::widget const *target_widget, Event const &event) noexcept;
 
    friend class widget;
};
 
} // namespace hi::inline v1