event.c

Go to the documentation of this file.

 
#include <kiba/core/event.h>
 
#include <kiba/core/log.h>
#include <kiba/core/memory.h>
 
typedef struct registered_listener {
    void             *listener;
    on_event_function on_event;
} registered_listener;
 
#define MAX_EVENT_LISTENER 512
 
// TODO: Replace with container.
typedef struct registered_listener_list {
    registered_listener content[MAX_EVENT_LISTENER];
    u32                 last_listener;
} registered_listener_list;
 
typedef struct event_system_state {
    registered_listener_list listener_map[APPLICATION_EVENT_CODE_MAX];
} event_system_state;
 
event_system_state event_state;
 
b8 event_initialize(void) {
    memory_zero(&event_state, sizeof(event_system_state));
    return true;
}
 
void event_shutdown(void) {}
 
b8 event_register(u16 event_code, void *listener, on_event_function on_event, b8 append) {
    registered_listener_list *list = &event_state.listener_map[event_code];
    if (list->last_listener >= MAX_EVENT_LISTENER) {
        return false;
    }
    registered_listener *element;
    if (append) {
        element = &list->content[list->last_listener++];
    } else {
        element = list->content;
        registered_listener_list new_list;
        memory_copy(new_list.content, list->content, MAX_EVENT_LISTENER - 1);
        memory_copy(list->content + 1, new_list.content, MAX_EVENT_LISTENER - 1);
        ++list->last_listener;
    }
    element->listener = listener;
    element->on_event = on_event;
    return true;
}
 
b8 event_unregister(u16 event_code, void *listener, on_event_function on_event) {
    registered_listener_list *list = &event_state.listener_map[event_code];
    for (u32 i = 0; i < list->last_listener; ++i) {
        if (list->content[i].listener == listener && list->content[i].on_event == on_event) {
            if (i + 1 >= list->last_listener) {
                memory_copy(list->content + i, list->content + i + 1, list->last_listener - i);
            }
            memory_zero(&list->content[--list->last_listener], sizeof(registered_listener));
            return true;
        }
    }
    return false;
}
 
b8 event_fire(u16 event_code, void *sender, event_context context) {
    registered_listener_list *list = &event_state.listener_map[event_code];
    for (u32 i = 0; i < list->last_listener; ++i) {
        if ((*list->content[i].on_event)(event_code, sender, list->content[i].listener, context)) {
            return true;
        }
    }
    return false;
}