ge211_event.hxx

#pragma once
 
#include "ge211_forward.hxx"
#include "ge211_error.hxx"
#include "ge211_noexcept.hxx"
 
#include <sstream>
#include <string>
 
namespace ge211 {
 
namespace events {
 
enum class Mouse_button
{
    left,
    middle,
    right,
};
 
std::ostream& operator<<(std::ostream&, Mouse_button);
 
} // end namespace events
 
namespace detail {
 
// Attempts to convert an SDL mouse button code to a ge211 Mouse_button.
// Returns true on success, or false if the SDL mouse button code does
// not correspond to left, middle, or right.
bool map_button(uint8_t, Mouse_button&) NOEXCEPT;
 
// Unicode constants.
static char32_t const lowest_unicode_surrogate = 0xD800;
static char32_t const highest_unicode_surrogate = 0xDFFF;
static char32_t const highest_unicode_code_point = 0x10FFFF;
 
// Checks for valid Unicode code points.
inline bool is_valid_unicode(char32_t code)
{
    return code < lowest_unicode_surrogate ||
            (code > highest_unicode_surrogate &&
                    code <= highest_unicode_code_point);
}
 
} // end namespace detail
 
namespace events {
 
class Key
{
public:
 
    Key() NOEXCEPT : Key{Type::other} { }
 
    static Key code(char32_t c)
    {
        if (detail::is_valid_unicode(c))
            return Key{c};
 
        throw Client_logic_error{"Not a valid Unicode code point"};
    }
 
    static Key up() NOEXCEPT { return Key{Type::up}; };
 
    static Key down() NOEXCEPT { return Key{Type::down}; };
 
    static Key left() NOEXCEPT { return Key{Type::left}; };
 
    static Key right() NOEXCEPT { return Key{Type::right}; };
 
    static Key shift() NOEXCEPT { return Key{Type::shift}; };
 
    static Key control() NOEXCEPT { return Key{Type::control}; };
 
    static Key alt() NOEXCEPT { return Key{Type::alt}; };
 
    static Key command() NOEXCEPT { return Key{Type::command}; };
 
    static Key other() NOEXCEPT { return Key{Type::other}; }
 
 
    enum class Type
    {
        code,
        up,
        down,
        left,
        right,
        shift,
        control,
        alt,
        command,
        other,
    };
 
    Type type() const NOEXCEPT { return type_; }
 
    char32_t code() const NOEXCEPT { return code_; }
 
    bool is_textual() const NOEXCEPT;
 
    std::string as_text() const;
 
private:
    explicit Key(Type type) NOEXCEPT
            : type_{type},
              code_{0}
    { }
 
    explicit Key(char32_t c) NOEXCEPT
            : type_{Type::code},
              code_{c}
    { }
 
    friend class detail::Engine;
    explicit Key(SDL_KeyboardEvent const&) NOEXCEPT;
 
    Type type_;
    char32_t code_;
};
 
inline bool operator==(Key a, Key b) NOEXCEPT
{
    return a.type() == b.type() && a.code() == b.code();
}
 
inline bool operator!=(Key a, Key b) NOEXCEPT
{
    return !(a == b);
}
 
std::ostream& operator<<(std::ostream&, Key::Type);
 
std::ostream& operator<<(std::ostream&, Key);
 
} // end namespace events
 
}