window.c

Go to the documentation of this file.

 
#include <kiba/platform/window.h>
 
#include <kiba/core/event.h>
#include <kiba/core/input.h>
#include <kiba/core/log.h>
#include <kiba/platform/linux/window.h>
 
#include <stdlib.h>
#include <string.h>
#include <xcb/xkb.h>
 
b8 window_create(platform_window *window, const char *title, u32 x, u32 y, u32 w, u32 h, allocator *alloc) {
    KB_ASSERT(window != KB_NULL, "window to populate must not be nullptr");
    KB_ASSERT(title != KB_NULL, "window title must point to some data");
    linux_window_state *state =
        allocator_allocate_aligned(alloc, sizeof(linux_window_state), ALIGN_OF(linux_window_state));
    if (state == KB_NULL) {
        KB_ERROR("could not allocate {usize} bytes for the window state", sizeof(linux_window_state));
        return false;
    }
    window->state = state;
 
    // connect to X server
    i32 screenp       = 0;
    state->connection = xcb_connect(NULL, &screenp);
    if (xcb_connection_has_error(state->connection)) {
        KB_ERROR("failed to establish connection to X server");
        return false;
    }
 
    // check for xkb extension
    const xcb_query_extension_reply_t *ext_reply = xcb_get_extension_data(state->connection, &xcb_xkb_id);
    if (ext_reply == KB_NULL) {
        KB_ERROR("xkb extension not available on X server");
        return false;
    }
 
    // load xkb
    xcb_xkb_use_extension_cookie_t use_ext_cookie =
        xcb_xkb_use_extension(state->connection, XCB_XKB_MAJOR_VERSION, XCB_XKB_MINOR_VERSION);
    xcb_generic_error_t           *error         = KB_NULL;
    xcb_xkb_use_extension_reply_t *use_ext_reply = KB_NULL;
    use_ext_reply = xcb_xkb_use_extension_reply(state->connection, use_ext_cookie, &error);
    if (use_ext_reply == KB_NULL) {
        KB_ERROR("failed to load xkb extension of X server");
        return false;
    }
    if (!use_ext_reply->supported || error != KB_NULL) {
        KB_ERROR("xkb extension is not supported on this X server");
        free(use_ext_reply);
        return false;
    }
    free(use_ext_reply);
 
    // deactivate key repeat
    xcb_xkb_per_client_flags_cookie_t pcf_cookie;
    xcb_xkb_per_client_flags_reply_t *pcf_reply;
    pcf_cookie = xcb_xkb_per_client_flags(state->connection,
                                          XCB_XKB_ID_USE_CORE_KBD,
                                          XCB_XKB_PER_CLIENT_FLAG_DETECTABLE_AUTO_REPEAT,
                                          XCB_XKB_PER_CLIENT_FLAG_DETECTABLE_AUTO_REPEAT,
                                          0,
                                          0,
                                          0);
    pcf_reply  = xcb_xkb_per_client_flags_reply(state->connection, pcf_cookie, &error);
    free(pcf_reply);
    if (error != KB_NULL) {
        KB_ERROR("failed to set xkb per-client flag, error code: {u8}", error->major_code);
        return false;
    }
 
    // get keysym
    state->syms = xcb_key_symbols_alloc(state->connection);
 
    // gather data
    const xcb_setup_t *setup = xcb_get_setup(state->connection);
    state->screen            = xcb_setup_roots_iterator(setup).data;
    state->window            = xcb_generate_id(state->connection);
 
    // register event types
    u32 event_mask   = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
    u32 event_values = XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_KEY_PRESS
                     | XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_POINTER_MOTION
                     | XCB_EVENT_MASK_STRUCTURE_NOTIFY;
    u32 value_list[] = {state->screen->black_pixel, event_values};
 
    // create window
    xcb_create_window(state->connection,
                      XCB_COPY_FROM_PARENT,
                      state->window,
                      state->screen->root,
                      (i16) x,
                      (i16) y,
                      (u16) w,
                      (u16) h,
                      0,
                      XCB_WINDOW_CLASS_INPUT_OUTPUT,
                      state->screen->root_visual,
                      event_mask,
                      value_list);
 
    // set title
    xcb_change_property(state->connection,
                        XCB_PROP_MODE_REPLACE,
                        state->window,
                        XCB_ATOM_WM_NAME,
                        XCB_ATOM_STRING,
                        8,
                        (u32) strlen(title),
                        title);
 
    // listen on window manager commands
    const char              *wm_delete_cmd_name    = "WM_DELETE_WINDOW";
    const char              *wm_protocols_cmd_name = "WM_PROTOCOLS";
    xcb_intern_atom_cookie_t wm_delete_cookie =
        xcb_intern_atom(state->connection, 0, (u16) strlen(wm_delete_cmd_name), wm_delete_cmd_name);
    xcb_intern_atom_cookie_t wm_protocols_cookie =
        xcb_intern_atom(state->connection, 0, (u16) strlen(wm_protocols_cmd_name), wm_protocols_cmd_name);
    xcb_intern_atom_reply_t *wm_delete_reply    = xcb_intern_atom_reply(state->connection, wm_delete_cookie, NULL);
    xcb_intern_atom_reply_t *wm_protocols_reply = xcb_intern_atom_reply(state->connection, wm_protocols_cookie, NULL);
    state->wm_delete_win                        = wm_delete_reply->atom;
    state->wm_protocols                         = wm_protocols_reply->atom;
    xcb_change_property(state->connection,
                        XCB_PROP_MODE_REPLACE,
                        state->window,
                        state->wm_protocols,
                        4,
                        32,
                        1,
                        &wm_delete_reply->atom);
 
    // map window to screen
    xcb_map_window(state->connection, state->window);
 
    // flush stream
    i32 stream_result = xcb_flush(state->connection);
    if (stream_result <= 0) {
        KB_ERROR("failed to flush the stream, result: {i32}", stream_result);
        return false;
    }
    gpu_surface surface = allocator_allocate_aligned(alloc, sizeof(struct gpu_surface), ALIGN_OF(struct gpu_surface));
    if (!surface) {
        KB_ERROR("failed to allocate memory for window's surface");
        return false;
    }
    if (!gpu_surface_create(surface, state)) {
        KB_ERROR("failed to create window surface");
        return false;
    }
    window->title = title;
    window->x     = x;
    window->y     = y;
    window->w     = w;
    window->h     = h;
    window->surface = surface;
    window->alloc   = alloc;
    return true;
}
 
