ZXKeyboard.h

Go to the documentation of this file.

 
/* *************************************************************************/
#ifndef ZXKEYBOARD
#define ZXKEYBOARD
 
#include <cstdint>
#include <string>
#include <utility>
#include <set>
#include <map>
#include <chrono>
#include <functional>
#include "zxecosystem/ancillary/CppAddons.h"
#include "zxecosystem/base/ZXChars.h"
 
 
namespace zxeco
{
 
/*****************************************************************************
*
*    Class: Key
*
******************************************************************************/
 
enum class Key { // Must follow the order in which keys are in halfrows (see
                 // Membrane)
                 CAPS_SHIFT = 0, Z, X, C, V, 
                 A, S, D, F, G, 
                 Q, W, E, R, T, 
                 N1, N2, N3, N4, N5, 
                 N0, N9, N8, N7, N6, 
                 P, O, I, U, Y, 
                 ENTER, L, K, J, H, 
                 SPACE, SYMBOL_SHIFT, M, N, B, 
                 FIRST = CAPS_SHIFT, 
                 LAST = B, 
                 NUMKEYS = B+1, 
                 NO_KEY = NUMKEYS 
             }; // enum class for forcing explicit qualification.
 
 
extern const std::map<Key,std::string> KeyNames;
 
 
extern const char KeyLetters[2][static_cast<int>(Key::NUMKEYS)];
 
 
extern const char KeySymbols[2][static_cast<int>(Key::NUMKEYS)];
 
constexpr char keyToNumber(Key k)
    { return( ((k>=Key::N1)&&(k<=Key::N5)) ? static_cast<int>(k)-
                                             static_cast<int>(Key::N1)+1 :
                                 (
              ((k>=Key::N9)&&(k<=Key::N6)) ? static_cast<int>(Key::N6)-
                                             static_cast<int>(k)+6 :
                                 (
                                     (k==Key::N0) ? 0 : -1
                                 ) ) ); }
 
constexpr bool keyIsShift(Key k)
    { return((k==Key::CAPS_SHIFT)||(k==Key::SYMBOL_SHIFT)); }
 
 
typedef IterableEnum<Key> ItKey;
 
 
/*****************************************************************************
*
*    Class: KeyComb
*
******************************************************************************/
 
 
class KeyComb
{
 public:
 
    KeyComb(void) noexcept:ok_{false} {}
 
    KeyComb(Key shift, Key other);
 
    virtual ~KeyComb(void) = default;
 
    bool valid(void) const noexcept { return(ok_); }
 
    bool is(Key shift, Key other) const;
 
    Key shift(void) const;
 
    Key other(void) const;
 
    std::string to_string(void) const noexcept;
 
 private:
 
    bool ok_;
    Key kshift_{Key::NO_KEY};
    Key kother_{Key::NO_KEY};
};
 
 
/*****************************************************************************
*
*    Class: SetOfKeys
*
******************************************************************************/
 
class SetOfKeys: public std::set<Key>
{
 public:
 
    typedef std::set<Key> Base; 
 
    SetOfKeys(void) = default;
 
    SetOfKeys(const KeyComb &kc);
 
    SetOfKeys(const Base &b):Base{b} {}
 
    KeyComb toKeyComb(void) const noexcept;
 
    std::string to_string(void) const noexcept;
 
};
 
 
/*****************************************************************************
*
*    Class: Membrane
*
******************************************************************************/
 
class Membrane
{
 public:
 
        /* ---------------- Types, consts, etc. ------------------- */
 
    enum HalfRow { CAPS_V = 0,
                    A_G,        
                    Q_T,        
                    ONE_FIVE,   
                    ZERO_SIX,   
                    P_Y,        
                    ENTER_H,    
                    SPC_B,      
                    NUMHALFROWS };
 
    static constexpr unsigned char KEYSPERROW = 5;
 
    enum RowMask: unsigned char { MK1 = 1, 
                                   MK2 = 1 << 1, 
                                   MK3 = 1 << 2, 
                                   MK4 = 1 << 3, 
                                   MK5 = 1 << 4 
                                  };
 
 
    static constexpr uint8_t MASKKEYS = 0x1F;
 
 
    class KeyInRow: public std::pair<HalfRow,RowMask>
    {
     public:
 
        typedef std::pair<HalfRow,RowMask> Base; 
 
        static void checkPair(const Base & b);
 
        KeyInRow(HalfRow h=CAPS_V, RowMask m=MK1);
        KeyInRow(Key k);
        KeyInRow(const Base &b):KeyInRow{b.first,b.second} {}
 
        virtual ~KeyInRow(void) = default;
 
        // leave the rest of constructors, move and copies by default
 
        operator Key(void) const;
    };
 
 
        /* ---------------- Attributes ---------------------- */
 
 
    unsigned char krows[NUMHALFROWS];
 
 
    // Leave the compiler to generate default copies and moves
 
