most tests done

11 files changed, 71 insertions, 137 deletions

diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index d5ddf0a..33f3add 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -7,17 +7,15 @@
 /**
  * \brief Base class for all event types in the system.
  */
-class Event {
-public:
-};
+class Event {};
 
 /**
  * \brief Event triggered when a key is pressed.
  */
 class KeyPressEvent : public Event {
 public:
-	//! Number of times the key press is repeated (e.g., for long presses).
-	int repeat = 0;
+	//! false if first time press, true if key is repeated
+	bool repeat = false;
 
 	//! The key that was pressed.
 	Keycode key = Keycode::NONE;
@@ -110,6 +108,4 @@ public:
 /**
  * \brief Event triggered to indicate the application is shutting down.
  */
-class ShutDownEvent : public Event {
-public:
-};
+class ShutDownEvent : public Event {};
diff --git a/src/crepe/api/EventHandler.cpp b/src/crepe/api/EventHandler.cpp
index 186ec9c..4dc232f 100644
--- a/src/crepe/api/EventHandler.cpp
+++ b/src/crepe/api/EventHandler.cpp
@@ -2,5 +2,4 @@
 
 using namespace crepe;
 
-// Implementation of IEventHandlerWrapper::exec
-bool IEventHandlerWrapper::exec(const Event & e) { return call(e); }
+bool IEventHandlerWrapper::exec(const Event & e) { return this->call(e); }
diff --git a/src/crepe/api/EventHandler.h b/src/crepe/api/EventHandler.h
index db51d04..90886aa 100644
--- a/src/crepe/api/EventHandler.h
+++ b/src/crepe/api/EventHandler.h
@@ -13,6 +13,8 @@ namespace crepe {
  * indicating whether the event is handled.
  * 
  * \tparam EventType The type of event this handler will handle.
+ * 
+ * Returning \c false from an event handler results in the event being propogated to other listeners for the same event type, while returning \c true stops propogation altogether.
  */
 template <typename EventType>
 using EventHandler = std::function<bool(const EventType & e)>;
@@ -105,9 +107,9 @@ private:
 	std::string get_type() const override;
 
 	//! The event handler function.
-	EventHandler<EventType> m_handler;
+	EventHandler<EventType> handler;
 	//! The type name of the handler function.
-	const std::string m_handler_type;
+	const std::string handler_type;
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/EventHandler.hpp b/src/crepe/api/EventHandler.hpp
index 9c47da2..a1e774d 100644
--- a/src/crepe/api/EventHandler.hpp
+++ b/src/crepe/api/EventHandler.hpp
@@ -8,19 +8,19 @@ 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()) {}
+	: handler(handler),
+	  handler_type(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));
+	return this->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;
+	return this->handler_type;
 }
 
 } //namespace crepe
diff --git a/src/crepe/api/EventManager.cpp b/src/crepe/api/EventManager.cpp
index b465e89..27a304f 100644
--- a/src/crepe/api/EventManager.cpp
+++ b/src/crepe/api/EventManager.cpp
@@ -13,9 +13,9 @@ void EventManager::dispatch_events() {
 	using HandlersVec = std::vector<std::unique_ptr<IEventHandlerWrapper>>;
 
 	for (auto event_it = this->events_queue.begin(); event_it != this->events_queue.end();) {
-		std::unique_ptr<Event> & event = std::get<0>(*event_it);
-		int channel = std::get<1>(*event_it);
-		std::type_index event_type = std::get<2>(*event_it);
+		std::unique_ptr<Event> & event = (*event_it).event;
+		int channel = (*event_it).channel;
+		std::type_index event_type = (*event_it).type;
 
 		bool event_handled = false;
 
@@ -58,3 +58,8 @@ void EventManager::dispatch_events() {
 		}
 	}
 }
