keyboard.h

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// keyboard.h


#ifndef _KEYBOARD_H
#  define _KEYBOARD_H

#  include "misc.h"
#  include "driver.h"
#  include "stringtool.h"
#  include <vector>
#  include <list>
#  include <map>


/// a scan code with flags
class ScanCode
{
public:
	///
	enum {
		BREAK = KEYBOARD_INPUT_DATA::BREAK,		/// key release flag
		E0    = KEYBOARD_INPUT_DATA::E0,		/// extended key flag
		E1    = KEYBOARD_INPUT_DATA::E1,		/// extended key flag
		E0E1  = KEYBOARD_INPUT_DATA::E0E1,		/// extended key flag
	};

public:
	USHORT m_scan;				///
	USHORT m_flags;				///

public:
	///
	ScanCode() : m_scan(0), m_flags(0) { }
	///
	ScanCode(USHORT i_scan, USHORT i_flags)
			: m_scan(i_scan), m_flags(i_flags) { }
	///
	bool operator==(const ScanCode &i_sc) const {
		return (m_scan == i_sc.m_scan &&
				(E0E1 & m_flags) == (E0E1 & i_sc.m_flags));
	}
	///
	bool operator!=(const ScanCode &i_sc) const {
		return !(*this == i_sc);
	}
};


/// a key
class Key
{
public:
	enum {
		///
		MAX_SCAN_CODES_SIZE = 4,
	};

private:
	///
	typedef std::vector<tstringi> Names;

public:
	/// if this key pressed physically
	bool m_isPressed;
	/// if this key pressed on Win32
	bool m_isPressedOnWin32;
	/// if this key pressed by assign
	bool m_isPressedByAssign;

private:
	/// key name
	Names m_names;
	/// key scan code length
	size_t m_scanCodesSize;
	/// key scan code
	ScanCode m_scanCodes[MAX_SCAN_CODES_SIZE];

public:
	///
	Key()
			: m_isPressed(false),
			m_isPressedOnWin32(false),
			m_isPressedByAssign(false),
			m_scanCodesSize(0) { }

	/// for Event::* only
	Key(const tstringi &i_name)
			: m_isPressed(false),
			m_isPressedOnWin32(false),
			m_isPressedByAssign(false),
			m_scanCodesSize(0) {
		addName(i_name);
		addScanCode(ScanCode());
	}

	/// get key name (first name)
	const tstringi &getName() const {
		return m_names.front();
	}

	/// get scan codes
	const ScanCode *getScanCodes() const {
		return m_scanCodes;
	}
	///
	size_t getScanCodesSize() const {
		return m_scanCodesSize;
	}

	/// add a name of key
	void addName(const tstringi &i_name);

	/// add a scan code
	void addScanCode(const ScanCode &i_sc);

	/// initializer
	Key &initialize();

	/// equation by name
	bool operator==(const tstringi &i_name) const;
	///
	bool operator!=(const tstringi &i_name) const {
		return !(*this == i_name);
	}

	/// is the scan code of this key ?
	bool isSameScanCode(const Key &i_key) const;

	/// is the i_key's scan code the prefix of this key's scan code ?
	bool isPrefixScanCode(const Key &i_key) const;

	/// stream output
	friend tostream &operator<<(tostream &i_ost, const Key &i_key);

	/// <
	bool operator<(const Key &i_key) const {
		return getName() < i_key.getName();
	}
};


///
class Modifier
{
	///
	typedef u_int64 MODIFIERS;
	///
	MODIFIERS m_modifiers;
	///
	MODIFIERS m_dontcares;

public:
	///
	enum Type {
		Type_begin = 0,				///

		Type_Shift = Type_begin,			/// &lt;BASIC_MODIFIER&gt;
		Type_Alt,					/// &lt;BASIC_MODIFIER&gt;
		Type_Control,				/// &lt;BASIC_MODIFIER&gt;
		Type_Windows,				/// &lt;BASIC_MODIFIER&gt;
		Type_BASIC,					///

		Type_Up = Type_BASIC,			/// &lt;KEYSEQ_MODIFIER&gt;
		Type_Down,					/// &lt;KEYSEQ_MODIFIER&gt;
		Type_KEYSEQ,				///

