aboutsummaryrefslogtreecommitdiff
path: root/backend/x11/backend.c
blob: f76b314e66aef4418b7f4b09191cd853d3848f11 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
#define _POSIX_C_SOURCE 200112L
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <EGL/egl.h>
#include <wayland-server.h>
#include <xcb/xcb.h>
#include <xcb/glx.h>
#include <X11/Xlib-xcb.h>
#ifdef __linux__
#include <linux/input-event-codes.h>
#elif __FreeBSD__
#include <dev/evdev/input-event-codes.h>
#endif
#include <wlr/backend/interface.h>
#include <wlr/backend/x11.h>
#include <wlr/render/egl.h>
#include <wlr/interfaces/wlr_output.h>
#include <wlr/interfaces/wlr_input_device.h>
#include <wlr/interfaces/wlr_keyboard.h>
#include <wlr/interfaces/wlr_pointer.h>
#include <wlr/util/log.h>
#include "backend/x11.h"

static struct wlr_backend_impl backend_impl;
static struct wlr_output_impl output_impl;

static uint32_t xcb_button_to_wl(uint32_t button) {
	switch (button) {
	case XCB_BUTTON_INDEX_1: return BTN_LEFT;
	case XCB_BUTTON_INDEX_2: return BTN_MIDDLE;
	case XCB_BUTTON_INDEX_3: return BTN_RIGHT;
	// XXX: I'm not sure the scroll-wheel direction is right
	case XCB_BUTTON_INDEX_4: return BTN_GEAR_UP;
	case XCB_BUTTON_INDEX_5: return BTN_GEAR_DOWN;
	default: return 0;
	}
}

static bool handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *event) {
	struct wlr_x11_output *output = &x11->output;

	switch (event->response_type) {
	case XCB_EXPOSE: {
		wl_signal_emit(&output->wlr_output.events.frame, output);
		break;
	}
	case XCB_KEY_PRESS:
	case XCB_KEY_RELEASE: {
		xcb_key_press_event_t *ev = (xcb_key_press_event_t *)event;
		struct wlr_event_keyboard_key key = {
			.device = &x11->keyboard_dev,
			.time_msec = ev->time,
			.keycode = ev->detail - 8,
			.state = event->response_type == XCB_KEY_PRESS ?
				WLR_KEY_PRESSED : WLR_KEY_RELEASED,
			.update_state = true,
		};

		// TODO use xcb-xkb for more precise modifiers state?
		wlr_keyboard_notify_key(&x11->keyboard, &key);
		x11->time = ev->time;
		break;
	}
	case XCB_BUTTON_PRESS: {
		xcb_button_press_event_t *ev = (xcb_button_press_event_t *)event;

		if (ev->detail == XCB_BUTTON_INDEX_4 ||
				ev->detail == XCB_BUTTON_INDEX_5) {
			double delta = (ev->detail == XCB_BUTTON_INDEX_4 ? -15 : 15);
			struct wlr_event_pointer_axis axis = {
				.device = &x11->pointer_dev,
				.time_msec = ev->time,
				.source = WLR_AXIS_SOURCE_WHEEL,
				.orientation = WLR_AXIS_ORIENTATION_VERTICAL,
				.delta = delta,
			};
			wl_signal_emit(&x11->pointer.events.axis, &axis);
			x11->time = ev->time;
			break;
		}
	}
	/* fallthrough */
	case XCB_BUTTON_RELEASE: {
		xcb_button_press_event_t *ev = (xcb_button_press_event_t *)event;

		if (ev->detail != XCB_BUTTON_INDEX_4 &&
				ev->detail != XCB_BUTTON_INDEX_5) {
			struct wlr_event_pointer_button button = {
				.device = &x11->pointer_dev,
				.time_msec = ev->time,
				.button = xcb_button_to_wl(ev->detail),
				.state = event->response_type == XCB_BUTTON_PRESS ?
					WLR_BUTTON_PRESSED : WLR_BUTTON_RELEASED,
			};

			wl_signal_emit(&x11->pointer.events.button, &button);
		}
		x11->time = ev->time;
		break;
	}
	case XCB_MOTION_NOTIFY: {
		xcb_motion_notify_event_t *ev = (xcb_motion_notify_event_t *)event;
		struct wlr_event_pointer_motion_absolute abs = {
			.device = &x11->pointer_dev,
			.time_msec = ev->time,
			.x_mm = ev->event_x,
			.y_mm = ev->event_y,
			.width_mm = output->wlr_output.width,
			.height_mm = output->wlr_output.height,
		};

		wl_signal_emit(&x11->pointer.events.motion_absolute, &abs);
		x11->time = ev->time;
		break;
	}
	case XCB_CONFIGURE_NOTIFY: {
		xcb_configure_notify_event_t *ev = (xcb_configure_notify_event_t *)event;

		wlr_output_update_size(&output->wlr_output, ev->width, ev->height);
		wl_signal_emit(&output->wlr_output.events.resolution, output);

		// Move the pointer to its new location
		xcb_query_pointer_cookie_t cookie =
			xcb_query_pointer(x11->xcb_conn, output->win);
		xcb_query_pointer_reply_t *pointer =
			xcb_query_pointer_reply(x11->xcb_conn, cookie, NULL);
		if (!pointer) {
			break;
		}

		struct wlr_event_pointer_motion_absolute abs = {
			.device = &x11->pointer_dev,
			.time_msec = x11->time,
			.x_mm = pointer->root_x,
			.y_mm = pointer->root_y,
			.width_mm = output->wlr_output.width,
			.height_mm = output->wlr_output.height,
		};

		wl_signal_emit(&x11->pointer.events.motion_absolute, &abs);
		break;
	}
	case XCB_GLX_DELETE_QUERIES_ARB: {
		wl_display_terminate(x11->wl_display);
		return true;
		break;
	}
	default:
		break;
	}

	return false;
}

