libdraw

// Copyright (C) 2024, Jakob Wakeling

// All rights reserved.

#include "../draw.h"

#include <xcb/xcb.h>

#include <xcb/xcb_keysyms.h>

#include <xcb/xproto.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

enum : xcb_atom_t {

	ATOM_REPAINT = 0x0f00,

};

struct keymap { xcb_keysym_t keysym; draw_key_k key; };

struct draw_window_s {

	xcb_connection_t *connection;

	xcb_screen_t *screen;

	xcb_window_t window;

	xcb_key_symbols_t *symbols;

	uint32_t x, y, w, h;

};

extern const struct keymap keymap[];

extern const size_t keymap_size;

static inline draw_mod_k mod(uint16_t state);

static inline draw_key_k keymap_find(draw_window *window, xcb_keycode_t keycode);

int draw_window_init(draw_window **window, int32_t w, int32_t h, const char *title, uint32_t flags) {

	(*window) = calloc(1, sizeof(draw_window)); if ((*window) == NULL) { return -1; }

	(*window)->connection = xcb_connect(NULL, NULL);

	if (xcb_connection_has_error((*window)->connection)) { return -1; }

	xcb_void_cookie_t cookie;

	xcb_generic_error_t *error = NULL;

	(*window)->screen = xcb_setup_roots_iterator(xcb_get_setup((*window)->connection)).data;

	(*window)->window = xcb_generate_id((*window)->connection);

	if ((*window)->window == -1) { xcb_disconnect((*window)->connection); return -1; }

	uint32_t mask = XCB_CW_BACK_PIXMAP | XCB_CW_BORDER_PIXEL | XCB_CW_EVENT_MASK | XCB_CW_COLORMAP;

	uint32_t values[4] = {

		0, 0,

		XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_BUTTON_PRESS |

		XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_BUTTON_MOTION | XCB_EVENT_MASK_EXPOSURE |

		XCB_EVENT_MASK_STRUCTURE_NOTIFY, XCB_VISUAL_CLASS_TRUE_COLOR

	};

	/**/

	xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator((*window)->screen);

	xcb_visualtype_t *visual = NULL;

	for (; depth_iter.rem; xcb_depth_next(&depth_iter)) {

		if (depth_iter.data->depth != 32) continue;

		xcb_visualtype_iterator_t visual_iter = xcb_depth_visuals_iterator(depth_iter.data);

		for (; visual_iter.rem; xcb_visualtype_next(&visual_iter)) {

			visual = visual_iter.data;

			break;

		}

		if (visual != NULL) break;

	}

	if (visual == NULL) { xcb_disconnect((*window)->connection); return -1; }

	xcb_colormap_t colormap = xcb_generate_id((*window)->connection);

	cookie = xcb_create_colormap(

		(*window)->connection, XCB_COLORMAP_ALLOC_NONE, colormap, (*window)->screen->root, visual->visual_id

	);

	error = xcb_request_check((*window)->connection, cookie);

	if (error != NULL) {

		printf("Error %d while creating colormap\n", error->error_code);

		free(error); xcb_disconnect((*window)->connection); return -1;

	}

	values[3] = colormap;

	cookie = xcb_create_window_checked(

		(*window)->connection, 32, (*window)->window, (*window)->screen->root, 0, 0, w, h, 0,

		XCB_WINDOW_CLASS_INPUT_OUTPUT, visual->visual_id, mask, values

	);

	error = xcb_request_check((*window)->connection, cookie);

	if (error != NULL) {

		printf("Error %d while creating window\n", error->error_code);

		free(error); xcb_disconnect((*window)->connection); return -1;

	}

	xcb_change_property(

		(*window)->connection, XCB_PROP_MODE_REPLACE, (*window)->window, XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8,

		strlen(title), title

	);

	xcb_change_property(

		(*window)->connection, XCB_PROP_MODE_REPLACE, (*window)->window, XCB_ATOM_WM_CLASS, XCB_ATOM_STRING, 8,

		strlen(title), title

	);

	(*window)->symbols = xcb_key_symbols_alloc((*window)->connection);

	(*window)->w = w; (*window)->h = h;

	xcb_map_window((*window)->connection, (*window)->window);

	xcb_flush((*window)->connection);

	return 0;

}