		Type_Repeat = Type_KEYSEQ,			/// &lt;ASSIGN_MODIFIER&gt;
		Type_ImeLock,				/// &lt;ASSIGN_MODIFIER&gt;
		Type_ImeComp,				/// &lt;ASSIGN_MODIFIER&gt;
		Type_NumLock,				/// &lt;ASSIGN_MODIFIER&gt;
		Type_CapsLock,				/// &lt;ASSIGN_MODIFIER&gt;
		Type_ScrollLock,				/// &lt;ASSIGN_MODIFIER&gt;
		Type_KanaLock,				/// &lt;ASSIGN_MODIFIER&gt;
		Type_Maximized,				/// &lt;ASSIGN_MODIFIER&gt;
		Type_Minimized,				/// &lt;ASSIGN_MODIFIER&gt;
		Type_MdiMaximized,				/// &lt;ASSIGN_MODIFIER&gt;
		Type_MdiMinimized,				/// &lt;ASSIGN_MODIFIER&gt;
		Type_Touchpad,				/// &lt;ASSIGN_MODIFIER&gt;
		Type_TouchpadSticky,			/// &lt;ASSIGN_MODIFIER&gt;
		Type_Mod0,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Mod1,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Mod2,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Mod3,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Mod4,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Mod5,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Mod6,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Mod7,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Mod8,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Mod9,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Lock0,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Lock1,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Lock2,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Lock3,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Lock4,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Lock5,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Lock6,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Lock7,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Lock8,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_Lock9,					/// &lt;ASSIGN_MODIFIER&gt;
		Type_ASSIGN,				///

		Type_end = Type_ASSIGN			///
	};

public:
	///
	Modifier();
	///
	Modifier &on(Type i_type) {
		return press(i_type);
	}
	///
	Modifier &off(Type i_type) {
		return release(i_type);
	}
	///
	Modifier &press(Type i_type) {
		m_modifiers |= ((MODIFIERS(1)) << i_type);
		return care(i_type);
	}
	///
	Modifier &release(Type i_type) {
		m_modifiers &= ~((MODIFIERS(1)) << i_type);
		return care(i_type);
	}
	///
	Modifier &care(Type i_type) {
		m_dontcares &= ~((MODIFIERS(1)) << i_type);
		return *this;
	}
	///
	Modifier &dontcare(Type i_type) {
		m_dontcares |= ((MODIFIERS(1)) << i_type);
		return *this;
	}
	/// set all modifiers to dontcare
	Modifier &dontcare() {
		m_dontcares = ~MODIFIERS(0);
		return *this;
	}

	///
	Modifier &on(Type i_type, bool i_isOn) {
		return press(i_type, i_isOn);
	}
	///
	Modifier &press(Type i_type, bool i_isPressed) {
		return i_isPressed ? press(i_type) : release(i_type);
	}
	///
	Modifier &care(Type i_type, bool i_doCare) {
		return i_doCare ? care(i_type) : dontcare(i_type);
	}

	///
	bool operator==(const Modifier &i_m) const {
		return m_modifiers == i_m.m_modifiers && m_dontcares == i_m.m_dontcares;
	}

	/// add m's modifiers where this dontcare
	void add(const Modifier &i_m);
	//Modifier &operator+=(const Modifier &i_m);

	/** does match. (except dontcare modifiers) (is the m included in the *this
	    set ?) */
	bool doesMatch(const Modifier &i_m) const {
		return ((m_modifiers | m_dontcares) == (i_m.m_modifiers | m_dontcares));
	}

	///
	bool isOn(Type i_type) const {
		return isPressed(i_type);
	}
	///
	bool isPressed(Type i_type) const {
		return !!(m_modifiers & ((MODIFIERS(1)) << i_type));
	}
	///
	bool isDontcare(Type i_type) const {
		return !!(m_dontcares & ((MODIFIERS(1)) << i_type));
	}

	/// stream output
	friend tostream &operator<<(tostream &i_ost, const Modifier &i_m);

	/// <
	bool operator<(const Modifier &i_m) const {
		return m_modifiers < i_m.m_modifiers ||
			   (m_modifiers == i_m.m_modifiers && m_dontcares < i_m.m_dontcares);
	}
};


