Input - Added more functionality, custom tag and all-in-one key callback

Code/Misc/Input/Include/InputManager.h

@@ -25,6 +25,11 @@ namespace Input
 			*/
 			static InputManager*			CreateInputManager				();
 
+			/**
+			* @return Destroys the default input manager.
+			*/
+			static void						DestroyInputManager				();
+
 			/**
 			* @return Destroys a input manager.
 			*/

Code/Misc/Input/Include/Keyboard.h

@@ -135,11 +135,23 @@ namespace Input
 		};
 	}
 	//-----------------------------------------------------------------------------------------------------------------------------
+	namespace Struct
+	{
+		struct KeyboardEventData
+		{
+			Enum::SAKI key;
+			Enum::ButtonState state;
+			Keyboard* sender;
+			void* tag;
+		};
+	}
+	//-----------------------------------------------------------------------------------------------------------------------------
 	namespace Typedefs
 	{
-		typedef void(*OnKeyPressCallback)(Enum::SAKI key, Keyboard* sender);
+		typedef void(*OnKeyEventCallback)	(const Struct::KeyboardEventData& eventData);
-		typedef void(*OnKeyDownCallback)(Enum::SAKI key, Keyboard* sender);
+		typedef void(*OnKeyPressCallback)	(Enum::SAKI key, Keyboard* sender, void* tag);
-		typedef void(*OnKeyReleaseCallback)(Enum::SAKI key, Keyboard* sender);
+		typedef void(*OnKeyDownCallback)	(Enum::SAKI key, Keyboard* sender, void* tag);
+		typedef void(*OnKeyReleaseCallback)	(Enum::SAKI key, Keyboard* sender, void* tag);
 	}
 	//-----------------------------------------------------------------------------------------------------------------------------
 
