gui_event.hpp

Go to the documentation of this file.

// Copyright Take Vos 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_event_type.hpp"
#include "gui_event_variant.hpp"
#include "keyboard_virtual_key.hpp"
#include "keyboard_state.hpp"
#include "keyboard_modifiers.hpp"
#include "keyboard_focus_group.hpp"
#include "keyboard_focus_direction.hpp"
#include "mouse_buttons.hpp"
#include "../unicode/grapheme.hpp"
#include "../geometry/vector.hpp"
#include "../geometry/point.hpp"
#include "../geometry/translate.hpp"
#include "../chrono.hpp"
#include <chrono>
#include <memory>
 
namespace hi { inline namespace v1 {
 
struct mouse_event_data {
    point2i position = {};
 
    point2i down_position = {};
 
    vector2i wheel_delta = {};
 
    mouse_buttons cause = {};
 
    mouse_buttons down = {};
 
    uint8_t click_count = 0;
};
 
class widget;
 
struct keyboard_target_data {
    hi::widget const *widget = nullptr;
    keyboard_focus_group group = keyboard_focus_group::normal;
    keyboard_focus_direction direction = keyboard_focus_direction::here;
};
 
class gui_event {
public:
    utc_nanoseconds time_point;
 
    keyboard_modifiers keyboard_modifiers;
 
    keyboard_state keyboard_state;
 
    constexpr gui_event(
        gui_event_type type,
        utc_nanoseconds time_point,
        hi::keyboard_modifiers keyboard_modifiers,
        hi::keyboard_state keyboard_state) noexcept :
        _type(gui_event_type::none),
        time_point(time_point),
        keyboard_modifiers(keyboard_modifiers),
        keyboard_state(keyboard_state)
    {
        set_type(type);
    }
 
    constexpr gui_event() noexcept :
        gui_event(gui_event_type::none, utc_nanoseconds{}, keyboard_modifiers::none, keyboard_state::idle)
    {
    }
 
    gui_event(gui_event_type type) noexcept :
        gui_event(type, std::chrono::utc_clock::now(), keyboard_modifiers::none, keyboard_state::idle)
    {
    }
 
    gui_event(gui_event_type type, aarectanglei rectangle) noexcept :
        gui_event(type, std::chrono::utc_clock::now(), keyboard_modifiers::none, keyboard_state::idle)
    {
        hi_assert(variant() == gui_event_variant::rectangle);
        this->rectangle() = rectangle;
    }
 
    gui_event(
        gui_event_type type,
        keyboard_virtual_key key,
        hi::keyboard_modifiers keyboard_modifiers = keyboard_modifiers::none,
        hi::keyboard_state keyboard_state = keyboard_state::idle) noexcept :
        gui_event(type, std::chrono::utc_clock::now(), keyboard_modifiers, keyboard_state)
    {
        hi_assert(variant() == gui_event_variant::keyboard);
        this->key() = key;
    }
 
    constexpr ~gui_event() = default;
    constexpr gui_event(gui_event const&) noexcept = default;
    constexpr gui_event(gui_event&&) noexcept = default;
    constexpr gui_event& operator=(gui_event const&) noexcept = default;
    constexpr gui_event& operator=(gui_event&&) noexcept = default;
 
    [[nodiscard]] static gui_event make_mouse_enter(point2i position) noexcept
    {
        auto r = gui_event{gui_event_type::mouse_enter};
        r.mouse().position = position;
        return r;
    }
 
    [[nodiscard]] static gui_event keyboard_grapheme(hi::grapheme grapheme) noexcept
    {
        auto r = gui_event{gui_event_type::keyboard_grapheme};
        r.grapheme() = grapheme;
        return r;
    }
 
    [[nodiscard]] static gui_event keyboard_partial_grapheme(hi::grapheme grapheme) noexcept
    {
        auto r = gui_event{gui_event_type::keyboard_partial_grapheme};
        r.grapheme() = grapheme;
        return r;
    }
 
    [[nodiscard]] static gui_event window_set_keyboard_target(
        widget const *widget,
        keyboard_focus_group group = keyboard_focus_group::normal,
        keyboard_focus_direction direction = keyboard_focus_direction::here) noexcept
    {
        auto r = gui_event{gui_event_type::window_set_keyboard_target};
        r.keyboard_target().widget = widget;
        r.keyboard_target().group = group;
        r.keyboard_target().direction = direction;
        return r;
    }
 
    [[nodiscard]] static gui_event make_clipboard_event(gui_event_type type, std::string_view text) noexcept
    {
        auto r = gui_event{type};
        r.clipboard_data() = text;
        return r;
    }
 
    [[nodiscard]] constexpr gui_event_type type() const noexcept
    {
        return _type;
    }
 
