From 80c74b90a3e44e25a4fa9fdd25bf0aa9efbaf6fd Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Mon, 11 Nov 2024 16:12:09 +0100
Subject: interfaces working but unsubscribe broken

---
 src/crepe/api/CMakeLists.txt | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'src/crepe/api/CMakeLists.txt')

diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index 87cbb09..4e8f8a0 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -18,6 +18,10 @@ target_sources(crepe PUBLIC
 	Vector2.cpp
 	Camera.cpp
 	Animator.cpp
+	EventManager.cpp
+	EventHandler.cpp
+	IKeyListener.cpp
+	IMouseListener.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
@@ -42,4 +46,9 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	SceneManager.hpp
 	Camera.h
 	Animator.h
+	EventManager.h
+	EventHandler.h
+	Event.h
+	IKeyListener.h
+	IMouseListener.h
 )
-- 
cgit v1.2.3


From cab672ce6258aec563e7f0e0549281156c0c8d21 Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Fri, 15 Nov 2024 12:43:38 +0100
Subject: feedback

---
 src/crepe/api/CMakeLists.txt     |  14 ++++
 src/crepe/api/Event.h            |  13 ++--
 src/crepe/api/EventHandler.h     |   1 +
 src/crepe/api/EventManager.cpp   |   3 +
 src/crepe/api/EventManager.h     | 142 ++-------------------------------------
 src/crepe/api/EventManager.hpp   | 140 ++++++++++++++++++++++++++++++++++++++
 src/crepe/api/IKeyListener.cpp   |   4 +-
 src/crepe/api/IMouseListener.cpp |  10 ++-
 src/crepe/api/KeyCodes.h         |   1 -
 src/example/events.cpp           |  10 ++-
 10 files changed, 187 insertions(+), 151 deletions(-)
 create mode 100644 src/crepe/api/EventManager.hpp

(limited to 'src/crepe/api/CMakeLists.txt')

diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index 87cbb09..53b3041 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -18,6 +18,12 @@ target_sources(crepe PUBLIC
 	Vector2.cpp
 	Camera.cpp
 	Animator.cpp
+	EventManager.cpp
+	EventHandler.cpp
+	IKeyListener.cpp
+	IMouseListener.cpp
+	LoopManager.cpp
+	LoopTimer.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
@@ -42,4 +48,12 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	SceneManager.hpp
 	Camera.h
 	Animator.h
+	EventManager.h
+	EventManager.hpp
+	EventHandler.h
+	Event.h
+	IKeyListener.h
+	IMouseListener.h
+	LoopManager.h
+	LoopTimer.h
 )
diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index cffa5da..701ecdf 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -6,38 +6,37 @@
 
 class Event {
 public:
-	bool handled = false;
 };
 
 class KeyPressEvent : public Event {
 public:
 	int repeat = 0;
-	Keycode key = Keycode::None;
+	Keycode key = Keycode::NONE;
 };
 
 class KeyReleaseEvent : public Event {
 public:
-	Keycode key = Keycode::None;
+	Keycode key = Keycode::NONE;
 };
 
 class MousePressEvent : public Event {
 public:
 	int mouse_x = 0;
 	int mouse_y = 0;
-	MouseButton button;
+	MouseButton button = MouseButton::NONE;
 };
 
 class MouseClickEvent : public Event {
 public:
 	int mouse_x = 0;
 	int mouse_y = 0;
-	MouseButton button;
+	MouseButton button = MouseButton::NONE;
 };
 class MouseReleaseEvent : public Event {
 public:
 	int mouse_x = 0;
 	int mouse_y = 0;
-	MouseButton button = MouseButton::None;
+	MouseButton button = MouseButton::NONE;
 };
 class MouseMoveEvent : public Event {
 public:
@@ -50,7 +49,7 @@ public:
 };
 class TextSubmitEvent : public Event {
 public:
-	std::string text;
+	std::string text = "";
 };
 class ShutDownEvent : public Event {
 public:
diff --git a/src/crepe/api/EventHandler.h b/src/crepe/api/EventHandler.h
index 46c6c7b..0ab90de 100644
--- a/src/crepe/api/EventHandler.h
+++ b/src/crepe/api/EventHandler.h
@@ -12,6 +12,7 @@
  * 
  * \tparam EventType The type of event this handler will handle.
  */
+// TODO: typedef
 template <typename EventType>
 using EventHandler = std::function<bool(const EventType & e)>;
 
diff --git a/src/crepe/api/EventManager.cpp b/src/crepe/api/EventManager.cpp
index 72cfd74..e881d49 100644
--- a/src/crepe/api/EventManager.cpp
+++ b/src/crepe/api/EventManager.cpp
@@ -1,5 +1,7 @@
 #include "EventManager.h"
 
+using namespace crepe;
+
 EventManager & EventManager::get_instance() {
 	static EventManager instance;
 	return instance;
@@ -62,6 +64,7 @@ void EventManager::dispatch_events() {
 						 iterator handler_it
 					 = handlers.begin();
 					 handler_it != handlers.end(); ++handler_it) {
+					// remove event from queue since and continue when callback returns true
 					if ((*handler_it)->exec(*event)) {
 						event_it = this->events_queue.erase(event_it);
 						event_handled = true;
diff --git a/src/crepe/api/EventManager.h b/src/crepe/api/EventManager.h
index e2665bd..38d2e64 100644
--- a/src/crepe/api/EventManager.h
+++ b/src/crepe/api/EventManager.h
@@ -10,6 +10,8 @@
 #include "Event.h"
 #include "EventHandler.h"
 
+
+namespace crepe {
 /**
  * \class EventManager
  * \brief The EventManager class is responsible for managing the subscription, triggering, 
@@ -115,142 +117,6 @@ private:
 						   std::vector<std::unique_ptr<IEventHandlerWrapper>>>>
 		subscribers_by_event_id;
 };
-template <typename EventType>
-void EventManager::subscribe(EventHandler<EventType> && callback, int channel) {
-	std::type_index event_type = typeid(EventType);
-	std::unique_ptr<EventHandlerWrapper<EventType>> handler
-		= std::make_unique<EventHandlerWrapper<EventType>>(callback);
-
-	if (channel) {
-		std::unordered_map<int,
-						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
-			handlers_map
-			= this->subscribers_by_event_id[event_type];
-		std::unordered_map<
-			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-			handlers
-			= handlers_map.find(channel);
-		if (handlers != handlers_map.end()) {
-			handlers->second.emplace_back(std::move(handler));
-		} else {
-			handlers_map[channel].emplace_back(std::move(handler));
-		}
-	} else {
-		std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
-			= this->subscribers[event_type];
-		handlers.emplace_back(std::move(handler));
-	}
-}
-
-template <typename EventType>
-void EventManager::queue_event(EventType && event, int channel) {
-	std::type_index event_type = std::type_index(typeid(EventType));
-
-	std::unique_ptr<EventType> event_ptr
-		= std::make_unique<EventType>(std::forward<EventType>(event));
-
-	std::tuple<std::unique_ptr<Event>, int, std::type_index> tuple(
-		std::move(event_ptr), channel, event_type);
-	this->events_queue.push_back(std::move(tuple));
-}
-
-template <typename EventType>
-void EventManager::trigger_event(const EventType & event, int channel) {
-	std::type_index event_type = std::type_index(typeid(EventType));
-
-	if (channel > 0) {
-		std::unordered_map<int,
-						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
-			handlers_map
-			= this->subscribers_by_event_id[event_type];
-		std::unordered_map<
-			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-			handlers_it
-			= handlers_map.find(channel);
-
-		if (handlers_it != handlers_map.end()) {
-			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
-				= handlers_it->second;
-			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
-				 = handlers.begin();
-				 it != handlers.end();) {
-				// erases callback if callback function returns true
-				if ((*it)->exec(event)) {
-					it = handlers.erase(it);
-				} else {
-					++it;
-				}
-			}
-		}
-	} else {
-		std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
-			= this->subscribers[event_type];
-		for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
-			 = handlers.begin();
-			 it != handlers.end();) {
-			// erases callback if callback function returns true
-			if ((*it)->exec(event)) {
-				it = handlers.erase(it);
-			} else {
-				++it;
-			}
-		}
-	}
-}
-
-template <typename EventType>
-void EventManager::unsubscribe(const EventHandler<EventType> & callback,
-							   int channel) {
-	std::type_index event_type(typeid(EventType));
-	std::string handler_name = callback.target_type().name();
 
-	if (channel) {
-		std::unordered_map<
-			std::type_index,
-			std::unordered_map<
-				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
-			iterator subscriber_list
-			= this->subscribers_by_event_id.find(event_type);
-		if (subscriber_list != this->subscribers_by_event_id.end()) {
-			std::unordered_map<
-				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
-				handlers_map
-				= subscriber_list->second;
-			std::unordered_map<
-				int,
-				std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-				handlers
-				= handlers_map.find(channel);
-			if (handlers != handlers_map.end()) {
-				std::vector<std::unique_ptr<IEventHandlerWrapper>> & callbacks
-					= handlers->second;
-				for (std::vector<
-						 std::unique_ptr<IEventHandlerWrapper>>::iterator it
-					 = callbacks.begin();
-					 it != callbacks.end(); ++it) {
-					if ((*it)->get_type() == handler_name) {
-						it = callbacks.erase(it);
-						return;
-					}
-				}
-			}
-		}
-	} else {
-		std::unordered_map<std::type_index,
-						   std::vector<std::unique_ptr<IEventHandlerWrapper>>>::
-			iterator handlers_it
-			= this->subscribers.find(event_type);
-		if (handlers_it != this->subscribers.end()) {
-			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
-				= handlers_it->second;
-			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
-				 = handlers.begin();
-				 it != handlers.end(); ++it) {
-				if ((*it)->get_type() == handler_name) {
-					it = handlers.erase(it);
-					return;
-				}
-			}
-		}
-	}
-}
+} // namespace crepe
+#include "EventManager.hpp"
diff --git a/src/crepe/api/EventManager.hpp b/src/crepe/api/EventManager.hpp
new file mode 100644
index 0000000..b509097
--- /dev/null
+++ b/src/crepe/api/EventManager.hpp
@@ -0,0 +1,140 @@
+#include "EventManager.h"
+namespace crepe {
+
+template <typename EventType>
+void EventManager::subscribe(EventHandler<EventType> && callback, int channel) {
+	std::type_index event_type = typeid(EventType);
+	std::unique_ptr<EventHandlerWrapper<EventType>> handler
+		= std::make_unique<EventHandlerWrapper<EventType>>(callback);
+
+	if (channel) {
+		std::unordered_map<int,
+						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
+			handlers_map
+			= this->subscribers_by_event_id[event_type];
+		std::unordered_map<
+			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
+			handlers
+			= handlers_map.find(channel);
+		if (handlers != handlers_map.end()) {
+			handlers->second.emplace_back(std::move(handler));
+		} else {
+			handlers_map[channel].emplace_back(std::move(handler));
+		}
+	} else {
+		std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
+			= this->subscribers[event_type];
+		handlers.emplace_back(std::move(handler));
+	}
+}
+
+template <typename EventType>
+void EventManager::queue_event(EventType && event, int channel) {
+	std::type_index event_type = std::type_index(typeid(EventType));
+
+	std::unique_ptr<EventType> event_ptr
+		= std::make_unique<EventType>(std::forward<EventType>(event));
+
+	std::tuple<std::unique_ptr<Event>, int, std::type_index> tuple(
+		std::move(event_ptr), channel, event_type);
+	this->events_queue.push_back(std::move(tuple));
+}
+
+template <typename EventType>
+void EventManager::trigger_event(const EventType & event, int channel) {
+	std::type_index event_type = std::type_index(typeid(EventType));
+
+	if (channel > 0) {
+		std::unordered_map<int,
+						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
+			handlers_map
+			= this->subscribers_by_event_id[event_type];
+		std::unordered_map<
+			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
+			handlers_it
+			= handlers_map.find(channel);
+
+		if (handlers_it != handlers_map.end()) {
+			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
+				= handlers_it->second;
+			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
+				 = handlers.begin();
+				 it != handlers.end();++it) {
+				// stops when callback returns true
+				if((*it)->exec(event)){
+					break;
+				}
+			}
+		}
+	} else {
+		std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
+			= this->subscribers[event_type];
+		for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
+			 = handlers.begin();
+			 it != handlers.end();++it) {
+			// stops when callback returns true
+			if((*it)->exec(event)){
+					break;
+				}
+		}
+	}
+}
+
+template <typename EventType>
+void EventManager::unsubscribe(const EventHandler<EventType> & callback,
+							   int channel) {
+	std::type_index event_type(typeid(EventType));
+	std::string handler_name = callback.target_type().name();
+
+	if (channel) {
+		std::unordered_map<
+			std::type_index,
+			std::unordered_map<
+				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
+			iterator subscriber_list
+			= this->subscribers_by_event_id.find(event_type);
+		if (subscriber_list != this->subscribers_by_event_id.end()) {
+			std::unordered_map<
+				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
+				handlers_map
+				= subscriber_list->second;
+			std::unordered_map<
+				int,
+				std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
+				handlers
+				= handlers_map.find(channel);
+			if (handlers != handlers_map.end()) {
+				std::vector<std::unique_ptr<IEventHandlerWrapper>> & callbacks
+					= handlers->second;
+				for (std::vector<
+						 std::unique_ptr<IEventHandlerWrapper>>::iterator it
+					 = callbacks.begin();
+					 it != callbacks.end(); ++it) {
+					if ((*it)->get_type() == handler_name) {
+						it = callbacks.erase(it);
+						return;
+					}
+				}
+			}
+		}
+	} else {
+		std::unordered_map<std::type_index,
+						   std::vector<std::unique_ptr<IEventHandlerWrapper>>>::
+			iterator handlers_it
+			= this->subscribers.find(event_type);
+		if (handlers_it != this->subscribers.end()) {
+			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
+				= handlers_it->second;
+			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
+				 = handlers.begin();
+				 it != handlers.end(); ++it) {
+				if ((*it)->get_type() == handler_name) {
+					it = handlers.erase(it);
+					return;
+				}
+			}
+		}
+	}
+}
+
+}
diff --git a/src/crepe/api/IKeyListener.cpp b/src/crepe/api/IKeyListener.cpp
index eb8f9af..4fd9855 100644
--- a/src/crepe/api/IKeyListener.cpp
+++ b/src/crepe/api/IKeyListener.cpp
@@ -1,5 +1,7 @@
 #include "IKeyListener.h"
-#include <iostream>
+
+using namespace crepe;
+
 IKeyListener::IKeyListener() {
 	this->channel = channel;
 	this->subscribe_events();
diff --git a/src/crepe/api/IMouseListener.cpp b/src/crepe/api/IMouseListener.cpp
index 683632c..489e55b 100644
--- a/src/crepe/api/IMouseListener.cpp
+++ b/src/crepe/api/IMouseListener.cpp
@@ -1,6 +1,11 @@
 #include "IMouseListener.h"
+
+using namespace crepe;
+
 IMouseListener::IMouseListener(int channel) { this->channel = channel; }
+
 IMouseListener::IMouseListener() { this->subscribe_events(); }
+
 IMouseListener::~IMouseListener() { this->unsubscribe_events(); }
 
 void IMouseListener::subscribe_events() {
@@ -26,7 +31,7 @@ void IMouseListener::subscribe_events() {
 	EventManager::get_instance().subscribe<MouseMoveEvent>(
 		std::move(this->mouse_move_handler), this->channel);
 }
-
+// TODO: reference voor singleton
 void IMouseListener::unsubscribe_events() {
 	EventManager::get_instance().unsubscribe<MouseClickEvent>(
 		this->mouse_click_handler, this->channel);
@@ -37,18 +42,21 @@ void IMouseListener::unsubscribe_events() {
 	EventManager::get_instance().unsubscribe<MouseMoveEvent>(
 		this->mouse_move_handler, this->channel);
 }
+
 void IMouseListener::activate_mouse() {
 	if (this->active) {
 		return;
 	}
 	this->subscribe_events();
 }
+
 void IMouseListener::deactivate_mouse() {
 	if (!this->active) {
 		return;
 	}
 	this->unsubscribe_events();
 }
+
 void IMouseListener::set_channel(int channel) {
 	this->unsubscribe_events();
 	this->channel = channel;
diff --git a/src/crepe/api/KeyCodes.h b/src/crepe/api/KeyCodes.h
index 1cb1a8a..e5a91fc 100644
--- a/src/crepe/api/KeyCodes.h
+++ b/src/crepe/api/KeyCodes.h
@@ -12,7 +12,6 @@ enum class MouseButton {
 };
 
 enum class Keycode : int {
-	// From glfw3.h
 	NONE = 0,
 	SPACE = 32,
 	APOSTROPHE = 39, /* ' */
diff --git a/src/example/events.cpp b/src/example/events.cpp
index 51c9a37..9c59bb7 100644
--- a/src/example/events.cpp
+++ b/src/example/events.cpp
@@ -70,7 +70,7 @@ int main() {
 	key_press.key = Keycode::A;
 	key_press.repeat = 0;
 	MouseClickEvent click_event;
-	click_event.button = MouseButton::Left_Mouse;
+	click_event.button = MouseButton::LEFT_MOUSE;
 	click_event.mouse_x = 100;
 	click_event.mouse_y = 200;
 	// queue events to test queue
@@ -89,8 +89,12 @@ int main() {
 
 		// Trigger the events while `testListener` is in scope
 		EventManager::get_instance().trigger_event<KeyPressEvent>(key_press, 1);
-		EventManager::get_instance().trigger_event<MouseClickEvent>(click_event,
-																	1);
+		// EventManager::get_instance().trigger_event<MouseClickEvent>(MouseClickEvent{
+		// 	.button = MouseButton::LEFT_MOUSE,
+		// 	.mouse_y = 100,
+		// 	.mouse_x = 100,
+			
+		// },1);
 	}
 	// custom lambda event handler
 	EventHandler<KeyPressEvent> event_handler = [](const KeyPressEvent & e) {
-- 
cgit v1.2.3


From 6e7003c73110cf9ad7e4c72de703dfdc2292d8ca Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Sat, 16 Nov 2024 13:55:47 +0100
Subject: added hpp files and auto

---
 src/crepe/api/CMakeLists.txt   |  3 +-
 src/crepe/api/Event.h          | 94 ++++++++++++++++++++++++++++++++++--------
 src/crepe/api/EventHandler.cpp |  8 +++-
 src/crepe/api/EventHandler.h   | 53 +++++++++++++-----------
 src/crepe/api/EventHandler.hpp | 25 +++++++++++
 src/crepe/api/EventManager.hpp | 42 +++++--------------
 src/crepe/api/IKeyListener.h   |  3 ++
 src/crepe/api/IMouseListener.h |  3 ++
 8 files changed, 155 insertions(+), 76 deletions(-)
 create mode 100644 src/crepe/api/EventHandler.hpp

(limited to 'src/crepe/api/CMakeLists.txt')

diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index 53b3041..edf4250 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -19,11 +19,11 @@ target_sources(crepe PUBLIC
 	Camera.cpp
 	Animator.cpp
 	EventManager.cpp
-	EventHandler.cpp
 	IKeyListener.cpp
 	IMouseListener.cpp
 	LoopManager.cpp
 	LoopTimer.cpp
+	EventHandler.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
@@ -51,6 +51,7 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	EventManager.h
 	EventManager.hpp
 	EventHandler.h
+	EventHandler.hpp
 	Event.h
 	IKeyListener.h
 	IMouseListener.h
diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 701ecdf..e7cac25 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -1,56 +1,116 @@
 #pragma once
-#include "KeyCodes.h"
+
 #include <iostream>
 #include <string>
 #include <typeindex>
 
+#include "KeyCodes.h"
+/**
+ * \brief Base class for all event types in the system.
+ */
 class Event {
 public:
 };
 
+/**
+ * \brief Event triggered when a key is pressed.
+ */
 class KeyPressEvent : public Event {
 public:
-	int repeat = 0;
-	Keycode key = Keycode::NONE;
+    //! Number of times the key press is repeated (e.g., for long presses).
+    int repeat = 0;
+
+    //! The key that was pressed.
+    Keycode key = Keycode::NONE;
 };
 
+/**
+ * \brief Event triggered when a key is released.
+ */
 class KeyReleaseEvent : public Event {
 public:
-	Keycode key = Keycode::NONE;
+    //! The key that was released.
+    Keycode key = Keycode::NONE;
 };
 
+/**
+ * \brief Event triggered when a mouse button is pressed.
+ */
 class MousePressEvent : public Event {
 public:
-	int mouse_x = 0;
-	int mouse_y = 0;
-	MouseButton button = MouseButton::NONE;
+    //! X-coordinate of the mouse position at the time of the event.
+    int mouse_x = 0;
+
+    //! Y-coordinate of the mouse position at the time of the event.
+    int mouse_y = 0;
+
+    //! The mouse button that was pressed.
+    MouseButton button = MouseButton::NONE;
 };
 
+/**
+ * \brief Event triggered when a mouse button is clicked (press and release).
+ */
 class MouseClickEvent : public Event {
 public:
-	int mouse_x = 0;
-	int mouse_y = 0;
-	MouseButton button = MouseButton::NONE;
+    //! X-coordinate of the mouse position at the time of the event.
+    int mouse_x = 0;
+
+    //! Y-coordinate of the mouse position at the time of the event.
+    int mouse_y = 0;
+
+    //! The mouse button that was clicked.
+    MouseButton button = MouseButton::NONE;
 };
+
+/**
+ * \brief Event triggered when a mouse button is released.
+ */
 class MouseReleaseEvent : public Event {
 public:
-	int mouse_x = 0;
-	int mouse_y = 0;
-	MouseButton button = MouseButton::NONE;
+    //! X-coordinate of the mouse position at the time of the event.
+    int mouse_x = 0;
+
+    //! Y-coordinate of the mouse position at the time of the event.
+    int mouse_y = 0;
+
+    //! The mouse button that was released.
+    MouseButton button = MouseButton::NONE;
 };
+
+/**
+ * \brief Event triggered when the mouse is moved.
+ */
 class MouseMoveEvent : public Event {
 public:
-	int mouse_x = 0;
-	int mouse_y = 0;
+    //! X-coordinate of the mouse position at the time of the event.
+    int mouse_x = 0;
+
+    //! Y-coordinate of the mouse position at the time of the event.
+    int mouse_y = 0;
 };
+
+/**
+ * \brief Event triggered during a collision between objects.
+ */
 class CollisionEvent : public Event {
 public:
-	//Collision collisionData;
+    //! Data describing the collision (currently not implemented).
+    // Collision collisionData;
 };
+
+/**
+ * \brief Event triggered when text is submitted, e.g., from a text input.
+ */
 class TextSubmitEvent : public Event {
 public:
-	std::string text = "";
+    //! The submitted text.
+    std::string text = "";
 };
+
+/**
+ * \brief Event triggered to indicate the application is shutting down.
+ */
 class ShutDownEvent : public Event {
 public:
 };
diff --git a/src/crepe/api/EventHandler.cpp b/src/crepe/api/EventHandler.cpp
index 93a116a..d90d765 100644
--- a/src/crepe/api/EventHandler.cpp
+++ b/src/crepe/api/EventHandler.cpp
@@ -1,2 +1,8 @@
 #include "EventHandler.h"
-bool IEventHandlerWrapper::exec(const Event & e) { return call(e); }
+
+using namespace crepe;
+
+// Implementation of IEventHandlerWrapper::exec
+bool IEventHandlerWrapper::exec(const Event & e) {
+    return call(e);
+}
diff --git a/src/crepe/api/EventHandler.h b/src/crepe/api/EventHandler.h
index 0ab90de..2a684c0 100644
--- a/src/crepe/api/EventHandler.h
+++ b/src/crepe/api/EventHandler.h
@@ -1,9 +1,11 @@
 #pragma once
-#include "Event.h"
+
 #include <functional>
-#include <iostream>
-#include <typeindex>
+#include <string>
+
+#include "Event.h"
 
+namespace crepe {
 /**
  * \brief A type alias for an event handler function.
  * 
@@ -12,7 +14,6 @@
  * 
  * \tparam EventType The type of event this handler will handle.
  */
-// TODO: typedef
 template <typename EventType>
 using EventHandler = std::function<bool(const EventType & e)>;
 
@@ -25,12 +26,12 @@ using EventHandler = std::function<bool(const EventType & e)>;
  */
 class IEventHandlerWrapper {
 public:
-	/**
+    /**
      * \brief Virtual destructor for IEventHandlerWrapper.
      */
-	virtual ~IEventHandlerWrapper() = default;
+    virtual ~IEventHandlerWrapper() = default;
 
-	/**
+    /**
      * \brief Executes the handler with the given event.
      * 
      * This method calls the `call()` method of the derived class, passing the event to the handler.
@@ -38,19 +39,19 @@ public:
      * \param e The event to be processed.
      * \return A boolean value indicating whether the event is handled.
      */
-	bool exec(const Event & e);
+    bool exec(const Event & e);
 
-	/**
+    /**
      * \brief Get the type of the event handler.
      * 
      * This method returns the type of the event handler as a string.
      * 
      * \return A string representing the handler's type.
      */
-	virtual std::string get_type() const = 0;
+    virtual std::string get_type() const = 0;
 
 private:
-	/**
+    /**
      * \brief The method responsible for handling the event.
      * 
      * This method is implemented by derived classes to process the event.
@@ -58,7 +59,7 @@ private:
      * \param e The event to be processed.
      * \return A boolean value indicating whether the event is handled.
      */
-	virtual bool call(const Event & e) = 0;
+    virtual bool call(const Event & e) = 0;
 };
 
 /**
@@ -74,18 +75,17 @@ private:
 template <typename EventType>
 class EventHandlerWrapper : public IEventHandlerWrapper {
 public:
-	/**
+    /**
      * \brief Constructs an EventHandlerWrapper with a given handler.
      * 
      * The constructor takes an event handler function and stores it in the wrapper.
      * 
      * \param handler The event handler function.
      */
-	explicit EventHandlerWrapper(const EventHandler<EventType> & handler)
-		: m_handler(handler), m_handler_type(m_handler.target_type().name()) {}
+    explicit EventHandlerWrapper(const EventHandler<EventType> & handler);
 
 private:
-	/**
+    /**
      * \brief Calls the stored event handler with the event.
      * 
      * This method casts the event to the appropriate type and calls the handler.
@@ -93,20 +93,23 @@ private:
      * \param e The event to be handled.
      * \return A boolean value indicating whether the event is handled.
      */
-	bool call(const Event & e) override {
-		return m_handler(static_cast<const EventType &>(e));
-	}
+    bool call(const Event & e) override;
 
-	/**
+    /**
      * \brief Returns the type of the handler.
      * 
      * This method returns a string representing the type of the event handler.
      * 
      * \return The handler type as a string.
      */
-	std::string get_type() const override { return m_handler_type; }
-	//! The event handler function.
-	EventHandler<EventType> m_handler;
-	//! The type name of the handler function.
-	const std::string m_handler_type;
+    std::string get_type() const override;
+
+    //! The event handler function.
+    EventHandler<EventType> m_handler;
+    //! The type name of the handler function.
+    const std::string m_handler_type;
 };
+
+} // namespace crepe
+
+#include "EventHandler.hpp"
diff --git a/src/crepe/api/EventHandler.hpp b/src/crepe/api/EventHandler.hpp
new file mode 100644
index 0000000..1b5702e
--- /dev/null
+++ b/src/crepe/api/EventHandler.hpp
@@ -0,0 +1,25 @@
+
+#include <typeindex>
+
+#include "EventHandler.h"
+
+namespace crepe {
+
+// Implementation of EventHandlerWrapper constructor
+template <typename EventType>
+EventHandlerWrapper<EventType>::EventHandlerWrapper(const EventHandler<EventType> & handler)
+    : m_handler(handler), m_handler_type(m_handler.target_type().name()) {}
+
+// Implementation of EventHandlerWrapper::call
+template <typename EventType>
+bool EventHandlerWrapper<EventType>::call(const Event & e) {
+    return m_handler(static_cast<const EventType &>(e));
+}
+
+// Implementation of EventHandlerWrapper::get_type
+template <typename EventType>
+std::string EventHandlerWrapper<EventType>::get_type() const {
+    return m_handler_type;
+}
+
+} //namespace crepe
diff --git a/src/crepe/api/EventManager.hpp b/src/crepe/api/EventManager.hpp
index b509097..70f0a31 100644
--- a/src/crepe/api/EventManager.hpp
+++ b/src/crepe/api/EventManager.hpp
@@ -12,10 +12,7 @@ void EventManager::subscribe(EventHandler<EventType> && callback, int channel) {
 						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
 			handlers_map
 			= this->subscribers_by_event_id[event_type];
-		std::unordered_map<
-			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-			handlers
-			= handlers_map.find(channel);
+		auto handlers = handlers_map.find(channel);
 		if (handlers != handlers_map.end()) {
 			handlers->second.emplace_back(std::move(handler));
 		} else {
@@ -49,16 +46,12 @@ void EventManager::trigger_event(const EventType & event, int channel) {
 						   std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
 			handlers_map
 			= this->subscribers_by_event_id[event_type];
-		std::unordered_map<
-			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-			handlers_it
-			= handlers_map.find(channel);
+		auto handlers_it = handlers_map.find(channel);
 
 		if (handlers_it != handlers_map.end()) {
 			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
 				= handlers_it->second;
-			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
-				 = handlers.begin();
+			for (auto it = handlers.begin();
 				 it != handlers.end();++it) {
 				// stops when callback returns true
 				if((*it)->exec(event)){
@@ -69,7 +62,7 @@ void EventManager::trigger_event(const EventType & event, int channel) {
 	} else {
 		std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
 			= this->subscribers[event_type];
-		for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
+		for (auto it
 			 = handlers.begin();
 			 it != handlers.end();++it) {
 			// stops when callback returns true
@@ -87,28 +80,17 @@ void EventManager::unsubscribe(const EventHandler<EventType> & callback,
 	std::string handler_name = callback.target_type().name();
 
 	if (channel) {
-		std::unordered_map<
-			std::type_index,
-			std::unordered_map<
-				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
-			iterator subscriber_list
-			= this->subscribers_by_event_id.find(event_type);
+		auto subscriber_list = this->subscribers_by_event_id.find(event_type);
 		if (subscriber_list != this->subscribers_by_event_id.end()) {
 			std::unordered_map<
 				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
 				handlers_map
 				= subscriber_list->second;
-			std::unordered_map<
-				int,
-				std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
-				handlers
-				= handlers_map.find(channel);
+				auto handlers = handlers_map.find(channel);
 			if (handlers != handlers_map.end()) {
 				std::vector<std::unique_ptr<IEventHandlerWrapper>> & callbacks
 					= handlers->second;
-				for (std::vector<
-						 std::unique_ptr<IEventHandlerWrapper>>::iterator it
-					 = callbacks.begin();
+				for (auto it = callbacks.begin();
 					 it != callbacks.end(); ++it) {
 					if ((*it)->get_type() == handler_name) {
 						it = callbacks.erase(it);
@@ -118,15 +100,11 @@ void EventManager::unsubscribe(const EventHandler<EventType> & callback,
 			}
 		}
 	} else {
-		std::unordered_map<std::type_index,
-						   std::vector<std::unique_ptr<IEventHandlerWrapper>>>::
-			iterator handlers_it
-			= this->subscribers.find(event_type);
+		auto handlers_it = this->subscribers.find(event_type);
 		if (handlers_it != this->subscribers.end()) {
 			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
 				= handlers_it->second;
-			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
-				 = handlers.begin();
+			for (auto it = handlers.begin();
 				 it != handlers.end(); ++it) {
 				if ((*it)->get_type() == handler_name) {
 					it = handlers.erase(it);
@@ -137,4 +115,4 @@ void EventManager::unsubscribe(const EventHandler<EventType> & callback,
 	}
 }
 
-}
+} // namespace crepe
diff --git a/src/crepe/api/IKeyListener.h b/src/crepe/api/IKeyListener.h
index 839acbf..5a2cafa 100644
--- a/src/crepe/api/IKeyListener.h
+++ b/src/crepe/api/IKeyListener.h
@@ -3,6 +3,7 @@
 #include "EventHandler.h"
 #include "EventManager.h"
 
+namespace crepe {
 /**
  * \class IKeyListener
  * \brief Interface for keyboard event handling in the application.
@@ -76,3 +77,5 @@ private:
 	//!< Key release event handler.
 	EventHandler<KeyReleaseEvent> key_released_handler;
 };
+
+} // namespace crepe
diff --git a/src/crepe/api/IMouseListener.h b/src/crepe/api/IMouseListener.h
index 7e92956..1df55af 100644
--- a/src/crepe/api/IMouseListener.h
+++ b/src/crepe/api/IMouseListener.h
@@ -4,6 +4,7 @@
 #include "EventHandler.h"
 #include "EventManager.h"
 
+namespace crepe {
 /**
  * \class IMouseListener
  * \brief Interface for mouse event handling in the application.
@@ -115,3 +116,5 @@ private:
 	//! Mouse move event handler.
 	EventHandler<MouseMoveEvent> mouse_move_handler;
 };
+
+} //namespace crepe
-- 
cgit v1.2.3