CUKeyboard.h

//
//  CUKeyboard.h
//  Cornell University Game Library (CUGL)
//
//  This class provides basic keyboard support.  It is intended for low-level,
//  WASD-like control.  It is not to be used for gather text.  That is the
//  purpose of the TextInput device.
//
//  This class is a singleton and should never be allocated directly.  It
//  should only be accessed via the Input dispatcher.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 7/9/16
#ifndef __CU_KEYBOARD_H__
#define __CU_KEYBOARD_H__
 
#include <cugl/input/CUInput.h>
#include <cugl/util/CUTimestamp.h>
#include <functional>
 
namespace cugl {
 
#pragma mark KeyCode
 
enum class KeyCode : int {
    NUM_0 = SDLK_0,
    NUM_1 = SDLK_1,
    NUM_2 = SDLK_2,
    NUM_3 = SDLK_3,
    NUM_4 = SDLK_4,
    NUM_5 = SDLK_5,
    NUM_6 = SDLK_6,
    NUM_7 = SDLK_7,
    NUM_8 = SDLK_8,
    NUM_9 = SDLK_9,
    
    A = SDLK_a,
    B = SDLK_b,
    C = SDLK_c,
    D = SDLK_d,
    E = SDLK_e,
    F = SDLK_f,
    G = SDLK_g,
    H = SDLK_h,
    I = SDLK_i,
    J = SDLK_j,
    K = SDLK_k,
    L = SDLK_l,
    M = SDLK_m,
    N = SDLK_n,
    O = SDLK_o,
    P = SDLK_p,
    Q = SDLK_q,
    R = SDLK_r,
    S = SDLK_s,
    T = SDLK_t,
    U = SDLK_u,
    V = SDLK_v,
    W = SDLK_w,
    X = SDLK_x,
    Y = SDLK_y,
    Z = SDLK_z,
    
    ARROW_DOWN = SDLK_DOWN,
    ARROW_LEFT = SDLK_LEFT,
    ARROW_RIGHT = SDLK_RIGHT,
    ARROW_UP = SDLK_UP,
    
    QUOTE = SDLK_QUOTE,
    BACKSLASH = SDLK_BACKSLASH,
    COMMA = SDLK_COMMA,
    EQUALS = SDLK_EQUALS,
    BACKQUOTE = SDLK_BACKQUOTE,
    LEFT_BRACKET = SDLK_LEFTBRACKET,
    MINUS = SDLK_MINUS,
    PERIOD = SDLK_PERIOD,
    RIGHT_BRACKET = SDLK_RIGHTBRACKET,
    SEMICOLON = SDLK_SEMICOLON,
    SLASH = SDLK_SLASH,
    BACKSPACE = SDLK_BACKSPACE,
    SPACE = SDLK_SPACE,
    TAB = SDLK_TAB,
    
    DEL = SDLK_DELETE,
    END = SDLK_END,
    ESCAPE = SDLK_ESCAPE,
    HOME = SDLK_HOME,
    HELP = SDLK_HELP,
    PAGE_DOWN = SDLK_PAGEDOWN,
    PAGE_UP = SDLK_PAGEUP,
    PAUSE = SDLK_PAUSE,
    RETURN = SDLK_RETURN,
    ENTER = SDLK_RETURN2,
    
    CAPS_LOCK = SDLK_CAPSLOCK,
    LEFT_ALT = SDLK_LALT,
    LEFT_CTRL = SDLK_LCTRL,
    LEFT_SHIFT = SDLK_LSHIFT,
    LEFT_META = SDLK_LGUI,
    RIGHT_ALT = SDLK_RALT,
    RIGHT_CTRL = SDLK_RCTRL,
    RIGHT_SHIFT = SDLK_RSHIFT,
    RIGHT_META = SDLK_RGUI,
    NUMLOCK = SDLK_NUMLOCKCLEAR,
    