@@ -149,6 +161,7 @@ namespace Input
 		class KeyboardEvent
 		{
 		public:
+			virtual void OnKeyEvent		(const Struct::KeyboardEventData& eventData)	{  }
 			virtual void OnKeyPress		(Enum::SAKI key, Keyboard* sender)				{  }
 			virtual void OnKeyDown		(Enum::SAKI key, Keyboard* sender)				{  }
 			virtual void OnKeyRelease	(Enum::SAKI key, Keyboard* sender)				{  }
@@ -166,18 +179,25 @@ namespace Input
 		virtual void Deactivate () override		= 0;
 		virtual bool IsActive() override		= 0;
 
-	public: /* global subscribe callback functions */
+	public: /* object subscribe functions */
-		void AddOnKeyPressCallback (Typedefs::OnKeyPressCallback func);
+		void AddKeyboardEvent			(KeyboardEvent* object);
-		void AddOnKeyDownCallback (Typedefs::OnKeyDownCallback func);
+		void RemoveKeyboardEvent		(KeyboardEvent* object);
-		void AddOnKeyReleaseCallback (Typedefs::OnKeyReleaseCallback func);
+		void operator+=					(KeyboardEvent* object);
+		void operator-=					(KeyboardEvent* object);
 
+	public: /* global subscribe callback functions */
+		void AddOnKeyEventCallback		(Typedefs::OnKeyEventCallback func, void* tag);
+		void AddOnKeyPressCallback		(Typedefs::OnKeyPressCallback func, void* tag);
+		void AddOnKeyDownCallback		(Typedefs::OnKeyDownCallback func, void* tag);
+		void AddOnKeyReleaseCallback	(Typedefs::OnKeyReleaseCallback func, void* tag);
+
+		void RemoveOnKeyEventCallback	(Typedefs::OnKeyEventCallback func);
 		void RemoveOnKeyPressCallback	(Typedefs::OnKeyPressCallback func);
 		void RemoveOnKeyDownCallback	(Typedefs::OnKeyDownCallback func);
 		void RemoveOnKeyReleaseCallback (Typedefs::OnKeyReleaseCallback func);
 
 	public:
-		void operator+= (KeyboardEvent* object);
+		
-		void operator-= (KeyboardEvent* object);
 
 		void BindTextTarget( ::std::wstring *field );
 		void ReleaseTextTarget();
@@ -189,6 +209,7 @@ namespace Input
 		Keyboard();
 
 	protected: /* Internal event proc */
+		void InternalOnEvent(Struct::KeyboardEventData& data);
 		void InternalOnKeyPress(Enum::SAKI key);
 		void InternalOnKeyDown(Enum::SAKI key);
 		void InternalOnKeyRelease(Enum::SAKI key);

Code/Misc/Input/Source/InputManager.cpp

@@ -57,6 +57,14 @@ InputManager* InputManager::CreateInputManager()
 {
 	return CreateManager();
 }
+void InputManager::DestroyInputManager()
+{
+	if(!defaultInstance) return;
+
+	defaultInstance->Destroy();
+	delete defaultInstance;
+	defaultInstance = 0;
+}
 void InputManager::DestroyInputManager(InputManager* inputSystem)
 {
 	if(!inputSystem) return;

Code/Misc/Input/Source/Keyboard.cpp

@@ -12,12 +12,14 @@ struct Keyboard::KeyboardCallbackList
 {
 	enum CallbackDataType
 	{
+		CallbackDataType_OnEvent,
 		CallbackDataType_OnPress,
 		CallbackDataType_OnDown,
 		CallbackDataType_OnRelease
 	} type;
 	union CallbackData
 	{
+		Typedefs::OnKeyEventCallback	keyEventCallback;
 		Typedefs::OnKeyPressCallback	keyPressCallback;
 		Typedefs::OnKeyDownCallback		keyDownCallback;
 		Typedefs::OnKeyReleaseCallback	keyReleaseCallback;
@@ -29,7 +31,8 @@ struct Keyboard::KeyboardCallbackList
 		operator bool(){ return this->keyDownCallback != 0; }
 	} function;
 	KeyboardCallbackList *next;
-	KeyboardCallbackList(CallbackData func, CallbackDataType t) :function(func), next(0), type(t) { }
+	void* tag;
+	KeyboardCallbackList(CallbackData func, CallbackDataType t, void* ct) :function(func), next(0), type(t), tag(ct) { }
 };
 
 void ClearList(Keyboard::KeyboardCallbackList* first)
@@ -44,7 +47,7 @@ void ClearList(Keyboard::KeyboardCallbackList* first)
 		delete removee;
 	}
 }
-void AddToList(Keyboard::KeyboardCallbackList* first, Keyboard::KeyboardCallbackList::CallbackData data, Keyboard::KeyboardCallbackList::CallbackDataType type)
+void AddToList(Keyboard::KeyboardCallbackList* first, Keyboard::KeyboardCallbackList::CallbackData data, Keyboard::KeyboardCallbackList::CallbackDataType type, void* tag)
 {
 	Keyboard::KeyboardCallbackList *w = first;
 	Keyboard::KeyboardCallbackList *prev = first;
@@ -54,7 +57,7 @@ void AddToList(Keyboard::KeyboardCallbackList* first, Keyboard::KeyboardCallback
 	Keyboard::KeyboardCallbackList::CallbackData f;
 	f = data;
 
-	prev->next = new Keyboard::KeyboardCallbackList(f, type);
+	prev->next = new Keyboard::KeyboardCallbackList(f, type, tag);
 }
 void RemoveFromList(Keyboard::KeyboardCallbackList* first, Keyboard::KeyboardCallbackList::CallbackData data)
 {
@@ -112,6 +115,27 @@ Keyboard::~Keyboard()
 
 }
 
+void Keyboard::InternalOnEvent(Struct::KeyboardEventData& data)
+{
+	for (unsigned int i = 0; i < this->keyEventSubscrivers.size(); i++)
+	{
+		if(this->keyEventSubscrivers[i])
+		{
+			this->keyEventSubscrivers[i]->OnKeyEvent(data);
+		}
+	}
+	KeyboardCallbackList *w = this->callbackList;
+	while (w)
+	{
+		if(w->function)
+			if (w->type == KeyboardCallbackList::CallbackDataType_OnEvent)
+			{
+				data.tag = w->tag;
+				w->function.keyEventCallback(data);
+			}
+		w = w->next;
+	}
+}
 void Keyboard::InternalOnKeyPress(Enum::SAKI key)
 {
 	for (unsigned int i = 0; i < this->keyEventSubscrivers.size(); i++)
@@ -126,7 +150,9 @@ void Keyboard::InternalOnKeyPress(Enum::SAKI key)
 	{
 		if(w->function)
 			if (w->type == KeyboardCallbackList::CallbackDataType_OnPress)
-				w->function.keyPressCallback(key, this);
+			{
+				w->function.keyPressCallback(key, this, w->tag);
+			}
 		w = w->next;
 	}
 }
@@ -144,7 +170,7 @@ void Keyboard::InternalOnKeyDown(Enum::SAKI key)
 	{
 		if(w->function)
 			if (w->type == KeyboardCallbackList::CallbackDataType_OnDown)
-				w->function.keyDownCallback(key, this);
+				w->function.keyDownCallback(key, this, w->tag);
 		w = w->next;
 	}
 }