    Membrane(void) noexcept { fill_byte(krows,0,NUMHALFROWS); }
 
    virtual ~Membrane(void) = default;
 
    void clear(void) noexcept { fill_byte(krows,0,NUMHALFROWS); }
 
    unsigned char numKeysPressed(void) const noexcept;
 
    bool someKeyUnpressed(const Membrane & oth) const noexcept;
 
    bool someKeyPressed(const Membrane & oth) const noexcept;
 
    bool someNewKeyPressed(const Membrane & oth) const noexcept;
 
    void setKeyState(Key k, bool pressed = true);
 
    void setKeyState(const SetOfKeys & soks, bool pressed = true);
    void setKeyState(const KeyComb & kc, bool pressed = true);
 
    bool keyState(Key k) const noexcept;
 
    SetOfKeys keysPressed(void) const noexcept;
 
    KeyComb combinationPressed(void) const noexcept;
 
    bool operator!=(const Membrane & oth) const noexcept;
    bool operator==(const Membrane & oth) const noexcept
        { return(!(operator!=(oth))); }
 
    // friends defined inside class are inline and hidden from non-ADL lookup
    // (http://en.cppreference.com/w/cpp/language/operators)
 
    Membrane & operator^=(const Membrane & oth) noexcept;
    friend Membrane operator^(Membrane lhs, // passing lhs by value helps
                                             // optimize chained a+b+c
                               const Membrane & rhs) noexcept
                                             // otherwise, both parameters may
                                             // be const references
        { lhs ^= rhs;   // reuse compound assignment
          return lhs; } // return the result by value (uses move constructor)
    
    Membrane & operator&=(const Membrane & oth) noexcept;
    
    friend Membrane operator&(Membrane lhs, const Membrane & rhs) noexcept
        { lhs &= rhs; return lhs; }
    
    Membrane & operator|=(const Membrane & oth) noexcept;
    
    friend Membrane operator|(Membrane lhs, const Membrane & rhs) noexcept
        { lhs |= rhs; return lhs; }
    
    Membrane operator~(void) noexcept;
 
    std::string to_string(void) const noexcept;
 
};
 
 
/*****************************************************************************
*
*    Class: Keyboard
*
******************************************************************************/
 
 
class Keyboard
{
 public:
 
        /* ---------------- Consts, types, etc. ----------------- */
 
    enum class Mode {
                         NORMAL = 0,     
                         EXTENDED,       
                         GRAPHICS,       
                         NUMMODES
                     };
 
    static uint8_t keyToASCII(Mode km, bool capslock, Key shift, Key k);
 
    Keyboard(const Membrane & mem0 = Membrane{})
        { reset(); lastmembrane_ = mem0; }
 
    virtual ~Keyboard(void) = default;
 
    void reset(void);
 
    void setKeyRepetitions(
        std::chrono::steady_clock::duration repdel =
            std::chrono::milliseconds{700},
        std::chrono::steady_clock::duration repper =
            std::chrono::milliseconds{100}) noexcept
        { keyrepdel_ = repdel; keyrepper_ = repper; }
 
    bool newMembrane(const Membrane & newmembrane,
                     std::string * lastprstr = nullptr);
 
    void keyRepetitions(std::chrono::steady_clock::duration & repdel,
                               std::chrono::steady_clock::duration & repper)
                                                                const noexcept
        { repdel = keyrepdel_; repper = keyrepper_; }
 
    Mode mode(void) const noexcept { return(kmode_); }
 
    bool capsLock(void) const noexcept { return(capslock_); }
 
    std::chrono::steady_clock::time_point lastEffectiveChange(void) const
                                                                        noexcept
        { return(lasteffectivechange_); }
 
    const Membrane & lastMembrane(void) const noexcept
        { return(lastmembrane_); }
 
    Key lastKey(void) const noexcept
        { return(lastpressed_.keyorkeycomb ? lastpressed_.key : Key::NO_KEY); }
 
    KeyComb lastKeyComb(void) const noexcept
        { return(lastpressed_.keyorkeycomb ? KeyComb{} : lastpressed_.keycomb);}
 
    bool anyKey(void) const noexcept
        { return((lastKey() != zxeco::Key::NO_KEY) || (lastKeyComb().valid()));}
 
    std::string to_string(void) const noexcept;
 
 private:
 
    Membrane lastmembrane_;
    struct {
                bool keyorkeycomb;
                Key key;
                KeyComb keycomb;
            } lastpressed_;
    bool repeating_;
    Mode kmode_;
    bool capslock_;
    std::chrono::steady_clock::time_point lasteffectivechange_;
    std::chrono::steady_clock::duration keyrepdel_,keyrepper_;
 
    bool changeMode(void);
    bool changeModeAfter(void) noexcept;
    bool updateReps(void) noexcept;
    const std::string lastAsZXString(void) const noexcept;
};
 
 
} // end namespace zxeco
 
#endif
 // ZXKeyboard