    KEYPAD_0 = SDLK_KP_0,
    KEYPAD_1 = SDLK_KP_1,
    KEYPAD_2 = SDLK_KP_2,
    KEYPAD_3 = SDLK_KP_3,
    KEYPAD_4 = SDLK_KP_4,
    KEYPAD_5 = SDLK_KP_5,
    KEYPAD_6 = SDLK_KP_6,
    KEYPAD_7 = SDLK_KP_7,
    KEYPAD_8 = SDLK_KP_8,
    KEYPAD_9 = SDLK_KP_9,
    KEYPAD_CLEAR = SDLK_KP_CLEAR,
    KEYPAD_EQUALS = SDLK_KP_EQUALS,
    KEYPAD_DIVIDE = SDLK_KP_DIVIDE,
    KEYPAD_MULTIPLY = SDLK_KP_MULTIPLY,
    KEYPAD_MINUS = SDLK_KP_MINUS,
    KEYPAD_PLUS = SDLK_KP_PLUS,
    KEYPAD_ENTER = SDLK_KP_ENTER,
    
    UNKNOWN = SDLK_POWER
};
    
struct KeyCodeHasher {
    std::size_t operator()(const KeyCode& k) const {
        return (std::hash<int>()(static_cast<int>(k)));
    }
};
 
 
#pragma mark -
 
enum class KeyCategory {
    NUMBER,
    LETTER,
    ARROW,
    PUNCTUATION,
    SPECIAL,
    MODIFIER,
    KEYPAD,
    UNKNOWN
};
    
#pragma mark -
    
class KeyEvent {
public:
    Timestamp timestamp;
    KeyCode keycode;
    
    KeyEvent() : keycode(KeyCode::UNKNOWN) {}
    
    KeyEvent(KeyCode code, const Timestamp& stamp) {
        keycode = code; timestamp = stamp;
    }
        
    KeyCategory keyCategory();
};
    
#pragma mark -
 
class Keyboard : public InputDevice {
public:
#pragma mark Listener
 
    typedef std::function<void(const KeyEvent& event, bool focus)> Listener;
    
#pragma mark Values
protected:
    std::unordered_set<KeyCode,KeyCodeHasher> _previous;
    std::unordered_set<KeyCode,KeyCodeHasher> _current;
    
    std::unordered_map<Uint32, Listener> _downListeners;
    std::unordered_map<Uint32, Listener> _upListeners;
 
#pragma mark Constructor
 
    Keyboard() : InputDevice() {}
    
    virtual ~Keyboard() {}
    
    virtual void dispose() override;
 
public:
#pragma mark Data Polling
 
    bool keyDown(KeyCode code) const {
        return _current.find(code) != _current.end();
    }
    
    bool keyPressed(KeyCode code) const {
        return _current.find(code) != _current.end() && _previous.find(code) == _previous.end();
    }
    
    bool keyReleased(KeyCode code) {
        return _current.find(code) == _current.end() && _previous.find(code) != _previous.end();
    }
    
    unsigned int keyCount() const { return (unsigned int)_current.size(); }
    
    const std::vector<KeyCode> keySet() const;
 
    static KeyCategory keyCategory(KeyCode code);
    
#pragma mark Listeners
 
    virtual bool requestFocus(Uint32 key) override;
    
    bool isListener(Uint32 key) const;
    
    const Listener getKeyDownListener(Uint32 key) const;
    
    const Listener getKeyUpListener(Uint32 key) const;
    
    bool addKeyDownListener(Uint32 key, Listener listener);
    
    bool addKeyUpListener(Uint32 key, Listener listener);
 
    bool removeKeyDownListener(Uint32 key);
 
    bool removeKeyUpListener(Uint32 key);
    
protected:
#pragma mark Input Device
 
    virtual void clearState() override;
    
    virtual bool updateState(const SDL_Event& event, const Timestamp& stamp) override;
    
    virtual void queryEvents(std::vector<Uint32>& eventset) override;
    
    // Apparently friends are not inherited
    friend class Input;
};
 
}
 
#endif /* __CU_KEYBOARD_H__ */