event_polling.c

Event handling using the polling pattern.

Event handling using the polling pattern.This demonstrates polling events from a queue instead of using callbacks. Polling gives you fine-grained control over when and how events are processed, which is useful for game loops and custom event prioritization.

The window is created resizable (BJ_WINDOW_FLAG_RESIZABLE): drag any edge to resize it. Resizing is not one of the queued event types, so it cannot be pulled from the poll loop like the input events. Instead we register a bj_set_resize_callback, exactly as event_callbacks.c does, which shows the two styles coexisting: input is polled from the queue, while a size change is delivered to a callback.

 
#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;
 
// Resize is not a queued event type, so even a polling program reacts to it
// through a callback. Registered per-window with bj_set_resize_callback, it
// receives the new width and height directly.
static 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;
    }
 
    window = bj_bind_window("Event Polling", 100, 100, 800, 600, BJ_WINDOW_FLAG_RESIZABLE, 0);
    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;
    event_counter* counter = (event_counter*)user_data;
    bj_event e;
 
    // Poll events from the queue. bj_poll_events() fills the event structure
    // and returns true if an event was available, false when the queue is empty.
    // Process all queued events in a loop before continuing with your frame logic.
    while (bj_poll_events(&e)) {
        // Each event has a type field that determines which union member is valid.
        switch (e.type) {
            case BJ_EVENT_ENTER:
                // Mouse cursor entering or leaving the window.
                ++counter->enter;
                bj_info("Enter event, window %p, %s, (%d,%d)",
                    window,
                    e.as.enter.enter ? "entered" : "left",
                    e.as.enter.x, e.as.enter.y
                );
                break;
 
            case BJ_EVENT_CURSOR:
                // Mouse movement within the window.
                ++counter->cursor;
                bj_info("Cursor event, window %p, (%d,%d)",
                    window, e.as.cursor.x, e.as.cursor.y
                );
                break;
 
            case BJ_EVENT_KEY:
                // Keyboard input. Action can be PRESS, RELEASE, or REPEAT.
                ++counter->key;
 
                const char* action_str = "pressed";
                if (e.as.key.action != BJ_PRESS) {
                    action_str = e.as.key.action == BJ_RELEASE ? "released" : "repeated";
                }
 
                bj_info("Key 0x%04X (%s) Scancode 0x%04X (with no mods) was %s",
                    e.as.key.key, bj_key_name(e.as.key.key), e.as.key.scancode, action_str
                );
 
                // With polling, you manually check for keys like ESC and handle
                // them explicitly, unlike with callbacks where you register handlers.
                if (e.as.key.key == BJ_KEY_ESCAPE) {
                    bj_set_window_should_close(window);
                }
                break;
 
            case BJ_EVENT_BUTTON:
                // Mouse button clicks. Button index and position are provided.
                ++counter->button;
                bj_info("Button event, window %p, button %d, %s, (%d,%d)",
                    (void*)window, e.as.button.button,
                    e.as.button.action == BJ_PRESS ? "pressed" : "released",
                    e.as.button.x, e.as.button.y
                );
                break;
        }
    }
 
    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);
}