static int x11_event(int fd, uint32_t mask, void *data) {
	struct wlr_x11_backend *x11 = data;
	xcb_generic_event_t *e;
	bool quit = false;

	while (!quit && (e = xcb_poll_for_event(x11->xcb_conn))) {
		quit = handle_x11_event(x11, e);
		free(e);
	}

	return 0;
}

static int signal_frame(void *data) {
	struct wlr_x11_backend *x11 = data;
	wl_signal_emit(&x11->output.wlr_output.events.frame, &x11->output);
	wl_event_source_timer_update(x11->frame_timer, 16);
	return 0;
}

static void init_atom(struct wlr_x11_backend *x11, struct wlr_x11_atom *atom,
		uint8_t only_if_exists, const char *name) {
	atom->cookie = xcb_intern_atom(x11->xcb_conn, only_if_exists, strlen(name), name);
	atom->reply = xcb_intern_atom_reply(x11->xcb_conn, atom->cookie, NULL);
}

struct wlr_backend *wlr_x11_backend_create(struct wl_display *display,
		const char *x11_display) {
	struct wlr_x11_backend *x11 = calloc(1, sizeof(*x11));
	if (!x11) {
		return NULL;
	}

	wlr_backend_init(&x11->backend, &backend_impl);
	x11->wl_display = display;

	x11->xlib_conn = XOpenDisplay(x11_display);
	if (!x11->xlib_conn) {
		wlr_log(L_ERROR, "Failed to open X connection");
		return NULL;
	}

	x11->xcb_conn = XGetXCBConnection(x11->xlib_conn);
	if (!x11->xcb_conn || xcb_connection_has_error(x11->xcb_conn)) {
		wlr_log(L_ERROR, "Failed to open xcb connection");
		goto error_x11;
	}

	XSetEventQueueOwner(x11->xlib_conn, XCBOwnsEventQueue);

	int fd = xcb_get_file_descriptor(x11->xcb_conn);
	struct wl_event_loop *ev = wl_display_get_event_loop(display);
	x11->event_source = wl_event_loop_add_fd(ev, fd, WL_EVENT_READABLE, x11_event, x11);
	if (!x11->event_source) {
		wlr_log(L_ERROR, "Could not create event source");
		goto error_x11;
	}

	x11->frame_timer = wl_event_loop_add_timer(ev, signal_frame, x11);

	x11->screen = xcb_setup_roots_iterator(xcb_get_setup(x11->xcb_conn)).data;

	if (!wlr_egl_init(&x11->egl, EGL_PLATFORM_X11_KHR,
			x11->screen->root_visual, x11->xlib_conn)) {
		goto error_event;
	}

	wlr_input_device_init(&x11->keyboard_dev, WLR_INPUT_DEVICE_KEYBOARD,
		NULL, "X11 keyboard", 0, 0);
	wlr_keyboard_init(&x11->keyboard, NULL);
	x11->keyboard_dev.keyboard = &x11->keyboard;

	wlr_input_device_init(&x11->pointer_dev, WLR_INPUT_DEVICE_POINTER,
		NULL, "X11 pointer", 0, 0);
	wlr_pointer_init(&x11->pointer, NULL);
	x11->pointer_dev.pointer = &x11->pointer;

	return &x11->backend;

error_event:
	wl_event_source_remove(x11->event_source);
error_x11:
	xcb_disconnect(x11->xcb_conn);
	XCloseDisplay(x11->xlib_conn);
	free(x11);
	return NULL;
}

