Key.h

#ifndef PT_FORMS_KEYCODE_H
#define PT_FORMS_KEYCODE_H
 
#include <Pt/Forms/Api.h>
#include <Pt/Types.h>
#include <Pt/String.h>
#include <iostream>
#include <cassert>
 
namespace Pt {
 
namespace Forms {

class Key
{
    public:
        // see also: https://w3c.github.io/uievents-code/
        enum Code
        {
            NoKey      = 0x0,
 
            // SPECIAL KEYS ASCII
 
            Backspace  = 0x08,
 
            Tab        = 0x09,
 
            Return     = 0x0D,
 
            Escape     = 0x1B,
 
 
            // CHARACTER KEYS (match unicode)
 
            // Space key.
            Space  = 32,
 
            // The 0 key.
            D0     = 48,
 
            // The 1 key.
            D1     = 49,
 
            // The 2 key.
            D2     = 50,
 
            // The 3 key.
            D3     = 51,
 
            // The 4 key.
            D4     = 52,
 
            // The 5 key.
            D5     = 53,
 
            // The 6 key.
            D6     = 54,
 
            // The 7 key.
            D7     = 55,
 
            // The 8 key.
            D8     = 56,
 
            // The 9 key.
            D9     = 57,
 
            // The A key.
            A      = 65,
 
            // The B key.
            B      = 66,
 
            // The C key.
            C      = 67,
 
            // The D key.
            D      = 68,
 
            // The E key.
            E      = 69,
 
            // The F key.
            F      = 70,
 
            // The G key.
            G      = 71,
 
            // The H key.
            H      = 72,
 
            // The I key.
            I      = 73,
 
            // The J key.
            J      = 74,
 
            // The K key.
            K      = 75,
 
            // The L key.
            L      = 76,
 
            // The M key.
            M      = 77,
 
            // The N key.
            N      = 78,
 
            // The O key.
            O      = 79,
 
            // The P key.
            P      = 80,
 
            // The Q key.
            Q      = 81,
 
            // The R key.
            R      = 82,
 
            // The S key.
            S      = 83,
 
            // The T key.
            T      = 84,
 
            // The U key.
            U      = 85,
 
            // The V key.
            V      = 86,
 
            // The W key.
            W      = 87,
 
            // The X key.
            X      = 88,
 
            // The Y key.
            Y      = 89,
 
            // The Z key.
            Z      = 90,
 
 
            // MODIFIERS
 
            Unknown        = 0x100000,
            ModifiersBegin = 0x100000,
 
            // The Shift Key.
            ShiftKey       = 0x100001, // 1
 
            // The Control Key.
            ControlKey     = 0x100002, // 2
 
            // The Alt Key.
            AltKey         = 0x100004, // 4
 
            // The Meta Key.
            MetaKey        = 0x100008, // 8
 
            // Reserved.
            Modifier5      = 0x100010, // 16
 
            // Reserved.
            Modifier6      = 0x100020, // 32
 
            // Reserved.
            Modifier7      = 0x100040, // 64
 
            // Reserved.
            Modifier8      = 0x100080, // 128
 
            // Reserved.
            Modifier9      = 0x100100, // 256
 
 
            // NAVIGATION KEYS 33 to 63
 
            ArrowLeft    = 0x100021,
 
            ArrowRight   = 0x100022,
 
            ArrowUp      = 0x100023,
 
            ArrowDown    = 0x100024,
 
 
            // NUMPAD 65 to 127
 
            // The NUM LOCK key.
            NumLock     = 0x100041,
 
            // The 0 key on the numeric keypad.
            NumPad0     = 0x100042,
 
            // The 1 key on the numeric keypad.
            NumPad1     = 0x100043,
 
            // The 2 key on the numeric keypad.
            NumPad2     = 0x100044,
 
            // The 3 key on the numeric keypad.
            NumPad3     = 0x100045,
 
            // The 4 key on the numeric keypad.
            NumPad4     = 0x100046,
 
            // The 5 key on the numeric keypad.
            NumPad5     = 0x100047,
 
            // The 6 key on the numeric keypad.
            NumPad6     = 0x100048,
 
