keyboard_event.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 "keyboard_key.hpp"
#include "../text/grapheme.hpp"
#include "../required.hpp"
#include "../assert.hpp"
#include "../command.hpp"
#include "../geometry/transform.hpp"
#include <utility>
 
namespace tt {
 
enum class KeyboardState : uint8_t {
    Idle = 0x00,
    CapsLock = 0x01,
    ScrollLock = 0x02,
    NumLock = 0x04,
};
 
[[nodiscard]] constexpr KeyboardState operator|(KeyboardState lhs, KeyboardState rhs) noexcept {
    return static_cast<KeyboardState>(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
}
 
constexpr KeyboardState &operator|=(KeyboardState &lhs, KeyboardState rhs) noexcept {
    lhs = lhs | rhs;
    return lhs;
}
 
[[nodiscard]] constexpr bool operator>=(KeyboardState lhs, KeyboardState rhs) noexcept {
    ttlet lhs_ = static_cast<uint8_t>(lhs);
    ttlet rhs_ = static_cast<uint8_t>(rhs);
    return (lhs_ & rhs_) == rhs_;
}
 
 
struct keyboard_event {
    enum class Type : uint8_t {
        Idle,
        Partialgrapheme, 
        grapheme, 
        Key, 
    };
 
    Type type;
    KeyboardState state;
 
    tt::grapheme grapheme;
    keyboard_key key;
 
    keyboard_event(Type type=Type::Idle) noexcept :
        type(type), state(), grapheme(), key() {}
 
    keyboard_event(KeyboardState state, keyboard_modifiers modifiers, keyboard_virtual_key key) noexcept :
        type(Type::Key), state(state), grapheme(), key(modifiers, key) {}
 
    keyboard_event(tt::grapheme grapheme, bool full = true) noexcept :
        type(full ? Type::grapheme : Type::Partialgrapheme), state(), grapheme(std::move(grapheme)), key() {}
 
    [[nodiscard]] std::vector<command> const &getCommands() const noexcept;
 
    [[nodiscard]] friend std::string to_string(keyboard_event const &rhs) noexcept {
        auto r = std::string{"<keyboard_event "};
 
        switch (rhs.type) {
        case Type::Idle: r += "Idle"; break;
        case Type::Partialgrapheme: r += "Partialgrapheme="; break;
        case Type::grapheme: r += "grapheme="; break;
        case Type::Key: r += "Key="; break;
        default: tt_no_default();
        }
 
        if (rhs.type == Type::Partialgrapheme || rhs.type == Type::grapheme) {
            r += to_string(rhs.grapheme);
        } else if (rhs.type == Type::Key) {
            r += to_string(rhs.key);
        }
 
        r += ">";
        return r;
    }
 
    friend std::ostream &operator<<(std::ostream &lhs, keyboard_event const &rhs) {
        return lhs << to_string(rhs);
    }
};
 
}