@@ -162,46 +188,26 @@ void Keyboard::InternalOnKeyRelease(Enum::SAKI key)
 	{
 		if(w->function)
 			if (w->type == KeyboardCallbackList::CallbackDataType_OnRelease)
-				w->function.keyReleaseCallback(key, this);
+				w->function.keyReleaseCallback(key, this, w->tag);
 		w = w->next;
 	}
 }
 
-void Keyboard::AddOnKeyPressCallback (OnKeyPressCallback func)
+void Keyboard::AddKeyboardEvent(KeyboardEvent* object)
 {
-	KeyboardCallbackList::CallbackData d;
+	if(ExistsInList(this->keyEventSubscrivers, object)) return;
-	d.keyPressCallback = func;
-	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnPress);
-	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnPress);
-}
-void Keyboard::AddOnKeyDownCallback (OnKeyDownCallback func)
-{
-	KeyboardCallbackList::CallbackData d;
-	d.keyDownCallback = func;
-	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnDown);
-	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnDown);
-}
-void Keyboard::AddOnKeyReleaseCallback (OnKeyReleaseCallback func)
-{
-	KeyboardCallbackList::CallbackData d;
-	d.keyReleaseCallback = func;
-	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnRelease);
-	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnRelease);
-}
 
-void Keyboard::RemoveOnKeyPressCallback (OnKeyPressCallback func)
+	this->keyEventSubscrivers.push_back(object);
-{
-	RemoveFromList(this->callbackList, func);
 }
-void Keyboard::RemoveOnKeyDownCallback (OnKeyDownCallback func)
+void Keyboard::RemoveKeyboardEvent(KeyboardEvent* object)
 {
-	RemoveFromList(this->callbackList, func);
+	int i = -1;
-}
+	if((i = ExistsInList(this->keyEventSubscrivers, object)))
-void Keyboard::RemoveOnKeyReleaseCallback (OnKeyReleaseCallback func)
 	{
-	RemoveFromList(this->callbackList, func);
+		std::swap(this->keyEventSubscrivers[i], this->keyEventSubscrivers[this->keyEventSubscrivers.size() - 1]);
+		this->keyEventSubscrivers.resize(this->keyEventSubscrivers.size() - 1);
+	}
 }
-
 void Keyboard::operator+= (KeyboardEvent* object)
 {
 	if(ExistsInList(this->keyEventSubscrivers, object)) return;
@@ -218,6 +224,56 @@ void Keyboard::operator-= (KeyboardEvent* object)
 	}
 }
 
