event_polling.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;
 
// 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);
}