Keyboard.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include "../Input.h"
 
namespace Gorgon { namespace Input {
    
namespace Keyboard {
        
    typedef Gorgon::Input::Key  Key;
 
    namespace Keycodes {
        constexpr Key Shift         = 0b100000001;
        constexpr Key Control       = 0b100000010;
        constexpr Key Alt           = 0b100000100;
        constexpr Key Meta          = 0b100001000;
 
        constexpr Key RShift        = 0b110000001;
        constexpr Key RControl      = 0b110000010;
        constexpr Key RAlt          = 0b110000100;
        constexpr Key RMeta         = 0b110001000;
 
        constexpr Key Home          = 0b100010001;
        constexpr Key End           = 0b100010010;
        constexpr Key Insert        = 0b100010011;
        constexpr Key Delete        = 0b100010100;
        constexpr Key PageUp        = 0b100010101;
        constexpr Key PageDown      = 0b100010110;
 
        constexpr Key PrintScreen   = 0b100010111;
        constexpr Key Pause         = 0b100011000;
 
        constexpr Key Menu          = 0b100011001;
 
        constexpr Key CapsLock      = 0b100011010;
        constexpr Key Numlock       = 0b100011011;
        constexpr Key ScrollLock    = 0b100011100;
 
        constexpr Key Enter         = 0x0D;
        constexpr Key Tab           = 0x0B;
        constexpr Key Backspace     = 0x08;
        constexpr Key Space         = 0x20;
        constexpr Key Escape        = 0x1B;
 
        constexpr Key Left          = 0b100100000;
        constexpr Key Up            = 0b100100001;
        constexpr Key Right         = 0b100100010;
        constexpr Key Down          = 0b100100011;
 
        constexpr Key F1            = 0b101000000 + 1;
        constexpr Key F2            = 0b101000000 + 2;
        constexpr Key F3            = 0b101000000 + 3;
        constexpr Key F4            = 0b101000000 + 4;
        constexpr Key F5            = 0b101000000 + 5;
        constexpr Key F6            = 0b101000000 + 6;
        constexpr Key F7            = 0b101000000 + 7;
        constexpr Key F8            = 0b101000000 + 8;
        constexpr Key F9            = 0b101000000 + 9;
        constexpr Key F10           = 0b101000000 + 10;
        constexpr Key F11           = 0b101000000 + 11;
        constexpr Key F12           = 0b101000000 + 12;
 
        constexpr Key A             = 'A';
        constexpr Key B             = 'B';
        constexpr Key C             = 'C';
        constexpr Key D             = 'D';
        constexpr Key E             = 'E';
        constexpr Key F             = 'F';
        constexpr Key G             = 'G';
        constexpr Key H             = 'H';
        constexpr Key I             = 'I';
        constexpr Key J             = 'J';
        constexpr Key K             = 'K';
        constexpr Key L             = 'L';
        constexpr Key M             = 'M';
        constexpr Key N             = 'N';
        constexpr Key O             = 'O';
        constexpr Key P             = 'P';
        constexpr Key Q             = 'Q';
        constexpr Key R             = 'R';
        constexpr Key S             = 'S';
        constexpr Key T             = 'T';
        constexpr Key U             = 'U';
        constexpr Key V             = 'V';
        constexpr Key W             = 'W';
        constexpr Key X             = 'X';
        constexpr Key Y             = 'Y';
        constexpr Key Z             = 'Z';
 
        constexpr Key Number_1      = '1';
        constexpr Key Number_2      = '2';
        constexpr Key Number_3      = '3';
        constexpr Key Number_4      = '4';
        constexpr Key Number_5      = '5';
        constexpr Key Number_6      = '6';
        constexpr Key Number_7      = '7';
        constexpr Key Number_8      = '8';
        constexpr Key Number_9      = '9';
        constexpr Key Number_0      = '0';
 