+void Keyboard::AddOnKeyEventCallback (OnKeyEventCallback func, void* tag)
+{
+	KeyboardCallbackList::CallbackData d;
+	d.keyEventCallback = func;
+	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnEvent, tag);
+	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnEvent, tag);
+}
+void Keyboard::AddOnKeyPressCallback (OnKeyPressCallback func, void* tag)
+{
+	KeyboardCallbackList::CallbackData d;
+	d.keyPressCallback = func;
+	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnPress, tag);
+	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnPress, tag);
+}
+void Keyboard::AddOnKeyDownCallback (OnKeyDownCallback func, void* tag)
+{
+	KeyboardCallbackList::CallbackData d;
+	d.keyDownCallback = func;
+	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnDown, tag);
+	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnDown, tag);
+}
+void Keyboard::AddOnKeyReleaseCallback (OnKeyReleaseCallback func, void* tag)
+{
+	KeyboardCallbackList::CallbackData d;
+	d.keyReleaseCallback = func;
+	if(!this->callbackList) this->callbackList = new KeyboardCallbackList(d, KeyboardCallbackList::CallbackDataType_OnRelease, tag);
+	else					AddToList(this->callbackList, d, KeyboardCallbackList::CallbackDataType_OnRelease, tag);
+}
+
+void Keyboard::RemoveOnKeyEventCallback (OnKeyEventCallback func)
+{
+	Keyboard::KeyboardCallbackList::CallbackData temp;
+	temp.keyEventCallback = func;
+	RemoveFromList(this->callbackList, temp);
+}
+void Keyboard::RemoveOnKeyPressCallback (OnKeyPressCallback func)
+{
+	RemoveFromList(this->callbackList, func);
+}
+void Keyboard::RemoveOnKeyDownCallback (OnKeyDownCallback func)
+{
+	RemoveFromList(this->callbackList, func);
+}
+void Keyboard::RemoveOnKeyReleaseCallback (OnKeyReleaseCallback func)
+{
+	RemoveFromList(this->callbackList, func);
+}
+
+
+
 void Keyboard::BindTextTarget( ::std::wstring *field )
 {
 	this->textTarget = field;

Code/Misc/Input/Source/Win32/Win32Keyboard.cpp

@@ -66,10 +66,10 @@ void Win32Keyboard::Deactivate ()
 
 void Win32Keyboard::ProccessKeyboardData (RAWKEYBOARD keyboard)
 {
-	if(!this->active)
+	if(!this->active)	return;
-	{
+
-		return;
+	static Struct::KeyboardEventData keyboardEventData;
-	}
+	memset(&keyboardEventData, 0, sizeof(Struct::KeyboardEventData));
 
 	bool isUp = (( keyboard.Flags & RI_KEY_BREAK) != 0);
 	SAKI key = SAKI_Unknown;
@@ -86,6 +86,11 @@ void Win32Keyboard::ProccessKeyboardData (RAWKEYBOARD keyboard)
 			this->keys[key].isDown = false;
 			this->keys[key].isE0 = isE0;
 			this->keys[key].makecode = keyboard.MakeCode;
+
+			keyboardEventData.key = key;
+			keyboardEventData.sender = this;
+			keyboardEventData.state = Enum::ButtonState_Release;
+			InternalOnEvent(keyboardEventData);
 		}
 		//The key is pressed.
 		else /*if (k.Flags == RI_KEY_MAKE || k.Flags == (RI_KEY_MAKE | RI_KEY_E0) || k.Flags == (RI_KEY_MAKE | RI_KEY_E1))*/
@@ -93,6 +98,11 @@ void Win32Keyboard::ProccessKeyboardData (RAWKEYBOARD keyboard)
 			if(this->keys[key].isDown)
 			{
 				this->InternalOnKeyDown(key);
+
+				keyboardEventData.key = key;
+				keyboardEventData.sender = this;
+				keyboardEventData.state = Enum::ButtonState_Down;
+				InternalOnEvent(keyboardEventData);
 			}
 			else
 			{
@@ -100,6 +110,11 @@ void Win32Keyboard::ProccessKeyboardData (RAWKEYBOARD keyboard)
 				this->keys[key].isDown = true;
 				this->keys[key].isE0 = isE0;
 				this->keys[key].makecode = keyboard.MakeCode;
+
+				keyboardEventData.key = key;
+				keyboardEventData.sender = this;
+				keyboardEventData.state = Enum::ButtonState_Press;
+				InternalOnEvent(keyboardEventData);
 			}
 		}
 	}