input.h

VC++ DEMO, used for the beginners and the amour

#ifdef CGE_HEADER_H
#ifndef CGE_INPUT_H
#define CGE_INPUT_H

namespace CGE
{
	namespace INPUT
	{
		enum
		{
			MOUSEBUTTON_NONE = 0x00,
				MOUSEBUTTON_LEFT = 0x01,
				MOUSEBUTTON_RIGHT = 0x02,
				MOUSEBUTTON_MIDDLE = 0x04,
		};

		enum
		{
			MODIFIER_NONE	= 0x00,
				MODIFIER_CTRL	= 0x01,
				MODIFIER_ALT	= 0x02,
				MODIFIER_SHIFT	= 0x04,
		};
		
		enum
		{
			KEY_NONE = 0x00,
				KEY_JUSTPRESSED = 0x01,
				KEY_PRESSED = 0x02,
				KEY_JUSTUNPRESSED = 0x04,
		};
		
		typedef BYTE ModifierState;

		typedef struct MouseKey
		{
			MouseKey(UINT MouseButton = 0,UINT HotKey = 0)
				: m_MouseX(0),m_MouseY(0),m_MouseButton(MouseButton),m_HotKey(HotKey)
			{}
			
			MouseKey & operator = (const MouseKey& Hot)
			{
				m_MouseButton = Hot.m_MouseButton;
				m_HotKey = Hot.m_HotKey;
				m_MouseX = Hot.m_MouseX;
				m_MouseY = Hot.m_MouseY;
				return *this;
			}
			
			CGE_INLINE BOOL	  operator < (const MouseKey & Hot) const
			{
				UINT First;
				First = Pack();
				UINT Second;
				Second = Hot.Pack();
				return ( First < Second );
			}
			
			CGE_INLINE BOOL	  operator == (const MouseKey & Hot) const
			{ 
				return ((m_MouseButton == Hot.m_MouseButton)&&
					(m_MouseX == Hot.m_MouseX)&&
					(m_MouseY == Hot.m_MouseY)); 
			}
			
			CGE_INLINE UINT Pack() const
			{
				UINT nPack;
				nPack = m_HotKey;
				nPack = nPack << 8;
				nPack = nPack | m_MouseButton;
				return nPack;
			}
			
			UINT m_HotKey;
			UINT m_MouseButton;
			LONG m_MouseX;
			LONG m_MouseY;
			
		}*LPMOUSEKEY;
		
		typedef BOOL (*LPHOTSPOTCALLBACK) (UINT,WPARAM,LPARAM);
		
		typedef struct HotSpot
		{
			HotSpot(LONG MinX = 0,LONG MaxX = 0,LONG MinY = 0,LONG MaxY = 0,LPHOTSPOTCALLBACK HotCallback = 0,UINT HotKey = 0,UINT HotID = 0)
				:m_MinX(MinX),m_MaxX(MaxX),m_MinY(MinY),m_MaxY(MaxY),m_HotID(HotID),m_HotKey(HotKey),m_HotSpotCallback(HotCallback)
			{}
			
			UINT m_HotID;
			UINT m_HotKey;
			LONG m_MinX,m_MaxX;
			LONG m_MinY,m_MaxY;
			LPHOTSPOTCALLBACK m_HotSpotCallback;
			
		}*LPHOTSPOT;
		
		typedef std::vector<MouseKey> MOUSEKEYVECTOR;
		typedef std::map<MouseKey,HotSpot> MOUSEHOTKEYMAP;
		
