keyboard_modifiers.hpp

// Copyright Take Vos 2020-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 "../utility/utility.hpp"
#include "../algorithm/algorithm.hpp"
#include "../macros.hpp"
#include <cstdint>
#include <utility>
#include <format>
#include <string_view>
#include <string>
#include <ostream>
#include <functional>
 
hi_export_module(hikogui.GUI : keyboard_modifiers);
 
hi_export namespace hi::inline v1 {
 
enum class keyboard_modifiers : uint8_t {
    none = 0x00,
    shift = 0x01, 
    control = 0x02, 
    alt = 0x04, 
    super = 0x08, 
};
 
[[nodiscard]] constexpr keyboard_modifiers operator|(keyboard_modifiers const& lhs, keyboard_modifiers const& rhs) noexcept
{
    return static_cast<keyboard_modifiers>(std::to_underlying(lhs) | std::to_underlying(rhs));
}
 
[[nodiscard]] constexpr keyboard_modifiers operator&(keyboard_modifiers const& lhs, keyboard_modifiers const& rhs) noexcept
{
    return static_cast<keyboard_modifiers>(std::to_underlying(lhs) & std::to_underlying(rhs));
}
 
constexpr keyboard_modifiers& operator|=(keyboard_modifiers& lhs, keyboard_modifiers const& rhs) noexcept
{
    return lhs = lhs | rhs;
}
 
[[nodiscard]] constexpr bool to_bool(keyboard_modifiers const& rhs) noexcept
{
    return to_bool(std::to_underlying(rhs));
}
 
bool operator>=(keyboard_modifiers const& lhs, keyboard_modifiers const& rhs) = delete;
 
hi_inline keyboard_modifiers to_keyboard_modifiers(std::string_view s)
{
    if (ssize(s) == 0) {
        throw parse_error("Empty keyboard modifier");
    }
 
    // Remove the canonical trailing '+'.
    auto const s_lower = to_lower((s.back() == '+') ? s.substr(0, ssize(s) - 1) : s);
 
    if (s_lower == "shift") {
        return keyboard_modifiers::shift;
    } else if (s_lower == "control" || s_lower == "ctrl" || s_lower == "cntr") {
        return keyboard_modifiers::control;
    } else if (s_lower == "alt" || s_lower == "option" || s_lower == "meta") {
        return keyboard_modifiers::alt;
    } else if (s_lower == "windows" || s_lower == "win" || s_lower == "command" || s_lower == "cmd" || s_lower == "super") {
        return keyboard_modifiers::super;
    } else {
        throw parse_error(std::format("Unknown keyboard modifier '{}'", s));
    }
}
 
hi_inline std::string to_string(keyboard_modifiers modifiers)
{
    auto r = std::string{};
 
    if (to_bool(modifiers & keyboard_modifiers::shift)) {
        r += "shift+";
    }
    if (to_bool(modifiers & keyboard_modifiers::control)) {
        r += "control+";
    }
    if (to_bool(modifiers & keyboard_modifiers::alt)) {
        r += "alt+";
    }
    if (to_bool(modifiers & keyboard_modifiers::super)) {
        r += "super+";
    }
 
    return r;
}
 
hi_inline std::ostream& operator<<(std::ostream& lhs, keyboard_modifiers const& rhs)
{
    return lhs << to_string(rhs);
}
 
} // namespace hi::inline v1
 
template<>
struct std::hash<hi::keyboard_modifiers> {
    [[nodiscard]] std::size_t operator()(hi::keyboard_modifiers const& rhs) const noexcept
    {
        return std::hash<uint8_t>{}(static_cast<uint8_t>(rhs));
    }
};
 
// XXX #617 MSVC bug does not handle partial specialization in modules.
hi_export template<>
struct std::formatter<hi::keyboard_modifiers, char> : std::formatter<std::string_view, char> {
    auto format(hi::keyboard_modifiers const& t, auto& fc) const
    {
        return std::formatter<std::string_view, char>::format(hi::to_string(t), fc);
    }
};