    [[nodiscard]] constexpr void set_type(gui_event_type type) noexcept
    {
        hilet previous_variant = variant();
 
        _type = type;
        if (previous_variant != variant()) {
            switch (variant()) {
            case gui_event_variant::mouse:
                _data = mouse_event_data{};
                break;
            case gui_event_variant::grapheme:
                _data = hi::grapheme{};
                break;
            case gui_event_variant::keyboard:
                _data = keyboard_virtual_key{};
                break;
            case gui_event_variant::keyboard_target:
                _data = keyboard_target_data{};
                break;
            case gui_event_variant::rectangle:
                _data = aarectanglei{};
                break;
            case gui_event_variant::clipboard_data:
                _data = std::string{};
            default:;
            }
        }
    }
 
    [[nodiscard]] mouse_event_data& mouse() noexcept
    {
        hi_assert(variant() == gui_event_variant::mouse);
        return std::get<mouse_event_data>(_data);
    }
 
    [[nodiscard]] mouse_event_data const& mouse() const noexcept
    {
        hi_assert(variant() == gui_event_variant::mouse);
        return std::get<mouse_event_data>(_data);
    }
 
    [[nodiscard]] keyboard_virtual_key& key() noexcept
    {
        hi_assert(variant() == gui_event_variant::keyboard);
        return std::get<keyboard_virtual_key>(_data);
    }
 
    [[nodiscard]] keyboard_virtual_key const& key() const noexcept
    {
        hi_assert(variant() == gui_event_variant::keyboard);
        return std::get<keyboard_virtual_key>(_data);
    }
 
    [[nodiscard]] hi::grapheme& grapheme() noexcept
    {
        hi_assert(variant() == gui_event_variant::grapheme);
        return std::get<hi::grapheme>(_data);
    }
 
    [[nodiscard]] hi::grapheme const& grapheme() const noexcept
    {
        hi_assert(variant() == gui_event_variant::grapheme);
        return std::get<hi::grapheme>(_data);
    }
 
    [[nodiscard]] aarectanglei& rectangle() noexcept
    {
        hi_assert(variant() == gui_event_variant::rectangle);
        return std::get<aarectanglei>(_data);
    }
 
    [[nodiscard]] aarectanglei const& rectangle() const noexcept
    {
        hi_assert(variant() == gui_event_variant::rectangle);
        return std::get<aarectanglei>(_data);
    }
 
    [[nodiscard]] keyboard_target_data& keyboard_target() noexcept
    {
        hi_assert(variant() == gui_event_variant::keyboard_target);
        return std::get<keyboard_target_data>(_data);
    }
 
    [[nodiscard]] keyboard_target_data const& keyboard_target() const noexcept
    {
        hi_assert(variant() == gui_event_variant::keyboard_target);
        return std::get<keyboard_target_data>(_data);
    }
 
    [[nodiscard]] std::string& clipboard_data() noexcept
    {
        hi_assert(variant() == gui_event_variant::clipboard_data);
        return std::get<std::string>(_data);
    }
 
    [[nodiscard]] std::string const& clipboard_data() const noexcept
    {
        hi_assert(variant() == gui_event_variant::clipboard_data);
        return std::get<std::string>(_data);
    }
 
    [[nodiscard]] constexpr bool operator==(gui_event_type event_type) const noexcept
    {
        return type() == event_type;
    }
 
    [[nodiscard]] constexpr bool operator==(gui_event_variant event_variant) const noexcept
    {
        return variant() == event_variant;
    }
 
    [[nodiscard]] constexpr bool empty() const noexcept
    {
        return type() == gui_event_type::none;
    }
 
    constexpr operator bool() const noexcept
    {
        return not empty();
    }
 
    [[nodiscard]] constexpr gui_event_variant variant() const noexcept
    {
        return to_gui_event_variant(type());
    }
 
    [[nodiscard]] constexpr bool is_left_button_up(aarectanglei active_area) const noexcept
    {
        using enum gui_event_type;
        return type() == mouse_up and mouse().cause.left_button and active_area.contains(mouse().position);
    }
 
    [[nodiscard]] constexpr vector2i drag_delta() const noexcept
    {
        using enum gui_event_type;
        return type() == mouse_drag ? mouse().position - mouse().down_position : vector2i{};
    }
 
    [[nodiscard]] constexpr friend gui_event operator*(translate2i const& transform, gui_event const& rhs) noexcept
    {
        auto r = rhs;
        if (rhs == gui_event_variant::mouse) {
            r.mouse().position = transform * rhs.mouse().position;
            r.mouse().down_position = transform * rhs.mouse().down_position;
        }
        return r;
    }
 
private:
    using data_type =
        std::variant<mouse_event_data, keyboard_virtual_key, keyboard_target_data, hi::grapheme, aarectanglei, std::string>;
 
    gui_event_type _type;
    data_type _data;
};
 
}} // namespace hi::v1
 
template<typename CharT>
struct std::formatter<hi::gui_event, CharT> : std::formatter<std::string_view, CharT> {
    auto format(hi::gui_event const& t, auto& fc)
    {
        return std::formatter<std::string_view, CharT>::format(hi::gui_event_type_metadata[t.type()], fc);
    }
};