/// stream output
tostream &operator<<(tostream &i_ost, Modifier::Type i_type);


///
class ModifiedKey
{
public:
	Modifier m_modifier;	///
	Key *m_key;		///

public:
	///
	ModifiedKey() : m_key(NULL) { }
	///
	ModifiedKey(Key *i_key) : m_key(i_key) { }
	///
	ModifiedKey(const Modifier &i_modifier, Key *i_key)
			: m_modifier(i_modifier), m_key(i_key) { }
	///
	bool operator==(const ModifiedKey &i_mk) const {
		return m_modifier == i_mk.m_modifier && m_key == i_mk.m_key;
	}
	///
	bool operator!=(const ModifiedKey &i_mk) const {
		return !operator==(i_mk);
	}

	/// stream output
	friend tostream &operator<<(tostream &i_ost, const ModifiedKey &i_mk);

	/// <
	bool operator<(const ModifiedKey &i_mk) const {
		return *m_key < *i_mk.m_key ||
			   (!(*i_mk.m_key < *m_key) && m_modifier < i_mk.m_modifier);
	}
};


///
class Keyboard
{
public:
	/// keyboard modifiers (pointer into Keys)
	typedef std::list<Key *> Mods;

private:
	/** keyboard keys (hashed by first scan code).
	    Keys must be *list* of Key.
	    Because *pointers* into Keys exist anywhere in this program, the address
	    of Key's elements must be fixed.  */
	enum {
		HASHED_KEYS_SIZE = 128,			///
	};
	typedef std::list<Key> Keys;			///
	typedef std::map<tstringi, Key *> Aliases;	/// key name aliases
	///
	class Substitute
	{
	public:
		ModifiedKey m_mkeyFrom;
		ModifiedKey m_mkeyTo;
	public:
		Substitute(const ModifiedKey &i_mkeyFrom,
				   const ModifiedKey &i_mkeyTo)
				: m_mkeyFrom(i_mkeyFrom), m_mkeyTo(i_mkeyTo) {
		}
	};
	typedef std::list<Substitute> Substitutes;	/// substitutes

private:
	Keys m_hashedKeys[HASHED_KEYS_SIZE];		///
	Aliases m_aliases;				///
	Substitutes m_substitutes;			///
	Key m_syncKey;				/// key used to synchronize

private:
	///
	Mods m_mods[Modifier::Type_BASIC];

public:
	///
	class KeyIterator
	{
		///
		Keys *m_hashedKeys;
		///
		size_t m_hashedKeysSize;
		///
		Keys::iterator m_i;

		///
		void next();

	public:
		///
		KeyIterator(Keys *i_hashedKeys, size_t i_hashedKeysSize);
		///
		Key *operator *();
		///
		void operator++() {
			next();
		}
	};

private:
	///
	Keys &getKeys(const Key &i_key);

public:
	/// add a key
	void addKey(const Key &i_key);

	/// add a key name alias
	void addAlias(const tstringi &i_aliasName, Key *i_key);

	/// add substitute
	void addSubstitute(const ModifiedKey &i_mkeyFrom,
					   const ModifiedKey &i_mkeyTo);

	/// get a sync key
	Key *getSyncKey() {
		return &m_syncKey;
	}

	/// add a modifier key
	void addModifier(Modifier::Type i_mt, Key * i_key);

	/// search a key
	Key *searchKey(const Key &i_key);

	/// search a key (of which the key's scan code is the prefix)
	Key *searchPrefixKey(const Key &i_key);

	/// search a key by name
	Key *searchKey(const tstringi &i_name);

	/// search a key by non-alias name
	Key *searchKeyByNonAliasName(const tstringi &i_name);

	/// search a substitute
	ModifiedKey searchSubstitute(const ModifiedKey &i_mkey);

	/// get modifiers
	Mods &getModifiers(Modifier::Type i_mt) {
		return m_mods[i_mt];
	}

	/// get key iterator
	KeyIterator getKeyIterator() {
		return KeyIterator(&m_hashedKeys[0], HASHED_KEYS_SIZE);
	}
};


#endif // !_KEYBOARD_H