void window_destroy(platform_window *window) {
    if (window->surface) {
        gpu_surface_destroy(window->surface);
        allocator_free(window->alloc, window->surface);
    }
    if (window->state) {
        linux_window_state *state = (linux_window_state *) window->state;
        xcb_destroy_window(state->connection, state->window);
        xcb_key_symbols_free(state->syms);
        xcb_disconnect(state->connection);
        allocator_free(window->alloc, state);
        window->state = KB_NULL;
    }
}
 
key_code translate_keysym(xcb_keysym_t key_code);
key_code translate_button(xcb_button_t button);
 
b8 window_poll_events(platform_window *window) {
    linux_window_state  *state = (linux_window_state *) window->state;
    xcb_generic_event_t *event;
    b8                   quit = false;
    while ((event = xcb_poll_for_event(state->connection))) {
        event_context context;
        i32           type = event->response_type & ~0x80;
        switch (type) {
            case XCB_KEY_PRESS:
            case XCB_KEY_RELEASE: {
                xcb_key_press_event_t *key_event = (xcb_key_press_event_t *) event;
                xcb_keysym_t           key_sym   = xcb_key_symbols_get_keysym(state->syms, key_event->detail, 0);
                key_code               code      = translate_keysym(key_sym);
                b8                     pressed   = type == XCB_KEY_PRESS;
                input_process_key(code, pressed);
                context.data.u32[0] = code;
                event_fire(pressed ? EVENT_CODE_KEY_PRESSED : EVENT_CODE_KEY_RELEASED, state, context);
            } break;
            case XCB_BUTTON_PRESS:
            case XCB_BUTTON_RELEASE: {
                xcb_button_press_event_t *button_event = (xcb_button_press_event_t *) event;
                if (button_event->detail > 3) {
                    i8 wheel_dir = button_event->detail == 4 ? -1 : 1;
                    input_process_mouse_wheel(wheel_dir);
                    context.data.i8[0] = wheel_dir;
                    event_fire(EVENT_CODE_MOUSE_WHEEL, state, context);
                } else {
                    key_code code    = translate_button(button_event->detail);
                    b8       pressed = type == XCB_BUTTON_PRESS;
                    input_process_key(code, pressed);
                    context.data.u32[0] = code;
                    event_fire(pressed ? EVENT_CODE_KEY_PRESSED : EVENT_CODE_KEY_RELEASED, state, context);
                }
            } break;
            case XCB_MOTION_NOTIFY: {
                xcb_motion_notify_event_t *motion_event = (xcb_motion_notify_event_t *) event;
                input_process_mouse_position((u32) motion_event->event_x, (u32) motion_event->event_y);
                context.data.u32[0] = (u32) motion_event->event_x;
                context.data.u32[1] = (u32) motion_event->event_y;
                if (input_mouse_moved(context.data.u32 + 2, context.data.u32 + 3)) {
                    event_fire(EVENT_CODE_MOUSE_MOVED, state, context);
                }
            } break;
            case XCB_CONFIGURE_NOTIFY: {
                xcb_configure_notify_event_t *configure_event = (xcb_configure_notify_event_t *) event;
                window->x                                     = (u32) configure_event->x;
                window->y                                     = (u32) configure_event->y;
                window->w                                     = configure_event->width;
                window->h                                     = configure_event->height;
 
                context.data.u32[0] = window->w;
                context.data.u32[1] = window->h;
                event_fire(EVENT_CODE_WINDOW_RESIZE, state, context);
            } break;
            case XCB_MAP_NOTIFY: {
                context.data.c[0] = 'R';
                event_fire(EVENT_CODE_WINDOW_RAISED, state, context);
            } break;
            case XCB_UNMAP_NOTIFY: {
                context.data.c[0] = 'M';
                event_fire(EVENT_CODE_WINDOW_MINIMIZED, state, context);
            } break;
            case XCB_CLIENT_MESSAGE: {
                xcb_client_message_event_t *message_event = (xcb_client_message_event_t *) event;
                quit                                      = message_event->data.data32[0] == state->wm_delete_win;
            } break;
            default:
                break;
        }
        free(event);
    }
    return !quit;
}
 