static bool wlr_x11_backend_start(struct wlr_backend *backend) {
	struct wlr_x11_backend *x11 = (struct wlr_x11_backend *)backend;
	struct wlr_x11_output *output = &x11->output;

	uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
	uint32_t values[2] = {
		x11->screen->white_pixel,
		XCB_EVENT_MASK_EXPOSURE |
		XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE |
		XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE |
		XCB_EVENT_MASK_POINTER_MOTION |
		XCB_EVENT_MASK_STRUCTURE_NOTIFY
	};

	output->x11 = x11;

	wlr_output_init(&output->wlr_output, &x11->backend, &output_impl);
	snprintf(output->wlr_output.name, sizeof(output->wlr_output.name), "X11-1");

	output->win = xcb_generate_id(x11->xcb_conn);
	xcb_create_window(x11->xcb_conn, XCB_COPY_FROM_PARENT, output->win, x11->screen->root,
		0, 0, 1024, 768, 1, XCB_WINDOW_CLASS_INPUT_OUTPUT,
		x11->screen->root_visual, mask, values);

	output->surf = wlr_egl_create_surface(&x11->egl, &output->win);
	if (!output->surf) {
		wlr_log(L_ERROR, "Failed to create EGL surface");
		return false;
	}

	init_atom(x11, &x11->atoms.wm_protocols, 1, "WM_PROTOCOLS");
	init_atom(x11, &x11->atoms.wm_delete_window, 0, "WM_DELETE_WINDOW");

	xcb_change_property(x11->xcb_conn, XCB_PROP_MODE_REPLACE, output->win,
		x11->atoms.wm_protocols.reply->atom, XCB_ATOM_ATOM, 32, 1,
		&x11->atoms.wm_delete_window.reply->atom);

	xcb_map_window(x11->xcb_conn, output->win);
	xcb_flush(x11->xcb_conn);
	wlr_output_create_global(&output->wlr_output, x11->wl_display);

	wl_signal_emit(&x11->backend.events.output_add, output);
	wl_signal_emit(&x11->backend.events.input_add, &x11->keyboard_dev);
	wl_signal_emit(&x11->backend.events.input_add, &x11->pointer_dev);

	wl_event_source_timer_update(x11->frame_timer, 16);

	return true;
}

static void wlr_x11_backend_destroy(struct wlr_backend *backend) {
	if (!backend) {
		return;
	}

	struct wlr_x11_backend *x11 = (struct wlr_x11_backend *)backend;

	struct wlr_x11_output *output = &x11->output;
	wlr_output_destroy(&output->wlr_output);

	wl_event_source_remove(x11->frame_timer);
	wlr_egl_free(&x11->egl);

	xcb_disconnect(x11->xcb_conn);
	free(x11);
}

static struct wlr_egl *wlr_x11_backend_get_egl(struct wlr_backend *backend) {
	struct wlr_x11_backend *x11 = (struct wlr_x11_backend *)backend;
	return &x11->egl;
}

bool wlr_backend_is_x11(struct wlr_backend *backend) {
	return backend->impl == &backend_impl;
}

static struct wlr_backend_impl backend_impl = {
	.start = wlr_x11_backend_start,
	.destroy = wlr_x11_backend_destroy,
	.get_egl = wlr_x11_backend_get_egl,
};

static void output_transform(struct wlr_output *wlr_output, enum wl_output_transform transform) {
	struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output;
	output->wlr_output.transform = transform;
}

static void output_destroy(struct wlr_output *wlr_output) {
	struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output;
	struct wlr_x11_backend *x11 = output->x11;

	eglDestroySurface(x11->egl.display, output->surf);
	xcb_destroy_window(x11->xcb_conn, output->win);
	// output has been allocated on the stack, do not free it
}

static void output_make_current(struct wlr_output *wlr_output) {
	struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output;
	struct wlr_x11_backend *x11 = output->x11;

	if (!eglMakeCurrent(x11->egl.display, output->surf, output->surf, x11->egl.context)) {
		wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error());
	}
}

static void output_swap_buffers(struct wlr_output *wlr_output) {
	struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output;
	struct wlr_x11_backend *x11 = output->x11;

	if (!eglSwapBuffers(x11->egl.display, output->surf)) {
		wlr_log(L_ERROR, "eglSwapBuffers failed: %s", egl_error());
	}
}

static struct wlr_output_impl output_impl = {
	.transform = output_transform,
	.destroy = output_destroy,
	.make_current = output_make_current,
	.swap_buffers = output_swap_buffers,
};