            // The 7 key on the numeric keypad.
            NumPad7     = 0x100049,
 
            // The 8 key on the numeric keypad.
            NumPad8     = 0x10004A,
 
            // The 9 key on the numeric keypad.
            NumPad9     = 0x10004B,
 
            // The multiply key.
            Multiply    = 0x10004C,
 
            // The add key.
            Add         = 0x10004D,
 
            // The divide key.
            Divide      = 0x10004E,
 
            // The subtract key.
            Subtract    = 0x10004F,
 
            // The separator key.
            Separator   = 0x100050,
 
            // The decimal key.
            Decimal     = 0x100051,
 
 
            // FUNCTION KEYS 129 to 191
 
            // The F1 key.
            F1  = 0x100081, // 129
 
            // The F2 key.
            F2  = 0x100082,
 
            // The F3 key.
            F3  = 0x100083,
 
            // The F4 key.
            F4  = 0x100084,
 
            // The F5 key.
            F5  = 0x100085,
 
            // The F6 key.
            F6  = 0x100086,
 
            // The F7 key.
            F7  = 0x100087,
 
            // The F8 key.
            F8  = 0x100088,
 
            // The F9 key.
            F9  = 0x100089,
 
            // The F10 key.
            F10 = 0x10008A,
 
            // The F11 key.
            F11 = 0x10008B,
 
            // The F12 key.
            F12 = 0x10008C,
 
            // The F13 key.
            F13 = 0x10008D,
 
            // The F14 key.
            F14 = 0x10008E,
 
            // The F15 key.
            F15 = 0x10008F,
 
            // The F16 key.
            F16 = 0x100090,
 
            // The F17 key.
            F17 = 0x100091,
 
            // The F18 key.
            F18 = 0x100092,
 
            // The F19 key.
            F19 = 0x100093,
 
            // The F20 key.
            F20 = 0x100094,
 
            // The F21 key.
            F21 = 0x100095,
 
            // The F22 key.
            F22 = 0x100096,
 
            // The F23 key.
            F23 = 0x100097,
 
            // The F24 key.
            F24 = 0x100098,
 
 
            // SPECIAL KEYS 192 to 255
 
            Insert             = 0x1000C0, // 192
 
            Delete             = 0x1000C1,
 
            Home               = 0x1000C2,
 
            End                = 0x1000C3,
 
            PageUp             = 0x1000C4,
 
            PageDown           = 0x1000C5,
 
            CapsLock           = 0x1000C6,
 
            PrintScreen        = 0x1000C7,
 
            SysReq             = 0x1000C8,
 
            ScrollLock         = 0x1000C9,
 
            Pause              = 0x1000CA,
 
            Break              = 0x1000CB, // 204
 
            Clear              = 0x1000E0, // 224
 
            Sleep              = 0x1000E1,
 
            Select             = 0x1000E2,
 
            Print              = 0x1000E3,
 
            Execute            = 0x1000E4,
 
            Help               = 0x1000E5,
 
            AppsMenu           = 0x1000E6,
 
            ModeChange         = 0x1000E7, // 231
 
 
            // SPECIAL APPLICATION KEYS 257 to 511
 
            Play               = 0x100101,
 
            Zoom               = 0x100102,
 
            BrowserBack        = 0x100103,
 
            BrowserForward     = 0x100104,
 
            BrowserRefresh     = 0x100105,
 
            BrowserStop        = 0x100106,
 
            BrowserSearch      = 0x100107,
 
            BrowserFavorites   = 0x100108,
 
            BrowserHome        = 0x100109,
 
            VolumeMute         = 0x10010A,
 
            VolumeDown         = 0x10010B,
 
            VolumeUp           = 0x10010C,
 
            MediaNext          = 0x10010D,
 
            MediaPrev          = 0x10010E,
 
            MediaStop          = 0x10010F,
 
            MediaPlay          = 0x100111,
 
            LaunchMail         = 0x100112,
 
            LaunchMedia        = 0x100113,
 
            LaunchApp1         = 0x100114,
 
            LaunchApp2         = 0x100115,
 
            KeyMax = 0x10FFFF
        };

        enum Modifier
        {
            // No modifier pressed.
            NoModifier  = ModifiersBegin,
 