key_code translate_keysym(xcb_keysym_t x_key_code) {
    if ((x_key_code >> 8) == 0 && x_key_code >= 0x0061 && x_key_code <= 0x007a) {
        x_key_code -= (0x0061 - 0x0041);
    }
    switch (x_key_code) {
        case 0xff08:
            return KEY_BACKSPACE;
        case 0xff0d:
            return KEY_ENTER;
        case 0xff09:
            return KEY_TAB;
        case 0xffe1:
            return KEY_SHIFT_L;
        case 0xffe2:
            return KEY_SHIFT_R;
        case 0xffe3:
            return KEY_CONTROL_L;
        case 0xffe4:
            return KEY_CONTROL_R;
        case 0xffe9:
            return KEY_ALT_L;
        case 0xffea:
            return KEY_ALT_R;
        case 0xffeb:
            return KEY_SUPER_L;
            // TODO find out right super key
        case 0xff13:
            return KEY_PAUSE;
        case 0xffe5:
            return KEY_CAPITAL;
        case 0xff1b:
            return KEY_ESCAPE;
        case 0x0020:
            return KEY_SPACE;
        case 0xff50:
            return KEY_HOME;
        case 0xff57:
            return KEY_END;
        case 0xff55:
            return KEY_PAGE_UP;
        case 0xff56:
            return KEY_PAGE_DOWN;
        case 0xff51:
            return KEY_LEFT;
        case 0xff52:
            return KEY_UP;
        case 0xff54:
            return KEY_DOWN;
        case 0xff53:
            return KEY_RIGHT;
        case 0xff61:
            return KEY_PRINT;
        case 0xff63:
            return KEY_INSERT;
        case 0xffff:
            return KEY_DELETE;
        case 0x0041:
            return KEY_A;
        case 0x0042:
            return KEY_B;
        case 0x0043:
            return KEY_C;
        case 0x0044:
            return KEY_D;
        case 0x0045:
            return KEY_E;
        case 0x0046:
            return KEY_F;
        case 0x0047:
            return KEY_G;
        case 0x0048:
            return KEY_H;
        case 0x0049:
            return KEY_I;
        case 0x004a:
            return KEY_J;
        case 0x004b:
            return KEY_K;
        case 0x004c:
            return KEY_L;
        case 0x004d:
            return KEY_M;
        case 0x004e:
            return KEY_N;
        case 0x004f:
            return KEY_O;
        case 0x0050:
            return KEY_P;
        case 0x0051:
            return KEY_Q;
        case 0x0052:
            return KEY_R;
        case 0x0053:
            return KEY_S;
        case 0x0054:
            return KEY_T;
        case 0x0055:
            return KEY_U;
        case 0x0056:
            return KEY_V;
        case 0x0057:
            return KEY_W;
        case 0x0058:
            return KEY_X;
        case 0x0059:
            return KEY_Y;
        case 0x005a:
            return KEY_Z;
        case 0x003b:
            return KEY_SEMICOLON;
        case 0x0023:
            return KEY_PLUS;
        case 0x003d:
            return KEY_EQUAL;
        case 0x002c:
            return KEY_COMMA;
        case 0x002d:
            return KEY_MINUS;
        case 0x002e:
            return KEY_PERIOD;
        case 0x002f:
            return KEY_SLASH;
        case 0x0060:
            return KEY_GRAVE;
        case 0x0027:
            return KEY_QUOTE;
        case 0x005b:
            return KEY_BRACKET_L;
        case 0x005d:
            return KEY_BRACKET_R;
        case 0x005c:
            return KEY_BACK_SLASH;
        case 0x0030:
            return KEY_0;
        case 0x0031:
            return KEY_1;
        case 0x0032:
            return KEY_2;
        case 0x0033:
            return KEY_3;
        case 0x0034:
            return KEY_4;
        case 0x0035:
            return KEY_5;
        case 0x0036:
            return KEY_6;
        case 0x0037:
            return KEY_7;
        case 0x0038:
            return KEY_8;
        case 0x0039:
            return KEY_9;
        case 0xff9e:
            return KEY_NUMPAD0;
        case 0xff9c:
            return KEY_NUMPAD1;
        case 0xff99:
            return KEY_NUMPAD2;
        case 0xff9b:
            return KEY_NUMPAD3;
        case 0xff96:
            return KEY_NUMPAD4;
        case 0xff9d:
            return KEY_NUMPAD5;
        case 0xff98:
            return KEY_NUMPAD6;
        case 0xff95:
            return KEY_NUMPAD7;
        case 0xff97:
            return KEY_NUMPAD8;
        case 0xff9a:
            return KEY_NUMPAD9;
        case 0xff8d:
            return KEY_NUMPAD_ENTER;
        case 0xff9f:
            return KEY_DECIMAL;
        case 0xffaa:
            return KEY_MULTIPLY;
        case 0xffab:
            return KEY_ADD;
        case 0xffad:
            return KEY_SUBTRACT;
        case 0xffaf:
            return KEY_DIVIDE;
        case 0xff7f:
            return KEY_NUMLOCK;
        case 0xffbe:
            return KEY_F1;
        case 0xffbf:
            return KEY_F2;
        case 0xffc0:
            return KEY_F3;
        case 0xffc1:
            return KEY_F4;
        case 0xffc2:
            return KEY_F5;
        case 0xffc3:
            return KEY_F6;
        case 0xffc4:
            return KEY_F7;
        case 0xffc5:
            return KEY_F8;
        case 0xffc6:
            return KEY_F9;
        case 0xffc7:
            return KEY_F10;
        case 0xffc8:
            return KEY_F11;
        case 0xffc9:
            return KEY_F12;
    }
    KB_WARN("unmapped key code received {u32}", x_key_code);
    return KEY_CODE_MAX;
}
 
key_code translate_button(xcb_button_t button) {
    switch (button) {
        case 1:
            return KEY_MOUSE_LEFT;
        case 2:
            return KEY_MOUSE_MIDDLE;
        case 3:
            return KEY_MOUSE_RIGHT;
    }
    KB_WARN("unmapped button code received {u32}", button);
    return KEY_CODE_MAX;
}