		typedef struct KeyboardKey
		{
			KeyboardKey(BYTE ScanCode = 0, BYTE HotKey = 0,ModifierState Modifier = MODIFIER_NONE) 
				: m_ScanCode(ScanCode), m_Modifier(Modifier),m_HotKey(HotKey)
			{}
			
			KeyboardKey & operator= (const KeyboardKey & Key)
			{
				m_Modifier  = Key.m_Modifier;
				m_ScanCode  = Key.m_ScanCode;
				m_HotKey = Key.m_HotKey;
				return *this;
			}
			
			CGE_INLINE BOOL	operator== (const KeyboardKey & That) const
			{ 
				return ((m_Modifier == That.m_Modifier) && 
					(m_ScanCode == That.m_ScanCode) &&
					(m_HotKey == That.m_HotKey) ); 
			}
			
			CGE_INLINE BOOL	operator< (const KeyboardKey & That) const
			{ 
				UINT First	 = Pack();
				UINT Second = That.Pack();
				return (First < Second); 
			}
			
			CGE_INLINE UINT Pack(VOID) const
			{
				UINT nPack;
				nPack = m_HotKey;
				nPack = nPack << 8;
				nPack = nPack | m_Modifier;
				nPack = nPack << 8;
				nPack = nPack | m_ScanCode;
				return nPack;
			}
			BYTE					m_HotKey;
			BYTE					m_ScanCode;
			ModifierState			m_Modifier;
		}*LPKEYBOARDKEY;
		
		typedef BOOL ( * LPHOTKEYCALLBACK ) (UINT,WPARAM,LPARAM);
		
		typedef struct HotKey
		{
			HotKey(LPHOTKEYCALLBACK HotKeyCallback = 0,UINT nHotKey = 0,UINT HotID = 0)
				:m_HotKey(nHotKey),m_HotKeyCallback(HotKeyCallback),m_HotID(HotID)
			{}
			UINT m_HotID;
			UINT m_HotKey;
			LPHOTKEYCALLBACK m_HotKeyCallback;
		}*LPHOTKEY;
		
		typedef std::vector<KeyboardKey> KEYVECTOR;
		typedef std::map<KeyboardKey,HotKey> KEYBOARDMAP;

		typedef class CONSOLE  
		{
			public:
				CONSOLE();
				virtual ~CONSOLE();
				BOOL Create();	
				BOOL CreateMouse();
				BOOL CreateKeyboard();
				BOOL UpdateMouse();
				BOOL UpdateKeyboard();
				VOID ReleaseKeyboardHotKey(KeyboardKey Key);
				VOID ReleaseMouseHotSpot(MouseKey MouseKey);
				BOOL SetKeyboardBehavior(VOID *hWnd, DWORD dwBehavior);
				BOOL SetMouseBehavior(VOID *hWnd, DWORD dwBehavior);
				VOID SetKeyboardHotKey(const KeyboardKey & Key,const HotKey & HotKey);
				VOID SetMouseHotSpot(const MouseKey & MouseKey,const HotSpot & HotSpot);
				VOID SetMouseSpeed( BYTE nMouseSpeed ) { m_d3dMouseSpeed = nMouseSpeed; }
				BYTE GetMosueSpeed() { return m_d3dMouseSpeed; }
			private:
				VOID KeyboardHotKey();
				VOID MouseHotSpot();
				ModifierState GetModifierState( BYTE  nScanCode);
			private:
				LPDIRECTINPUT8              m_pDI;
				LPDIRECTINPUTDEVICE8        m_pKeyboard;
				LPDIRECTINPUTDEVICE8        m_pMouse;
				ModifierState               m_ModifierState;
				KEYBOARDMAP					m_d3dKeyboard;
				MOUSEHOTKEYMAP				m_d3dMouse;
				UINT						m_d3dMouseSpeed;
			public:
				KEYVECTOR					m_d3dKeyPressed;
				KEYVECTOR					m_d3dKeyJustPressed;
				KEYVECTOR					m_d3dKeyJustUnPressed;
				
				MOUSEKEYVECTOR				m_d3dMouseKeyJustPressed;
				MOUSEKEYVECTOR				m_d3dMouseKeyPressed;
				MOUSEKEYVECTOR				m_d3dMouseKeyJustUnPressed;
				static LONG					m_MouseX;
				static LONG					m_MouseY;
				static LONG					m_MouseDeltaX;
				static LONG					m_MouseDeltaY;
				
		} *LPCONSOLE;
	}
}
#endif
#endif