mandelbrot-wl

mandelbrot-wl.c (21117B)

---

 #define _XOPEN_SOURCE 700
 
 #include "mandelbrot-wl.h"
 
 struct application {
 	/* wayland globals */
 	struct wl_display *wl_display;
 	struct wl_registry *wl_registry;
 	struct wl_compositor *wl_compositor;
 	struct wl_seat *wl_seat;
 	struct wl_shm *wl_shm;
 
 	/* memory buffer */
 	int wl_shm_pool_fd;
 	struct wl_shm_pool *wl_shm_pool;
 
 	/* wayland objects */
 	struct wl_surface *wl_surface, *wl_cursor_surface;
 	struct wl_cursor_image *wl_cursor_image;
 	struct wl_pointer *wl_pointer;
 	struct wl_keyboard *wl_keyboard;
 	struct wl_touch *wl_touch;
 
 	/* xdg globals */
 	struct xdg_wm_base *xdg_wm_base;
 
 	/* xdg objects */
 	struct xdg_surface *xdg_surface;
 	struct xdg_toplevel *xdg_toplevel;
 
 	/* application input */
 	struct pointer_ev pointer_ev;
 	struct xkb_context *xkb_context;
 	struct xkb_keymap *xkb_keymap;
 	struct xkb_state *xkb_state;
 	struct touch_ev touch_ev;
 
 	/* application state */
 	b32 should_close;
 	s32 width, height;
 	f32 offset;
 	u32 last_frame;
 };
 
 static void
 wl_buffer_release(void *data, struct wl_buffer *self) {
 	(void) data;
 
 	wl_buffer_destroy(self);
 }
 
 static const struct wl_buffer_listener wl_buffer_listener = {
 	.release = wl_buffer_release,
 };
 
 static void
 init_shm_pool(struct application *state, u64 sz) {
 	int fd = memfd_create("buffer", 0);
 	ftruncate(fd, sz);
 
 	state->wl_shm_pool_fd = fd;
 	state->wl_shm_pool = wl_shm_create_pool(state->wl_shm, fd, sz);
 }
 
 static void
 free_shm_pool(struct application *state) {
 	wl_shm_pool_destroy(state->wl_shm_pool);
 	close(state->wl_shm_pool_fd);
 }
 
 static struct wl_buffer *
 draw_frame(struct application *state) {
 	const s32 stride = state->width * sizeof(pixel_argb8888_t);
 	const s32 sz = stride * state->height;
 
 	u8 *data = mmap(NULL, sz, PROT_READ | PROT_WRITE, MAP_SHARED, state->wl_shm_pool_fd, 0);
 
 	struct wl_buffer *buffer = wl_shm_pool_create_buffer(state->wl_shm_pool, 0, state->width, state->height, stride, WL_SHM_FORMAT_ARGB8888);
 
 	u32 *out = (u32 *)data;
 
 	s32 offset = (s32)state->offset;
 	for (s32 j = 0; j < state->height; j++) {
 		for (s32 i = 0; i < state->width; i++) {
 			u8 r = (i + offset) % 256, g = (j + offset) % 256, b = 0;
 
 			*out++ = ((pixel_argb8888_t){ .a = 255, .r = r, .g = g, .b = b, }).v;
 		}
 	}
 
 	munmap(data, sz);
 	wl_buffer_add_listener(buffer, &wl_buffer_listener, NULL);
 
 	return buffer;
 }
 
 static void
 xdg_surface_configure(void *data, struct xdg_surface *self, u32 serial) {
 	struct application *state = data;
 
 	xdg_surface_ack_configure(self, serial);
 
 	struct wl_buffer *buffer = draw_frame(state);
 	wl_surface_attach(state->wl_surface, buffer, 0, 0);
 	wl_surface_commit(state->wl_surface);
 }
 
 static const struct xdg_surface_listener xdg_surface_listener = {
 	.configure = xdg_surface_configure,
 };
 
 static void
 xdg_wm_base_ping(void *data, struct xdg_wm_base *self, u32 serial) {
 	(void) data;
 
 	xdg_wm_base_pong(self, serial);
 }
 
 static const struct xdg_wm_base_listener xdg_wm_base_listener = {
 	.ping = xdg_wm_base_ping,
 };
 
 static void
 xdg_toplevel_configure_handler(void *data, struct xdg_toplevel *self, s32 width, s32 height, struct wl_array *states) {
 	(void) self;
 	(void) states;
 
 	struct application *state = data;
 
 	if (width == 0 || height == 0) {
 		return;
 	}
 
 	state->width = width;
 	state->height = height;
 }
 
 static void
 xdg_toplevel_close_handler(void *data, struct xdg_toplevel *self) {
 	(void) self;
 
 	struct application *state = data;
 
 	state->should_close = true;
 }
 
 static void
 xdg_toplevel_configure_bounds_handler(void *data, struct xdg_toplevel *self, s32 width, s32 height) {
 	(void) data;
 	(void) self;
 	(void) width;
 	(void) height;
 }
 
 static void
 xdg_toplevel_wm_capabilities_handler(void *data, struct xdg_toplevel *self, struct wl_array *capabilities) {
 	(void) data;
 	(void) self;
 	(void) capabilities;
 }
 
 static const struct xdg_toplevel_listener xdg_toplevel_listener = {
 	.configure = xdg_toplevel_configure_handler,
 	.close = xdg_toplevel_close_handler,
 	.configure_bounds = xdg_toplevel_configure_bounds_handler,
 	.wm_capabilities = xdg_toplevel_wm_capabilities_handler,
 };
 
 static const struct wl_callback_listener wl_surface_frame_listener;
 
 static void
 wl_surface_frame_done(void *data, struct wl_callback *callback, u32 time) {
 	wl_callback_destroy(callback);
 
 	struct application *state = data;
 
 	callback = wl_surface_frame(state->wl_surface);
 	wl_callback_add_listener(callback, &wl_surface_frame_listener, state);
 
 	if (state->last_frame) {
 		int elapsed = time - state->last_frame;
 		state->offset += elapsed / 1000.0 * 64;
 	}
 
 	struct wl_buffer *buffer = draw_frame(state);
 	wl_surface_attach(state->wl_surface, buffer, 0, 0);
 	wl_surface_damage_buffer(state->wl_surface, 0, 0, INT32_MAX, INT32_MAX);
 	wl_surface_commit(state->wl_surface);
 
 	state->last_frame = time;
 }
 
 static const struct wl_callback_listener wl_surface_frame_listener = {
 	.done = wl_surface_frame_done,
 };
 
 static void
 wl_pointer_enter(void *data, struct wl_pointer *self, u32 serial, struct wl_surface *surface, wl_fixed_t surface_x, wl_fixed_t surface_y) {
 	struct application *state = data;
 
 	state->pointer_ev.ev_mask |= POINTER_EV_ENTER;
 	state->pointer_ev.serial = serial;
 	state->pointer_ev.px = surface_x;
 	state->pointer_ev.py = surface_y;
 
 	wl_pointer_set_cursor(self, serial, state->wl_cursor_surface, state->wl_cursor_image->hotspot_x, state->wl_cursor_image->hotspot_y);
 
 	(void) self;
 	(void) surface;
 }
 
 static void
 wl_pointer_leave(void *data, struct wl_pointer *self, u32 serial, struct wl_surface *surface) {
 	struct application *state = data;
 
 	state->pointer_ev.ev_mask |= POINTER_EV_LEAVE;
 	state->pointer_ev.serial = serial;
 
 	(void) self;
 	(void) surface;
 }
 
 static void
 wl_pointer_motion(void *data, struct wl_pointer *self, u32 time, wl_fixed_t surface_x, wl_fixed_t surface_y) {
 	struct application *state = data;
 
 	state->pointer_ev.ev_mask |= POINTER_EV_MOTION;
 	state->pointer_ev.time = time;
 	state->pointer_ev.px = surface_x;
 	state->pointer_ev.py = surface_y;
 
 	(void) self;
 }
 
 static void
 wl_pointer_button(void *data, struct wl_pointer *self, u32 serial, u32 time, u32 button, u32 button_state) {
 	struct application *state = data;
 
 	state->pointer_ev.ev_mask |= POINTER_EV_BUTTON;
 	state->pointer_ev.serial = serial;
 	state->pointer_ev.time = time;
 	state->pointer_ev.button = button;
 	state->pointer_ev.button_state = button_state;
 
 	(void) self;
 }
 
 static void
 wl_pointer_axis(void *data, struct wl_pointer *self, u32 time, u32 axis, wl_fixed_t value) {
 	struct application *state = data;
 
 	state->pointer_ev.ev_mask |= POINTER_EV_AXIS;
 	state->pointer_ev.time = time;
 	state->pointer_ev.axes[axis].dirty = true;
 	state->pointer_ev.axes[axis].value = value;
 
 	(void) self;
 }
 
 static void
 wl_pointer_axis_source(void *data, struct wl_pointer *self, u32 axis_source) {
 	struct application *state = data;
 
 	state->pointer_ev.ev_mask |= POINTER_EV_AXIS_SOURCE;
 	state->pointer_ev.axis_source = axis_source;
 
 	(void) self;
 }
 
 static void
 wl_pointer_axis_stop(void *data, struct wl_pointer *self, u32 time, u32 axis) {
 	struct application *state = data;
 
 	state->pointer_ev.ev_mask |= POINTER_EV_AXIS_STOP;
 	state->pointer_ev.time = time;
 	state->pointer_ev.axes[axis].dirty = true;
 
 	(void) self;
 }
 
 static void
 wl_pointer_axis_discrete(void *data, struct wl_pointer *self, u32 axis, s32 discrete) {
 	struct application *state = data;
 
 	state->pointer_ev.ev_mask |= POINTER_EV_AXIS_DISCRETE;
 	state->pointer_ev.axes[axis].dirty = true;
 	state->pointer_ev.axes[axis].discrete = discrete;
 
 	(void) self;
 }
 
 static void
 wl_pointer_frame(void *data, struct wl_pointer *self) {
 	struct application *state = data;
 	struct pointer_ev *ev = &state->pointer_ev;
 
 //	fprintf(stderr, "pointer frame @ %" PRIu32 ": ", ev->time);
 
 	if (ev->ev_mask & POINTER_EV_ENTER) {
 //		fprintf(stderr, "entered %f, %f ", wl_fixed_to_double(ev->px), wl_fixed_to_double(ev->py));
 	}
 
 	if (ev->ev_mask & POINTER_EV_LEAVE) {
 //		fprintf(stderr, "leave");
 	}
 
 	if (ev->ev_mask & POINTER_EV_MOTION) {
 //		fprintf(stderr, "motion %f, %f ", wl_fixed_to_double(ev->px), wl_fixed_to_double(ev->py));
 	}
 
 	if (ev->ev_mask & POINTER_EV_BUTTON) {
 		//char *button_state_name = (ev->button_state == WL_POINTER_BUTTON_STATE_RELEASED) ? "released" : "pressed";
 //		fprintf(stderr, "button %d %s ", ev->button, button_state_name);
 	}
 
 	u32 axis_evs = POINTER_EV_AXIS | POINTER_EV_AXIS_SOURCE | POINTER_EV_AXIS_STOP | POINTER_EV_AXIS_DISCRETE;
 	if (ev->ev_mask & axis_evs) {
 		char *axis_name[] = {
 			[WL_POINTER_AXIS_VERTICAL_SCROLL] = "vertical",
 			[WL_POINTER_AXIS_HORIZONTAL_SCROLL] = "horizontal",
 		};
 
 		char *axis_source_name[] = {
 			[WL_POINTER_AXIS_SOURCE_WHEEL] = "wheel",
 			[WL_POINTER_AXIS_SOURCE_FINGER] = "finger",
 			[WL_POINTER_AXIS_SOURCE_CONTINUOUS] = "continuous",
 			[WL_POINTER_AXIS_SOURCE_WHEEL_TILT] = "wheel tilt",
 		};
 
 		(void) axis_name;
 		(void) axis_source_name;
 
 		for (u32 i = 0; i < ARRLEN(ev->axes); i++) {
 			if (!ev->axes[i].dirty) continue;
 
 //			fprintf(stderr, "%s axis ", axis_name[i]);
 
 			if (ev->ev_mask & POINTER_EV_AXIS) {
 //				fprintf(stderr, "value %f ", wl_fixed_to_double(ev->axes[i].value));
 			}
 
 			if (ev->ev_mask & POINTER_EV_AXIS_DISCRETE) {
 //				fprintf(stderr, "discrete %d ", ev->axes[i].discrete);
 			}
 
 			if (ev->ev_mask & POINTER_EV_AXIS_SOURCE) {
 //				fprintf(stderr, "via %s ", axis_source_name[i]);
 			}
 
 			if (ev->ev_mask & POINTER_EV_AXIS_STOP) {
 //				fprintf(stderr, "(stopped)");
 			}
 		}
 	}
 
 //	fprintf(stderr, "\n");
 	memset(ev, 0, sizeof *ev);
 
 	(void) self;
 }
 
 static const struct wl_pointer_listener wl_pointer_listener = {
 	.enter = wl_pointer_enter,
 	.leave = wl_pointer_leave,
 	.motion = wl_pointer_motion,
 	.button = wl_pointer_button,
 	.axis = wl_pointer_axis,
 	.axis_source = wl_pointer_axis_source,
 	.axis_stop = wl_pointer_axis_stop,
 	.axis_discrete = wl_pointer_axis_discrete,
 	.frame = wl_pointer_frame,
 };
 
 static void
 wl_keyboard_keymap(void *data, struct wl_keyboard *self, u32 format, int fd, u32 size) {
 	struct application *state = data;
 
 	assert(format == WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1);
 
 	char *map_shm = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
 	assert(map_shm != MAP_FAILED);
 
 	struct xkb_keymap *xkb_keymap = xkb_keymap_new_from_string(state->xkb_context, map_shm, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
 
 	munmap(map_shm, size);
 	close(fd);
 
 	struct xkb_state *xkb_state = xkb_state_new(xkb_keymap);
 
 	xkb_keymap_unref(state->xkb_keymap);
 	xkb_state_unref(state->xkb_state);
 
 	state->xkb_keymap = xkb_keymap;
 	state->xkb_state = xkb_state;
 
 	(void) self;
 }
 
 static void
 wl_keyboard_enter(void *data, struct wl_keyboard *self, u32 serial, struct wl_surface *surface, struct wl_array *keys) {
 	struct application *state = data;
 
 //	fprintf(stderr, "keyboard enter; keys pressed are:\n");
 
 	u32 *key;
 	wl_array_for_each(key, keys) {
 		char buf[128];
 		xkb_keysym_t sym = xkb_state_key_get_one_sym(state->xkb_state, *key + 8);
 		xkb_keysym_get_name(sym, buf, ARRLEN(buf));
 //		fprintf(stderr, "sym: %-12s (%" PRIu32 "), ", buf, sym);
 		xkb_state_key_get_utf8(state->xkb_state, *key + 8, buf, ARRLEN(buf));
 //		fprintf(stderr, "utf8: '%s'\n", buf);
 	}
 
 	(void) self;
 	(void) serial;
 	(void) surface;
 }
 
 static void
 wl_keyboard_key(void *data, struct wl_keyboard *self, u32 serial, u32 time, u32 key, u32 key_state) {
 	struct application *state = data;
 
 	u32 keycode = key + 8;
 	xkb_keysym_t keysym = xkb_state_key_get_one_sym(state->xkb_state, keycode);
 
 	char buf[128];
 	xkb_keysym_get_name(keysym, buf, ARRLEN(buf));
 
 	//char *action = (key_state == WL_KEYBOARD_KEY_STATE_PRESSED) ? "pressed" : "released";
 //	fprintf(stderr, "key %s: sym: %-12s (%" PRIu32 "), ", action, buf, keycode);
 
 	xkb_state_key_get_utf8(state->xkb_state, keycode, buf, ARRLEN(buf));
 //	fprintf(stderr, "utf8: '%s'\n", buf);
 
 	(void) self;
 	(void) serial;
 	(void) time;
 	(void) key_state;
 }
 
 static void
 wl_keyboard_leave(void *data, struct wl_keyboard *self, u32 serial, struct wl_surface *surface) {
 //	fprintf(stderr, "keyboard leave\n");
 
 	(void) data;
 	(void) self;
 	(void) serial;
 	(void) surface;
 }
 
 static void
 wl_keyboard_modifiers(void *data, struct wl_keyboard *self, u32 serial, u32 modifiers_depressed, u32 modifiers_latched, u32 modifiers_locked, u32 group) {
 	struct application *state = data;
 
 	xkb_state_update_mask(state->xkb_state, modifiers_depressed, modifiers_latched, modifiers_locked, 0, 0, group);
 
 	(void) self;
 	(void) serial;
 }
 
 static void
 wl_keyboard_repeat_info(void *data, struct wl_keyboard *self, s32 rate, s32 delay) {
 	(void) data;
 	(void) self;
 	(void) rate;
 	(void) delay;
 }
 
 static const struct wl_keyboard_listener wl_keyboard_listener = {
 	.keymap = wl_keyboard_keymap,
 	.enter = wl_keyboard_enter,
 	.key = wl_keyboard_key,
 	.leave = wl_keyboard_leave,
 	.modifiers = wl_keyboard_modifiers,
 	.repeat_info = wl_keyboard_repeat_info,
 };
 
 static struct touch_point *
 get_touch_point(struct application *state, s32 touch_id) {
 	struct touch_ev *ev = &state->touch_ev;
 
 	u32 first_dirty = 0;
 	for (u32 i = 0; i < ARRLEN(ev->points); i++) {
 		if (ev->points[i].id == touch_id) return &ev->points[i];
 
 		if (first_dirty == ARRLEN(ev->points) && !ev->points[i].dirty)
 			first_dirty = i;
 	}
 
 	if (first_dirty == ARRLEN(ev->points)) return NULL;
 
 	ev->points[first_dirty].dirty = true;
 	ev->points[first_dirty].id = touch_id;
 	return &ev->points[first_dirty];
 
 	return NULL;
 }
 
 static void
 wl_touch_down(void *data, struct wl_touch *self, u32 serial, u32 time, struct wl_surface *surface, s32 id, wl_fixed_t x, wl_fixed_t y) {
 	struct application *state = data;
 
 	struct touch_point *point = get_touch_point(state, id);
 	if (!point) return;
 
 	point->ev_mask |= TOUCH_EV_DOWN;
 	point->px = x;
 	point->py = y;
 	state->touch_ev.serial = serial;
 	state->touch_ev.time = time;
 
 	(void) self;
 	(void) surface;
 }
 
 static void
 wl_touch_up(void *data, struct wl_touch *self, u32 serial, u32 time, s32 id) {
 	struct application *state = data;
 
 	struct touch_point *point = get_touch_point(state, id);
 	if (!point) return;
 
 	point->ev_mask |= TOUCH_EV_UP;
 	state->touch_ev.serial = serial;
 	state->touch_ev.time = time;
 
 	(void) self;
 }
 
 static void
 wl_touch_motion(void *data, struct wl_touch *self, u32 time, s32 id, wl_fixed_t x, wl_fixed_t y) {
 	struct application *state = data;
 
 	struct touch_point *point = get_touch_point(state, id);
 	if (!point) return;
 
 	point->ev_mask |= TOUCH_EV_MOTION;
 	point->px = x;
 	point->py = y;
 	state->touch_ev.time = time;
 
 	(void) self;
 }
 
 static void
 wl_touch_cancel(void *data, struct wl_touch *self) {
 	struct application *state = data;
 
 	state->touch_ev.ev_mask |= TOUCH_EV_CANCEL;
 
 	(void) self;
 }
 
 static void
 wl_touch_shape(void *data, struct wl_touch *self, s32 id, wl_fixed_t major, wl_fixed_t minor) {
 	struct application *state = data;
 
 	struct touch_point *point = get_touch_point(state, id);
 	if (!point) return;
 
 	point->ev_mask |= TOUCH_EV_SHAPE;
 	point->major = major;
 	point->minor = minor;
 
 	(void) self;
 }
 
 static void
 wl_touch_orientation(void *data, struct wl_touch *self, s32 id, wl_fixed_t orientation) {
 	struct application *state = data;
 
 	struct touch_point *point = get_touch_point(state, id);
 	if (!point) return;
 
 	point->ev_mask |= TOUCH_EV_ORIENTATION;
 	point->orientation = orientation;
 
 	(void) self;
 }
 
 static void
 wl_touch_frame(void *data, struct wl_touch *self) {
 	struct application *state = data;
 
 	struct touch_ev *ev = &state->touch_ev;
 //	fprintf(stderr, "touch event @ %" PRIu32 ":\n", ev->time);
 
 	// TODO: handle cancelled touch events
 	// TODO: test out touch input logic
 
 	for (u32 i = 0; i < ARRLEN(ev->points); i++) {
 		struct touch_point *point = &ev->points[i];
 		if (!point->dirty) continue;
 
 //		fprintf(stderr, "point %" PRIi32 ": ", point->id);
 
 		if (point->ev_mask & TOUCH_EV_DOWN) {
 //			fprintf(stderr, "down %f, %f ", wl_fixed_to_double(point->px), wl_fixed_to_double(point->py));
 		}
 
 		if (point->ev_mask & TOUCH_EV_UP) {
 //			fprintf(stderr, "up ");
 		}
 
 		if (point->ev_mask & TOUCH_EV_MOTION) {
 //			fprintf(stderr, "motion %f, %f ", wl_fixed_to_double(point->px), wl_fixed_to_double(point->py));
 		}
 
 		if (point->ev_mask & TOUCH_EV_SHAPE) {
 //			fprintf(stderr, "shape %fx%f ", wl_fixed_to_double(point->major), wl_fixed_to_double(point->minor));
 		}
 
 		if (point->ev_mask & TOUCH_EV_ORIENTATION) {
 //			fprintf(stderr, "orientation %f ", wl_fixed_to_double(point->orientation));
 		}
 
 		point->dirty = 0;
 //		fprintf(stderr, "\n");
 	}
 
 	(void) self;
 }
 
 static const struct wl_touch_listener wl_touch_listener = {
 	.down = wl_touch_down,
 	.up = wl_touch_up,
 	.motion = wl_touch_motion,
 	.cancel = wl_touch_cancel,
 	.shape = wl_touch_shape,
 	.orientation = wl_touch_orientation,
 	.frame = wl_touch_frame,
 };
 
 static void
 wl_seat_capabilities(void *data, struct wl_seat *self, u32 capabilities) {
 	struct application *state = data;
 
 	b32 have_pointer = capabilities & WL_SEAT_CAPABILITY_POINTER;
 	b32 have_keyboard = capabilities & WL_SEAT_CAPABILITY_KEYBOARD;
 	b32 have_touch = capabilities & WL_SEAT_CAPABILITY_TOUCH;
 
 	if (have_pointer && !state->wl_pointer) {
 		state->wl_pointer = wl_seat_get_pointer(self);
 		wl_pointer_add_listener(state->wl_pointer, &wl_pointer_listener, state);
 	} else if (!have_pointer && state->wl_pointer) {
 		wl_pointer_release(state->wl_pointer);
 		state->wl_pointer = NULL;
 	}
 
 	if (have_keyboard && !state->wl_keyboard) {
 		state->wl_keyboard = wl_seat_get_keyboard(self);
 		wl_keyboard_add_listener(state->wl_keyboard, &wl_keyboard_listener, state);
 	} else if (!have_keyboard && state->wl_keyboard) {
 		wl_keyboard_release(state->wl_keyboard);
 		state->wl_keyboard = NULL;
 	}
 
 	if (have_touch && !state->wl_touch) {
 		state->wl_touch = wl_seat_get_touch(self);
 		wl_touch_add_listener(state->wl_touch, &wl_touch_listener, state);
 	} else if (!have_touch && state->wl_touch) {
 		wl_touch_release(state->wl_touch);
 		state->wl_touch = NULL;
 	}
 }
 
 static void
 wl_seat_name(void *data, struct wl_seat *self, char const *name) {
 	(void) data;
 	(void) self;
 	(void) name;
 }
 
 static const struct wl_seat_listener wl_seat_listener = {
 	.capabilities = wl_seat_capabilities,
 	.name = wl_seat_name,
 };
 
 static void
 wl_registry_global(void *data, struct wl_registry *self, u32 name, char const *interface, u32 version) {
 	struct application *state = data;
 
 	if (strcmp(interface, wl_compositor_interface.name) == 0) {
 		state->wl_compositor = wl_registry_bind(self, name, &wl_compositor_interface, version);
 	} else if (strcmp(interface, wl_seat_interface.name) == 0) {
 		state->wl_seat = wl_registry_bind(self, name, &wl_seat_interface, version);
 		wl_seat_add_listener(state->wl_seat, &wl_seat_listener, state);
 	} else if (strcmp(interface, wl_shm_interface.name) == 0) {
 		state->wl_shm = wl_registry_bind(self, name, &wl_shm_interface, version);
 	} else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
 		state->xdg_wm_base = wl_registry_bind(self, name, &xdg_wm_base_interface, version);
 		xdg_wm_base_add_listener(state->xdg_wm_base, &xdg_wm_base_listener, state);
 	}
 }
 
 static void
 wl_registry_global_remove(void *data, struct wl_registry *self, u32 name) {
 	(void) data;
 	(void) self;
 	(void) name;
 }
 
 static const struct wl_registry_listener wl_registry_listener = {
 	.global = wl_registry_global,
 	.global_remove = wl_registry_global_remove,
 };
 
 int main(int argc, char **argv) {
 	(void) argc;
 	(void) argv;
 
 	struct application state = { .width = 640, .height = 480, };
 
 	state.wl_display = wl_display_connect(NULL);
 
 	state.wl_registry = wl_display_get_registry(state.wl_display);
 	wl_registry_add_listener(state.wl_registry, &wl_registry_listener, &state);
 
 	state.xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
 
 	wl_display_roundtrip(state.wl_display);
 
 	if (!state.wl_compositor || !state.wl_seat || !state.wl_shm || !state.xdg_wm_base) {
 		fprintf(stderr, "Failed to register required globals!\n");
 		exit(EXIT_FAILURE);
 	}
 
 	init_shm_pool(&state, WL_SHM_POOL_SZ);
 
 	state.wl_surface = wl_compositor_create_surface(state.wl_compositor);
 
 	struct wl_cursor_theme *cursor_theme = wl_cursor_theme_load(NULL, 24, state.wl_shm);
 	struct wl_cursor *cursor = wl_cursor_theme_get_cursor(cursor_theme, "left_ptr");
 	state.wl_cursor_image = cursor->images[0];
 	struct wl_buffer *cursor_buffer = wl_cursor_image_get_buffer(state.wl_cursor_image);
 
 	state.wl_cursor_surface = wl_compositor_create_surface(state.wl_compositor);
 	wl_surface_attach(state.wl_cursor_surface, cursor_buffer, 0, 0);
 	wl_surface_commit(state.wl_cursor_surface);
 
 	state.xdg_surface = xdg_wm_base_get_xdg_surface(state.xdg_wm_base, state.wl_surface);
 	xdg_surface_add_listener(state.xdg_surface, &xdg_surface_listener, &state);
 
 	state.xdg_toplevel = xdg_surface_get_toplevel(state.xdg_surface);
 	xdg_toplevel_add_listener(state.xdg_toplevel, &xdg_toplevel_listener, &state);
 	xdg_toplevel_set_title(state.xdg_toplevel, "mandelbrot-wl");
 	wl_surface_commit(state.wl_surface);
 
 	struct wl_callback *callback = wl_surface_frame(state.wl_surface);
 	wl_callback_add_listener(callback, &wl_surface_frame_listener, &state);
 
 	do {
 		wl_display_dispatch(state.wl_display);
 	} while (!state.should_close);
 
 	free_shm_pool(&state);
 
 	return 0;
 }