event_callbacks.c

Go to the documentation of this file.

 
#include <banjo/app.h>
#include <banjo/main.h>
#include <banjo/error.h>
#include <banjo/event.h>
#include <banjo/log.h>
#include <banjo/memory.h>
#include <banjo/system.h>
#include <banjo/window.h>
 
bj_window* window = 0;
 
typedef struct {
    size_t cursor;
    size_t button;
    size_t key;
    size_t enter;
    size_t resize;
} event_counter;
 
// Callback functions follow a standard signature:
// (bj_window* window, const event_type* event, void* user_data)
// The user_data parameter is whatever you passed during registration.
 
void cursor_callback(bj_window* p_window, const bj_cursor_event* e, void* data) {
    event_counter* counter = (event_counter*)data;
    ++counter->cursor;
    bj_info("Cursor event, window %p, (%d,%d)",
        (void*)p_window, e->x, e->y
    );
}
 
void button_callback(bj_window* p_window, const bj_button_event* e, void* data) {
    event_counter* counter = (event_counter*)data;
    ++counter->button;
    bj_info("Button event, window %p, button %d, %s, (%d,%d)",
        (void*)p_window, e->button,
        e->action == BJ_PRESS ? "pressed" : "released",
        e->x, e->y
    );
}
 
void key_callback(bj_window* p_window, const bj_key_event* e, void* data) {
    event_counter* counter = (event_counter*)data;
    ++counter->key;
    (void)p_window;
 
    const char* action_str = "pressed";
    if(e->action != BJ_PRESS) {
        action_str = e->action == BJ_RELEASE ? "released" : "repeated";
    }
 
    bj_info("Key 0x%04X (%s) Scancode 0x%04X (with no mods) was %s",
        e->key, bj_key_name(e->key), e->scancode, action_str
    );
 
    if(e->key == BJ_KEY_ESCAPE) {
        bj_set_window_should_close(p_window);
    }
}
 
void enter_callback(bj_window* p_window, const bj_enter_event* e, void* data) {
    event_counter* counter = (event_counter*)data;
    ++counter->enter;
    bj_info("Enter event, window %p, %s, (%d,%d)",
        (void*)p_window,
        e->enter ? "entered" : "left",
        e->x, e->y
    );
}
 
// The resize callback is the odd one out: it is per-window and receives
// the new size directly rather than an event struct. Banjo has already
// resized the framebuffer by the time this fires; here we just count and
// log it. A real program would recompute layout or rescale here.
void resize_callback(bj_window* p_window, int width, int height, void* data) {
    event_counter* counter = (event_counter*)data;
    ++counter->resize;
    bj_info("Resize event, window %p, %dx%d", (void*)p_window, width, height);
}
 
static void* setup(struct bj_app* app, void* init_data) {
    (void)init_data;
    event_counter* counter = bj_calloc(sizeof(event_counter));
 
    if (!bj_begin(BJ_VIDEO_SYSTEM, 0)) {
        bj_free(counter);
        bj_quit_app(app, 1);
        return 0;
    }
 
    // Opt the window into user resizing; it is fixed-size otherwise.
    window = bj_bind_window("Event Callbacks", 100, 100, 800, 600,
                            BJ_WINDOW_FLAG_RESIZABLE, 0);
 
    // Register callbacks for each event type. When bj_dispatch_events() runs,
    // these functions will be called automatically for each matching event.
    // The second parameter (counter) is passed to the callback as user_data.
    bj_set_key_callback(key_callback, counter);
    bj_set_button_callback(button_callback, counter);
    bj_set_cursor_callback(cursor_callback, counter);
    bj_set_enter_callback(enter_callback, counter);
    // Resize is registered per-window, not globally like the input callbacks.
    bj_set_resize_callback(window, resize_callback, counter);
    return counter;
}
 
static void step(struct bj_app* app, struct bj_tick_info tick, void* user_data) {
    (void)tick;
    (void)user_data;
 
    // bj_dispatch_events() processes all queued events and invokes the
    // registered callbacks. Unlike polling where you manually check each event,
    // callbacks are automatically invoked for you.
    bj_dispatch_events();
 
    if (bj_should_close_window(window)) {
        bj_quit_app(app, 0);
    }
}
 
static void teardown(struct bj_app* app, void* user_data) {
    (void)app;
    event_counter* counter = (event_counter*)user_data;
    bj_info("Total events: %ld cursor, %ld button, %ld key, %ld enter, %ld resize",
        counter->cursor, counter->button, counter->key, counter->enter, counter->resize
    );
 
    bj_unbind_window(window);
    bj_end();
    bj_free(counter);
}
 
int main(int argc, char* argv[]) {
    (void)argc; (void)argv;
    return bj_run_app(setup, step, 0, teardown, 0);
}