Implement event handler

Added event handler implementation.
Moved enginge specific implementation outside graphics module

Signed-off-by: Piotr Krygier <piotrkrygier@everyonecancode@xyz>

events/src/events_context.h

@@ -15,6 +15,17 @@
 #include "SDL3/SDL_mouse.h"
 #include "utilities/commons.h"
 
+enum EVENT_HANDLER {
+    EVENT_HANDLER_QUIT,
+    EVENT_HANDLER_MOUSE,
+    EVENT_HANDLER_LAST
+};
+
+enum EVENT_SHOULD_STOP_ENGINE {
+    EVENT_SHOULD_STOP_ENGINE_FALSE,
+    EVENT_SHOULD_STOP_ENGINE_TRUE
+};
+
 struct mouse_event_data_t
 {
     float x_pos;
@@ -24,14 +35,10 @@ struct mouse_event_data_t
 
 typedef rse_err_t (*rse_event_handler_t)(void*);
 
-struct event_handlers
+struct events_context_t
 {
-    rse_event_handler_t mouse_event;
-};
-
-struct events_context
-{
-    struct event_handlers event_handlers;
+    enum EVENT_SHOULD_STOP_ENGINE should_stop;
+    rse_event_handler_t event_handlers[EVENT_HANDLER_LAST];
 };
 
 #endif /* EVENT_CONTEXT_H_ */

events/src/events_manager.c

@@ -9,11 +9,11 @@
  *
  */
 
-#include "events_manager.h"
-
 #include "SDL3/SDL_events.h"
+#include "SDL3/SDL_log.h"
 #include "SDL3/SDL_mouse.h"
 #include "events_context.h"
+#include "rse_events_manager.h"
 #include "utilities/commons.h"
 #include "utilities/errors_common.h"
 
@@ -24,44 +24,62 @@ static rse_err_t default_event(void* args)
     return RSE_ERROR_NO_ERROR;
 }
 
-static rse_err_t quit_event(void)
+static rse_err_t run_custom_event_handler(struct events_context_t* context,
+                                          enum EVENT_HANDLER event_handler,
+                                          void* args)
 {
-    return RSE_ERROR_NO_ERROR;
+    return context->event_handlers[event_handler](args);
 }
 
-static rse_err_t mouse_event(struct events_context* events_context)
+static rse_err_t quit_event(struct events_context_t* context)
+{
+    context->should_stop = EVENT_SHOULD_STOP_ENGINE_TRUE;
+
+    return run_custom_event_handler(context, EVENT_HANDLER_QUIT, NULL);
+}
+
+static rse_err_t mouse_event(struct events_context_t* context)
 {
     struct mouse_event_data_t mouse_data = {0};
 
     mouse_data.mouse_buttons = SDL_GetMouseState(&mouse_data.x_pos, &mouse_data.y_pos);
 
-    return events_context->event_handlers.mouse_event((void*)&mouse_data);
+    return run_custom_event_handler(context, EVENT_HANDLER_MOUSE, (void*)&mouse_data);
 }
 
-rse_err_t events_init(struct events_context* events_context)
+rse_err_t rse_events_init(struct events_context_t* events_context)
 {
-    events_context->event_handlers.mouse_event = default_event;
+    size_t i = 0U;
 
-    return RSE_ERROR_NO_ERROR;
-}
-
-rse_err_t events_set_event_handler(struct events_context* events_context,
-                                   enum RSE_EVENT_TYPE event_type,
-                                   rse_event_handler_t event_handler)
-{
-    switch (event_type) {
-        case RSE_EVENT_TYPE_MOUSE:
-            events_context->event_handlers.mouse_event = event_handler;
-            break;
-        default:
-            SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Invalid event type provided");
-            return RSE_ERROR_INVALID_PARAM;
+    for (i = 0U; i < EVENT_HANDLER_LAST; ++i) {
+        events_context->event_handlers[i] = default_event;
     }
 
     return RSE_ERROR_NO_ERROR;
 }
 
-rse_err_t events_run(struct events_context* context)
+rse_err_t rse_events_set_event_handler(struct events_context_t* events_context,
+                                       enum EVENT_HANDLER event_type,
+                                       rse_event_handler_t event_handler)
+{
+    if (event_type >= EVENT_HANDLER_LAST) {
+        SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Invalid event type selected");
+
+        return RSE_ERROR_INVALID_PARAM;
+    }
+
+    if (event_handler == NULL) {
+        SDL_LogCritical(SDL_LOG_CATEGORY_APPLICATION, "Provided NULL event handler");
+
+        return RSE_ERROR_INVALID_PARAM;
+    }
+
+    events_context->event_handlers[event_type] = event_handler;
+
+    return RSE_ERROR_NO_ERROR;
+}
+
+rse_err_t rse_events_main_loop(struct events_context_t* context)
 {
     SDL_Event event;
     rse_err_t status = RSE_ERROR_NO_ERROR;
@@ -69,7 +87,7 @@ rse_err_t events_run(struct events_context* context)
     while (SDL_PollEvent(&event)) {
         switch (event.type) {
             case SDL_EVENT_QUIT:
-                STATUS_CHECK(quit_event());
+                STATUS_CHECK(quit_event(context));
                 break;
             case SDL_EVENT_MOUSE_BUTTON_DOWN:
                 STATUS_CHECK(mouse_event(context));

events/src/events_manager.h

@@ -1,20 +0,0 @@
-/**
- * @file events_manager.h
- * @author Piotr Krygier (piotrkrygier@everyonencancode.xyz)
- * @brief Events manager for Red Scarf Engine
- * @version 0.1
- * @date 2026-03-02
- *
- * @copyright Copyright (c) 2026
- *
- */
-
-#ifndef EVENTS_MANAGER_H_
-#define EVENTS_MANAGER_H_
-
-enum RSE_EVENT_TYPE {
-    RSE_EVENT_TYPE_MOUSE,
-};
-
-
-#endif /* EVENTS_MANAGER_H_ */