+void EventManager::clear(){
+	this->subscribers.clear();
+	this->events_queue.clear();
+	this->subscribers_by_event_id.clear();
+}
diff --git a/src/crepe/api/EventManager.h b/src/crepe/api/EventManager.h
index 92273df..8fd22f4 100644
--- a/src/crepe/api/EventManager.h
+++ b/src/crepe/api/EventManager.h
@@ -11,7 +11,7 @@
 #include "EventHandler.h"
 
 namespace crepe {
-
+static constexpr int CHANNEL_ALL = -1;
 /**
  * \class EventManager
  * \brief The EventManager class is responsible for managing the subscription, triggering, 
@@ -19,6 +19,7 @@ namespace crepe {
  */
 class EventManager {
 public:
+
 	/**
      * \brief Get the singleton instance of the EventManager.
      * 
@@ -38,7 +39,7 @@ public:
      * \param channel The channel number to subscribe to (default is 0).
      */
 	template <typename EventType>
-	void subscribe(EventHandler<EventType> && callback, int channel = 0);
+	void subscribe(const EventHandler<EventType> & callback, int channel = CHANNEL_ALL, int priority = 0);
 
 	/**
      * \brief Unsubscribe from an event.
@@ -50,7 +51,7 @@ public:
      * \param channel The event ID to unsubscribe from.
      */
 	template <typename EventType>
-	void unsubscribe(const EventHandler<EventType> &, int channel = 0);
+	void unsubscribe(const EventHandler<EventType> &, int channel = CHANNEL_ALL);
 
 	/**
      * \brief Trigger an event.
@@ -62,7 +63,7 @@ public:
      * \param channel The channel from which to trigger the event (default is 0).
      */
 	template <typename EventType>
-	void trigger_event(const EventType & event, int channel = 0);
+	void trigger_event(const EventType & event, int channel = CHANNEL_ALL);
 
 	/**
      * \brief Queue an event for later processing.
@@ -75,7 +76,7 @@ public:
      * \param channel The channel number for the event (default is 0).
      */
 	template <typename EventType>
-	void queue_event(EventType && event, int channel = 0);
+	void queue_event(const EventType & event, int channel = CHANNEL_ALL,int priority = 0);
 
 	/**
      * \brief Dispatch all queued events.
@@ -84,8 +85,24 @@ public:
      * callbacks for each event.
      */
 	void dispatch_events();
-
+	/**
+     * \brief clears all subscribers
+     * 
+     */
+	void clear();
 private:
+	struct QueueEntry {
+        	std::unique_ptr<Event> event;
+		int channel = 0;
+		std::type_index type;
+		int priority = 0;
+    	};
+	struct CallbackEntry {
+        	std::unique_ptr<IEventHandlerWrapper> callback;
+		int channel = 0;
+		std::type_index type;
+		int priority = 0;
+    	};
 	/**
      * \brief Default constructor for the EventManager.
      * 
@@ -94,7 +111,7 @@ private:
 	EventManager() = default;
 
 	//! The queue of events to be processed.
-	std::vector<std::tuple<std::unique_ptr<Event>, int, std::type_index>> events_queue;
+	std::vector<QueueEntry> events_queue;
 	//! Registered event handlers.
 	std::unordered_map<std::type_index, std::vector<std::unique_ptr<IEventHandlerWrapper>>>
 		subscribers;
@@ -103,6 +120,7 @@ private:
 		std::type_index,
 		std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>
 		subscribers_by_event_id;
+	
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/EventManager.hpp b/src/crepe/api/EventManager.hpp
index b20b88f..9090a3f 100644
--- a/src/crepe/api/EventManager.hpp
+++ b/src/crepe/api/EventManager.hpp
@@ -3,7 +3,7 @@
 namespace crepe {
 
 template <typename EventType>
-void EventManager::subscribe(EventHandler<EventType> && callback, int channel) {
+void EventManager::subscribe(const EventHandler<EventType> & callback, int channel, int priority) {
 	using HandlersMap
 		= std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>;
 	using HandlersVec = std::vector<std::unique_ptr<IEventHandlerWrapper>>;
@@ -27,14 +27,20 @@ void EventManager::subscribe(EventHandler<EventType> && callback, int channel) {
 }
 
 template <typename EventType>
-void EventManager::queue_event(EventType && event, int channel) {
-	std::type_index event_type = std::type_index(typeid(EventType));
+void EventManager::queue_event(const EventType & event, int channel,int priority) {
+	static_assert(std::is_base_of<Event, EventType>::value, "EventType must derive from Event");
+	std::type_index event_type = typeid(EventType);
 
-	auto event_ptr = std::make_unique<EventType>(std::forward<EventType>(event));
+	auto event_ptr = std::make_unique<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));
+	
+	this->events_queue.push_back(
+		QueueEntry{
+			.event = std::move(event_ptr),
+			.channel = channel,
+			.type = event_type
+		}
+	);
 }
 
 template <typename EventType>
@@ -43,7 +49,7 @@ void EventManager::trigger_event(const EventType & event, int channel) {
 		= std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>;
 	using HandlersVec = std::vector<std::unique_ptr<IEventHandlerWrapper>>;
 
-	std::type_index event_type = std::type_index(typeid(EventType));
+	std::type_index event_type = typeid(EventType);
 
 	if (channel > 0) {
 		HandlersMap & handlers_map = this->subscribers_by_event_id[event_type];
@@ -75,7 +81,7 @@ void EventManager::unsubscribe(const EventHandler<EventType> & callback, int cha
 		= std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>;
 	using HandlersVec = std::vector<std::unique_ptr<IEventHandlerWrapper>>;
 
-	std::type_index event_type(typeid(EventType));
+	std::type_index event_type = typeid(EventType);
 	std::string handler_name = callback.target_type().name();
 
 	if (channel) {
diff --git a/src/crepe/api/IKeyListener.cpp b/src/crepe/api/IKeyListener.cpp
index f5426be..5e7d9bb 100644
--- a/src/crepe/api/IKeyListener.cpp
+++ b/src/crepe/api/IKeyListener.cpp
@@ -2,13 +2,6 @@
 
 using namespace crepe;
 
-// Constructor with default channel
-IKeyListener::IKeyListener()
-	: channel(0),
-	  active(true),
-	  event_manager(EventManager::get_instance()) {
-	this->subscribe_events();
-}
 
 // Constructor with specified channel
 IKeyListener::IKeyListener(int channel)
@@ -28,9 +21,9 @@ void IKeyListener::subscribe_events() {
 	key_released_handler
 		= [this](const KeyReleaseEvent & event) { return this->on_key_released(event); };
 
-	event_manager.subscribe<KeyPressEvent>(std::move(this->key_pressed_handler),
+	event_manager.subscribe<KeyPressEvent>(this->key_pressed_handler,
 										   this->channel);
-	event_manager.subscribe<KeyReleaseEvent>(std::move(this->key_released_handler),
+	event_manager.subscribe<KeyReleaseEvent>(this->key_released_handler,
 											 this->channel);
 }
 
@@ -40,27 +33,3 @@ void IKeyListener::unsubscribe_events() {
 	event_manager.unsubscribe<KeyReleaseEvent>(this->key_released_handler, this->channel);
 }
 
-// Activate key listening
-void IKeyListener::activate_keys() {
-	if (this->active) {
-		return;
-	}
-	this->active = true;
-	this->subscribe_events();
-}
-
-// Deactivate key listening
-void IKeyListener::deactivate_keys() {
-	if (!this->active) {
-		return;
-	}
-	this->active = false;
-	this->unsubscribe_events();
-}
-
-// Set a new channel for key events
-void IKeyListener::set_channel(int channel) {
-	this->unsubscribe_events();
-	this->channel = channel;
-	this->subscribe_events();
-}
diff --git a/src/crepe/api/IKeyListener.h b/src/crepe/api/IKeyListener.h
index d492387..70243b4 100644
--- a/src/crepe/api/IKeyListener.h
+++ b/src/crepe/api/IKeyListener.h
@@ -16,11 +16,11 @@ public:
      * \brief Constructs an IKeyListener with a specified channel.
      * \param channel The channel ID for event handling.
      */
-	IKeyListener(int channel);
-	IKeyListener();
+	IKeyListener(int channel = CHANNEL_ALL);
 	virtual ~IKeyListener();
 	IKeyListener(const IKeyListener &) = delete;
 	IKeyListener & operator=(const IKeyListener &) = delete;
+	IKeyListener & operator=(IKeyListener &&) = delete;
 	IKeyListener(IKeyListener &&) = delete;
 
 	/**
@@ -36,23 +36,6 @@ public:
      * \return True if the event was handled, false otherwise.
      */
 	virtual bool on_key_released(const KeyReleaseEvent & event) = 0;
-
-	/**
-     * \brief Activates key listening.
-     */
-	void activate_keys();
-
-	/**
-     * \brief Deactivates key listening.
-     */
-	void deactivate_keys();
-
-	/**
-     * \brief Sets the channel ID for event handling.
-     * \param channel The channel ID to set.
-     */
-	void set_channel(int channel);
-
 protected:
 	/**
      * \brief Subscribes to key events.
diff --git a/src/crepe/api/IMouseListener.cpp b/src/crepe/api/IMouseListener.cpp
index 5ee2814..6fd6c4b 100644
--- a/src/crepe/api/IMouseListener.cpp
+++ b/src/crepe/api/IMouseListener.cpp
@@ -8,10 +8,6 @@ IMouseListener::IMouseListener(int channel)
 	this->subscribe_events();
 }
 
-IMouseListener::IMouseListener() : event_manager(EventManager::get_instance()) {
-	this->subscribe_events();
-}
-
 IMouseListener::~IMouseListener() { this->unsubscribe_events(); }
 
 void IMouseListener::subscribe_events() {
@@ -26,11 +22,11 @@ void IMouseListener::subscribe_events() {
 		= [this](const MouseMoveEvent & event) { return this->on_mouse_moved(event); };
 
 	// Subscribe event handlers (no need for std::move)
-	event_manager.subscribe<MouseClickEvent>(std::move(mouse_click_handler), this->channel);
-	event_manager.subscribe<MousePressEvent>(std::move(mouse_press_handler), this->channel);
-	event_manager.subscribe<MouseReleaseEvent>(std::move(mouse_release_handler),
+	event_manager.subscribe<MouseClickEvent>(mouse_click_handler, this->channel);
+	event_manager.subscribe<MousePressEvent>(mouse_press_handler, this->channel);
+	event_manager.subscribe<MouseReleaseEvent>(mouse_release_handler,
 											   this->channel);
-	event_manager.subscribe<MouseMoveEvent>(std::move(mouse_move_handler), this->channel);
+	event_manager.subscribe<MouseMoveEvent>(mouse_move_handler, this->channel);
 }
 
 void IMouseListener::unsubscribe_events() {
@@ -40,25 +36,3 @@ void IMouseListener::unsubscribe_events() {
 	event_manager.unsubscribe<MouseReleaseEvent>(mouse_release_handler, this->channel);
 	event_manager.unsubscribe<MouseMoveEvent>(mouse_move_handler, this->channel);
 }
-
-void IMouseListener::activate_mouse() {
-	if (this->active) {
-		return;
-	}
-	this->subscribe_events();
-	this->active = true;
-}
-
-void IMouseListener::deactivate_mouse() {
-	if (!this->active) {
-		return;
-	}
-	this->unsubscribe_events();
-	this->active = false;
-}
-
-void IMouseListener::set_channel(int channel) {
-	this->unsubscribe_events();
-	this->channel = channel;
-	this->subscribe_events();
-}
diff --git a/src/crepe/api/IMouseListener.h b/src/crepe/api/IMouseListener.h
index 921a760..1195a4e 100644
--- a/src/crepe/api/IMouseListener.h
+++ b/src/crepe/api/IMouseListener.h
@@ -12,16 +12,15 @@ namespace crepe {
  */
 class IMouseListener {
 public:
-	IMouseListener();
 	/**
      * \brief Constructs an IMouseListener with a specified channel.
      * \param channel The channel ID for event handling.
      */
-	IMouseListener(int channel);
+	IMouseListener(int channel = CHANNEL_ALL);
 	virtual ~IMouseListener();
 	IMouseListener & operator=(const IMouseListener &) = delete;
 	IMouseListener(const IMouseListener &) = delete;
-	IMouseListener && operator=(const IMouseListener &&) = delete;
+	IMouseListener & operator=(const IMouseListener &&) = delete;
 	IMouseListener(IMouseListener &&) = delete;
 
 	/**
@@ -56,23 +55,6 @@ public:
      * \return True if the event was handled, false otherwise.
      */
 	virtual bool on_mouse_moved(const MouseMoveEvent & event) = 0;
-
-	/**
-     * \brief Activates mouse listening.
-     */
-	void activate_mouse();
-
-	/**
-     * \brief Deactivates mouse listening.
-     */
-	void deactivate_mouse();
-
-	/**
-     * \brief Sets the channel ID for event handling.
-     * \param channel The channel ID to set.
-     */
-	void set_channel(int channel);
-
 protected:
 	/**
      * \brief Subscribes to mouse events on the specified channel.