void draw_window_free(draw_window **window) {

	if (*window == NULL) { return; }

	xcb_key_symbols_free((*window)->symbols);

	xcb_destroy_window((*window)->connection, (*window)->window);

	xcb_disconnect((*window)->connection);

	free(*window); *window = NULL;

}

draw_event draw_window_event(draw_window *window) {

	xcb_generic_event_t *_e = xcb_wait_for_event(window->connection);

	if (_e == NULL) {

		if (draw_debug) { printf("xcb_wait_for_event returned NULL\n"); }

		return (draw_event){ .kind = DRAW_EVENT_EXIT };

	}

	draw_event event = {};

	/* TODO handle modifiers */

	switch (_e->response_type  & ~0x80) {

		case XCB_KEY_PRESS: {

			xcb_key_press_event_t *e = (xcb_key_press_event_t *)_e;

			if (draw_debug_verbose) { printf("KeyPress (%d, %d, %d)\n", e->detail, e->event_x, e->event_y); }

			event = (draw_event){ .kind = DRAW_EVENT_KEY, .key = {

				.code = keymap_find(window, e->detail), .modifiers = mod(e->state), .direction = DRAW_PRESS,

			}};

		} break;

		case XCB_KEY_RELEASE: {

			xcb_key_release_event_t *e = (xcb_key_release_event_t *)_e;

			if (draw_debug_verbose) { printf("KeyRelease (%d, %d, %d)\n", e->detail, e->event_x, e->event_y); }

			event = (draw_event){ .kind = DRAW_EVENT_KEY, .key = {

				.code = keymap_find(window, e->detail), .modifiers = mod(e->state), .direction = DRAW_RELEASE,

			}};

		} break;

		case XCB_BUTTON_PRESS: {

			xcb_button_press_event_t *e = (xcb_button_press_event_t *)_e;

			if (draw_debug_verbose) { printf("ButtonPress (%d, %d, %d)\n", e->detail, e->event_x, e->event_y); }

			event = (draw_event){ .kind = DRAW_EVENT_MOUSE, .mouse = {

				.x = e->event_x, .y = e->event_y, .button = e->detail, .modifiers = mod(e->state),

				.direction = DRAW_PRESS,

			}};

		} break;

		case XCB_BUTTON_RELEASE: {

			xcb_button_release_event_t *e = (xcb_button_release_event_t *)_e;

			if (draw_debug_verbose) { printf("ButtonRelease (%d, %d, %d)\n", e->detail, e->event_x, e->event_y); }

			event = (draw_event){ .kind = DRAW_EVENT_MOUSE, .mouse = {

				.x = e->event_x, .y = e->event_y, .button = e->detail, .modifiers = mod(e->state),

				.direction = DRAW_RELEASE,

			}};

		} break;

		case XCB_MOTION_NOTIFY: {

			xcb_motion_notify_event_t *e = (xcb_motion_notify_event_t *)_e;

			if (draw_debug_verbose) { printf("MotionNotify (%d, %d)\n", e->event_x, e->event_y); }

			event = (draw_event){ .kind = DRAW_EVENT_MOUSE, .mouse = {

				.x = e->event_x, .y = e->event_y, .button = e->detail, .modifiers = mod(e->state),

				.direction = DRAW_REPEAT,

			}};

		} break;

		case XCB_EXPOSE: {

			xcb_expose_event_t *e = (xcb_expose_event_t *)_e;

			if (draw_debug) { printf("Expose (%d, %d, %d, %d)\n", e->x, e->y, e->width, e->height); }

			event = (draw_event){ .kind = DRAW_EVENT_PAINT, .paint = { e->x, e->y, e->width, e->height }};

		} break;

		case XCB_UNMAP_NOTIFY: {

			xcb_unmap_notify_event_t *e = (xcb_unmap_notify_event_t *)_e;

			if (draw_debug) { printf("UnmapNotify\n"); }

			event = (draw_event){ .kind = DRAW_EVENT_HIDE };

		} break;

		case XCB_MAP_NOTIFY: {

			xcb_map_notify_event_t *e = (xcb_map_notify_event_t *)_e;

			if (draw_debug) { printf("MapNotify\n"); }

			event = (draw_event){ .kind = DRAW_EVENT_SHOW };

		} break;

		case XCB_CONFIGURE_NOTIFY: {

			xcb_configure_notify_event_t *e = (xcb_configure_notify_event_t *)_e;

			if (draw_debug) { printf("ConfigureNotify (%d, %d, %d, %d)\n", e->x, e->y, e->width, e->height); }

			if (e->width != window->w || e->height != window->h) {

				window->w = e->width; window->h = e->height;

				event = (draw_event){ .kind = DRAW_EVENT_RESIZE, .resize = { e->width, e->height }};

			}

		} break;

		case XCB_CLIENT_MESSAGE: {

			xcb_client_message_event_t *e = (xcb_client_message_event_t *)_e;

			switch (e->type) {

			case ATOM_REPAINT: {

				if (draw_debug) { printf("ClientMessage (REPAINT)\n"); }

				event = (draw_event){ .kind = DRAW_EVENT_PAINT, .paint = { 0, 0, window->w, window->h }};

			} break;

			}

		} break;

		default: { if (draw_debug) {

			printf("Unhandled X11 event: %d ", _e->response_type & ~0x80);

			printf("Sequence: %u ", _e->sequence);

			printf("Full sequence: %u ", _e->full_sequence);

			printf("Pad0: %u ", _e->pad0);

			printf("Pad: %u\n", *_e->pad);

		}} break;

	}

	free(_e); return event;

}