            // The SHIFT modifier key.
            Shift       = ShiftKey,
 
            // The CTRL modifier key.
            Control     = ControlKey,
 
            // The ALT modifier key.
            Alt         = AltKey,
 
            // The Meta modifier key.
            Meta        = MetaKey,
 
            ModifierMax = KeyMax
        };

        class Modifiers
        {
            friend Modifiers operator|(Modifier m1, Modifier m2);
 
            public:
                Modifiers()
                : _value(NoModifier)
                { }

                explicit Modifiers(Modifier m)
                : _value(m)
                { }

                Modifiers operator=(Modifier m)
                {
                    _value = m;
                    return *this;
                }

                void clear()
                {
                    _value = NoModifier;
                }

                bool empty() const
                {
                    return _value == NoModifier;
                }

                void add(Modifier m)
                {
                    _value |= m;
                }

                bool has(Modifier m) const
                {
                    return (_value & m) == m;
                }

                bool has(Modifiers m) const
                {
                    return (_value & m._value) == m._value;
                }

                Modifiers operator|(Modifier m) const
                {
                    return Modifiers(_value | m);
                }

                bool operator==(Modifier m) const
                {
                    return _value == static_cast<Pt::uint32_t>(m);
                }

                bool operator==(Modifiers m) const
                {
                    return _value == m._value;
                }

                bool operator!=(Modifier m) const
                {
                    return _value != static_cast<Pt::uint32_t>(m);
                }

                bool operator!=(Modifiers m) const
                {
                    return _value != m._value;
                }

                bool operator<(Modifiers m) const
                {
                    return _value < m._value;
                }
 
            private:
                explicit Modifiers(Pt::uint32_t value)
                : _value(value)
                { }
 
            private:
                Pt::uint32_t _value;
        };
 
    public:
        Key()
        : _code(NoKey)
        {}

        explicit Key(Pt::uint32_t c)
        : _code(c)
        {}

        Key(Modifier m, Pt::uint32_t c)
        : _code(c)
        , _modifier(m)
        {}

        Key(Modifiers m, Pt::uint32_t c)
        : _code(c)
        , _modifier( m )
        {}

        void clear()
        {
            _code = NoKey;
            _modifier = Modifiers();
        }

        void set(Pt::uint32_t c)
        {
            _code = c;
            _modifier = Modifiers();
        }

        void set(Modifier m, Pt::uint32_t c)
        {
            _code = c;
            _modifier = m;
        }

        void set(Modifiers m, Pt::uint32_t c)
        {
            _code = c;
            _modifier = m;
        }

        Pt::uint32_t code() const
        {
            return _code;
        }

        Modifiers modifiers() const
        {
            return _modifier;
        }

        bool operator==(const Key& k) const
        {
            return ! (*this != k);
        }

        bool operator!=(const Key& k) const
        {
            return _code != k._code ||
                   _modifier != k._modifier;
        }

        bool operator<(const Key& k) const
        {
            return _code < k._code ||
                  (_code == k._code && _modifier < k._modifier);
        }

        static Pt::String toString(Pt::uint32_t code)
        {
            if(code < ModifiersBegin)
                return Pt::String(1, code);
 
            switch(code)
            {
                case F1:         return "F1";
                case F2:         return "F2";
                case F3:         return "F3";
                case F4:         return "F4";
                case F5:         return "F5";
                case F6:         return "F6";
                case F7:         return "F7";
                case F8:         return "F8";
                case F9:         return "F9";
                case F10:        return "F10";
                case F11:        return "F11";
                case F12:        return "F12";
                case AltKey:     return "Alt";
                case ShiftKey:   return "Shift";
                case ControlKey: return "Ctrl";
                case MetaKey:    return "Meta";
                default:         return "";
            }
 
            return Pt::String();
        }

        bool empty() const
        {
            return _code  == Key::NoKey;
        }
 
 
    private:
        Pt::uint32_t _code;
        Modifiers _modifier;
};

inline Key::Modifiers operator|(Key::Modifier m1, Key::Modifier m2)
{
    Key::Modifiers m(m1);
    return m|m2;
}
 
} // namespace
 
} // namespace
 
#endif