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 "mouse_buttons.hpp"
#include "../unicode/grapheme.hpp"
#include "../geometry/vector.hpp"
#include "../geometry/point.hpp"
#include "../geometry/transform.hpp"
#include "../chrono.hpp"
#include <chrono>
 
namespace hi { inline namespace v1 {
 
struct mouse_event_data {
    point2 position = {};
 
    point2 down_position = {};
 
    vector2 wheel_delta = {};
 
    mouse_buttons cause = {};
 
    mouse_buttons down = {};
 
    uint8_t click_count = 0;
};
 
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, hi::grapheme grapheme) noexcept :
        gui_event(type, std::chrono::utc_clock::now(), keyboard_modifiers::none, keyboard_state::idle)
    {
        hi_axiom(variant() == gui_event_variant::grapheme);
        this->grapheme() = grapheme;
    }
 
    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_axiom(variant() == gui_event_variant::keyboard);
        this->key() = key;
    }
 
    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(point2 position) noexcept
    {
        auto r = gui_event{gui_event_type::mouse_enter};
        r.mouse().position = position;
        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:
                _mouse = {};
                break;
            case gui_event_variant::grapheme:
                _grapheme = hi::grapheme{};
                break;
            case gui_event_variant::keyboard:
                _key = {};
                break;
            default:;
            }
        }
    }
 
    [[nodiscard]] mouse_event_data& mouse() noexcept
    {
        hi_axiom(variant() == gui_event_variant::mouse);
        return _mouse;
    }
 
    [[nodiscard]] mouse_event_data const& mouse() const noexcept
    {
        hi_axiom(variant() == gui_event_variant::mouse);
        return _mouse;
    }
 
    [[nodiscard]] keyboard_virtual_key& key() noexcept
    {
        hi_axiom(variant() == gui_event_variant::keyboard);
        return _key;
    }
 
    [[nodiscard]] keyboard_virtual_key const& key() const noexcept
    {
        hi_axiom(variant() == gui_event_variant::keyboard);
        return _key;
    }
 
    [[nodiscard]] hi::grapheme& grapheme() noexcept
    {
        hi_axiom(variant() == gui_event_variant::grapheme);
        return _grapheme;
    }
 
    [[nodiscard]] hi::grapheme const& grapheme() const noexcept
    {
        hi_axiom(variant() == gui_event_variant::grapheme);
        return _grapheme;
    }
 
    [[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(aarectangle 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 vector2 drag_delta() const noexcept
    {
        using enum gui_event_type;
        return type() == mouse_drag ? mouse().position - mouse().down_position : vector2{};
    }
 
    [[nodiscard]] constexpr friend gui_event operator*(geo::transformer auto const& transform, gui_event const& rhs) noexcept
    {
        auto r = rhs;
        if (rhs == gui_event_variant::mouse) {
            r.mouse().position = point2{transform * rhs.mouse().position};
            r.mouse().down_position = point2{transform * rhs.mouse().down_position};
            r.mouse().wheel_delta = vector2{transform * rhs.mouse().wheel_delta};
        }
        return r;
    }
 
private:
    gui_event_type _type;
 
    union {
        mouse_event_data _mouse;
        keyboard_virtual_key _key;
        hi::grapheme _grapheme;
    };
};
 
}} // namespace hi::inline 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);
    }
};