void draw_window_set_title(draw_window *window, const char *title) {

	xcb_change_property(

		window->connection, XCB_PROP_MODE_REPLACE, window->window, XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8, strlen(title),

		title

	);

	xcb_flush(window->connection);

}

void draw_window_repaint(draw_window *window) {

	xcb_client_message_event_t e = {

		.response_type = XCB_CLIENT_MESSAGE, .format = 32, .window = window->window, .type = ATOM_REPAINT,

		.data.data32 = {}

	};

	xcb_send_event(window->connection, 0, window->window, XCB_EVENT_MASK_NO_EVENT, (const char *)&e);

	xcb_flush(window->connection);

}

int draw_window_draw(draw_window *w, point dp, draw_buffer *buf, rect br) {

	if (w == NULL) { return 1; }

	xcb_gcontext_t gc = xcb_generate_id(w->connection);

	xcb_create_gc(w->connection, gc, w->window, 0, NULL);

	xcb_put_image(

		w->connection, XCB_IMAGE_FORMAT_Z_PIXMAP, w->window, gc, br.w, br.h, dp.x, dp.y, 0, 32,

		(buf->bounds.w * buf->bounds.h) * sizeof (*buf->buf), (uint8_t *)buf->buf

	);

	xcb_free_gc(w->connection, gc);

	xcb_flush(w->connection);

	return 0;

}

void draw_window_clear(draw_window *w, uint32_t colour) {

	if (w == NULL) { return; }

	xcb_gcontext_t gc = xcb_generate_id(w->connection);

	xcb_create_gc(w->connection, gc, w->window, 0, NULL);

	xcb_change_gc(w->connection, gc, XCB_GC_FOREGROUND, (uint32_t[]){colour});

	xcb_poly_fill_rectangle(w->connection, w->window, gc, 1, (xcb_rectangle_t[]){{

		.x = 0, .y = 0, .width = w->w, .height = w->h,

	}});

	xcb_free_gc(w->connection, gc);

	xcb_flush(w->connection);

}

static inline draw_mod_k mod(uint16_t state) {

	draw_mod_k mod = 0;

	mod |= ((state & XCB_MOD_MASK_SHIFT) != 0) * DRAW_MOD_SHIFT;

	mod |= ((state & XCB_MOD_MASK_CONTROL) != 0) * DRAW_MOD_CONTROL;

	mod |= ((state & XCB_MOD_MASK_1) != 0) * DRAW_MOD_ALT;

	mod |= ((state & XCB_MOD_MASK_4) != 0) * DRAW_MOD_SUPER;

	mod |= ((state & XCB_MOD_MASK_LOCK) != 0) * DRAW_MOD_CAPS_LOCK;

	mod |= ((state & XCB_MOD_MASK_2) != 0) * DRAW_MOD_NUM_LOCK;

	return mod;

}

static inline draw_key_k keymap_find(draw_window *window, xcb_keycode_t keycode) {

	xcb_keysym_t keysym = xcb_key_symbols_get_keysym(window->symbols, keycode, 0);

	for (size_t i = 0; i < keymap_size; i += 1) { if (keymap[i].keysym == keysym) { return keymap[i].key; }}

	return DRAW_KEY_UNKNOWN;

}