        constexpr Key Numpad_0      = 0b101100000 + 0;
        constexpr Key Numpad_1      = 0b101100000 + 1;
        constexpr Key Numpad_2      = 0b101100000 + 2;
        constexpr Key Numpad_3      = 0b101100000 + 3;
        constexpr Key Numpad_4      = 0b101100000 + 4;
        constexpr Key Numpad_5      = 0b101100000 + 5;
        constexpr Key Numpad_6      = 0b101100000 + 6;
        constexpr Key Numpad_7      = 0b101100000 + 7;
        constexpr Key Numpad_8      = 0b101100000 + 8;
        constexpr Key Numpad_9      = 0b101100000 + 9;
        constexpr Key Numpad_Decimal= 0b101101010;
        constexpr Key Numpad_Div    = 0b101101011;
        constexpr Key Numpad_Mult   = 0b101101100;
        constexpr Key Numpad_Enter  = 0b101101101;
        constexpr Key Numpad_Plus   = 0b101101110;
        constexpr Key Numpad_Minus  = 0b101101111;
    
        constexpr Key OSTransport   = 0b100000000000;
 
        inline constexpr bool IsEnter(Key key) {
            return key == Enter || key == Numpad_Enter;
        }
 
        inline constexpr bool IsModifier(Key key) {
            return 
                key == Shift || key == RShift || 
                key == Control || key == RControl || 
                key == Alt || key == RAlt ||
                key == Meta || key == RMeta;
        }
        
        std::string GetName(Key key);
    }
 
    typedef Gorgon::Char        Char;
        
    extern std::map<Key, bool> PressedKeys;
        
    class Modifier {
    public:
        enum Type {
            None        = 0,
            Shift       = Keycodes::Shift,
            Ctrl        = Keycodes::Control,
            Alt         = Keycodes::Alt,
            Meta        = Keycodes::Meta,
 
            ShiftCtrl   = Shift | Ctrl ,                
            ShiftAlt    = Shift | Alt  ,                
            CtrlAlt     = Ctrl  | Alt  ,
                
            ShiftCtrlAlt= Shift | Ctrl | Alt ,
            
            ModMask = Ctrl | Alt | Meta,
            
            ModCompare = Ctrl & Alt & Meta,
        };
            
        Modifier(Type key=None) : 
        Key(key)
        { }
 
        Modifier &operator =(const Modifier &) = default;
            
        bool IsModified() const {
            return Key != 0 && Key != Shift;
        }
            
        void Remove(Type key) {
            Key = (Type)(Key & ~key);
        }
            
        void Add(Type key) {
            Key = (Type)(Key | key);
        }
            
        void Add(Key key) {
            if(key == Keycodes::Shift || key == Keycodes::RShift) {
                Key = Type(Key | Shift);
            }
            else if(key == Keycodes::Control || key == Keycodes::RControl) {
                Key = Type(Key | Ctrl);
            }
            else if(key == Keycodes::Alt || key == Keycodes::RAlt) {
                Key = Type(Key | Alt);
            }
            else if(key == Keycodes::Meta || key == Keycodes::RMeta) {
                Key = Type(Key | Meta);
            }
        }
            
        void Remove(Key key) {
            if(key == Keycodes::Shift || key == Keycodes::RShift) {
                Key = Type(Key & ~Shift);
            }
            else if(key == Keycodes::Control || key == Keycodes::RControl) {
                Key = Type(Key & ~Ctrl);
            }
            else if(key == Keycodes::Alt || key == Keycodes::RAlt) {
                Key = Type(Key & ~Alt);
            }
            else if(key == Keycodes::Meta || key == Keycodes::RMeta) {
                Key = Type(Key & ~Meta);
            }
        }
        
        Modifier &operator |=(const Modifier &r) {
            Key = (Type)(Key | r.Key);
                
            return *this;
        }
            
        Modifier &operator &=(const Modifier &r) {
            Key = (Type)(Key & r.Key);
                
            return *this;
        }
        
        Modifier operator |(const Modifier &r) const {
            return {Type(Key | r.Key)};
        }
            
        Modifier operator &(const Modifier &r) const {
            return {Type(Key & r.Key)};
        }
        
        explicit operator bool() const {
            return Key != None;
        }
        
        bool operator !() const {
            return Key == None;
        }
        
        Type Key;
    };
 
    inline bool operator ==(const Modifier &l, const Modifier &r) {
        return l.Key == r.Key;
    }
 
    inline bool operator !=(const Modifier &l, const Modifier &r) {
        return l.Key != r.Key;
    }
 
    extern Modifier CurrentModifier;
} } }