Add headless input devices

backend/headless/backend.c

@@ -3,6 +3,7 @@
 #include <EGL/eglext.h>
 #include <wlr/util/log.h>
 #include <wlr/interfaces/wlr_output.h>
+#include <wlr/interfaces/wlr_input_device.h>
 #include "backend/headless.h"
 #include "glapi.h"
 
@@ -11,11 +12,19 @@ static bool backend_start(struct wlr_backend *wlr_backend) {
 		(struct wlr_headless_backend *)wlr_backend;
 	wlr_log(L_INFO, "Starting headless backend");
 
-	struct wlr_headless_backend_output *output;
+	struct wlr_headless_output *output;
 	wl_list_for_each(output, &backend->outputs, link) {
 		wl_event_source_timer_update(output->frame_timer, output->frame_delay);
 		wlr_output_create_global(&output->wlr_output, backend->display);
-		wl_signal_emit(&backend->backend.events.output_add, &output->wlr_output);
+		wl_signal_emit(&backend->backend.events.output_add,
+			&output->wlr_output);
+	}
+
+	struct wlr_headless_input_device *input_device;
+	wl_list_for_each(input_device, &backend->input_devices,
+			wlr_input_device.link) {
+		wl_signal_emit(&backend->backend.events.input_add,
+			&input_device->wlr_input_device);
 	}
 
 	backend->started = true;
@@ -31,11 +40,17 @@ static void backend_destroy(struct wlr_backend *wlr_backend) {
 
 	wl_list_remove(&backend->display_destroy.link);
 
-	struct wlr_headless_backend_output *output, *tmp;
+	struct wlr_headless_output *output, *output_tmp;
-	wl_list_for_each_safe(output, tmp, &backend->outputs, link) {
+	wl_list_for_each_safe(output, output_tmp, &backend->outputs, link) {
 		wlr_output_destroy(&output->wlr_output);
 	}
 
+	struct wlr_headless_input_device *input_device, *input_device_tmp;
+	wl_list_for_each_safe(input_device, input_device_tmp,
+			&backend->input_devices, wlr_input_device.link) {
+		wlr_input_device_destroy(&input_device->wlr_input_device);
+	}
+
 	wlr_egl_finish(&backend->egl);
 	free(backend);
 }
@@ -162,6 +177,7 @@ struct wlr_backend *wlr_headless_backend_create(struct wl_display *display) {
 	wlr_backend_init(&backend->backend, &backend_impl);
 	backend->display = display;
 	wl_list_init(&backend->outputs);
+	wl_list_init(&backend->input_devices);
 
 	egl_init(&backend->egl);
 

backend/headless/input_device.c

@@ -0,0 +1,91 @@
+#include <stdlib.h>
+#include <wlr/interfaces/wlr_input_device.h>
+#include <wlr/interfaces/wlr_pointer.h>
+#include <wlr/interfaces/wlr_keyboard.h>
+#include <wlr/interfaces/wlr_touch.h>
+#include <wlr/interfaces/wlr_tablet_tool.h>
+#include <wlr/interfaces/wlr_tablet_pad.h>
+#include <wlr/util/log.h>
+#include "backend/headless.h"
+
+static void input_device_destroy(struct wlr_input_device *wlr_dev) {
+	struct wlr_headless_input_device *device =
+		(struct wlr_headless_input_device *)wlr_dev;
+	wl_signal_emit(&device->backend->backend.events.input_remove, wlr_dev);
+	free(device);
+}
+
+static struct wlr_input_device_impl input_device_impl = {
+	.destroy = input_device_destroy,
+};
+
+struct wlr_input_device *wlr_headless_add_input_device(
+		struct wlr_backend *wlr_backend, enum wlr_input_device_type type) {
+	struct wlr_headless_backend *backend =
+		(struct wlr_headless_backend *)wlr_backend;
+
+	struct wlr_headless_input_device *device =
+		calloc(1, sizeof(struct wlr_headless_input_device));
+	if (device == NULL) {
+		return NULL;
+	}
+	device->backend = backend;
+
+	int vendor = 0;
+	int product = 0;
+	const char *name = "headless";
+	struct wlr_input_device *wlr_device = &device->wlr_input_device;
+	wlr_input_device_init(wlr_device, type, &input_device_impl, name, vendor,
+		product);
+
+	switch (type) {
+	case WLR_INPUT_DEVICE_KEYBOARD:
+		wlr_device->keyboard = calloc(1, sizeof(struct wlr_keyboard));
+		if (wlr_device->keyboard == NULL) {
+			wlr_log(L_ERROR, "Unable to allocate wlr_keyboard");
+			return NULL;
+		}
+		wlr_keyboard_init(wlr_device->keyboard, NULL);
+		break;
+	case WLR_INPUT_DEVICE_POINTER:
+		wlr_device->pointer = calloc(1, sizeof(struct wlr_pointer));
+		if (wlr_device->pointer == NULL) {
+			wlr_log(L_ERROR, "Unable to allocate wlr_pointer");
+			return NULL;
+		}
+		wlr_pointer_init(wlr_device->pointer, NULL);
+		break;
+	case WLR_INPUT_DEVICE_TOUCH:
+		wlr_device->touch = calloc(1, sizeof(struct wlr_touch));
+		if (wlr_device->touch == NULL) {
+			wlr_log(L_ERROR, "Unable to allocate wlr_touch");
+			return NULL;
+		}
+		wlr_touch_init(wlr_device->touch, NULL);
+		break;
+	case WLR_INPUT_DEVICE_TABLET_TOOL:
+		wlr_device->tablet_tool = calloc(1, sizeof(struct wlr_tablet_tool));
+		if (wlr_device->tablet_tool == NULL) {
+			wlr_log(L_ERROR, "Unable to allocate wlr_tablet_tool");
+			return NULL;
+		}
+		wlr_tablet_tool_init(wlr_device->tablet_tool, NULL);
+		break;
+	case WLR_INPUT_DEVICE_TABLET_PAD:
+		wlr_device->tablet_pad = calloc(1, sizeof(struct wlr_tablet_pad));
+		if (wlr_device->tablet_pad == NULL) {
+			wlr_log(L_ERROR, "Unable to allocate wlr_tablet_pad");
+			return NULL;
+		}
+		wlr_tablet_pad_init(wlr_device->tablet_pad, NULL);
+		break;
+	}
+
+	wl_list_insert(&backend->input_devices, &wlr_device->link);
+
+	if (backend->started) {
+		wl_signal_emit(&backend->backend.events.input_add, wlr_device);
+	}
+
+	return wlr_device;
+}

backend/headless/output.c

@@ -20,8 +20,8 @@ static EGLSurface egl_create_surface(struct wlr_egl *egl, unsigned int width,
 
 static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width,
 		int32_t height, int32_t refresh) {
-	struct wlr_headless_backend_output *output =
+	struct wlr_headless_output *output =
-		(struct wlr_headless_backend_output *)wlr_output;
+		(struct wlr_headless_output *)wlr_output;
 	struct wlr_headless_backend *backend = output->backend;
 
 	if (output->egl_surface) {
@@ -43,14 +43,14 @@ static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width,
 
 static void output_transform(struct wlr_output *wlr_output,
 		enum wl_output_transform transform) {
-	struct wlr_headless_backend_output *output =
+	struct wlr_headless_output *output =
-		(struct wlr_headless_backend_output *)wlr_output;
+		(struct wlr_headless_output *)wlr_output;
 	output->wlr_output.transform = transform;
 }
 
 static void output_make_current(struct wlr_output *wlr_output) {
-	struct wlr_headless_backend_output *output =
+	struct wlr_headless_output *output =
-		(struct wlr_headless_backend_output *)wlr_output;
+		(struct wlr_headless_output *)wlr_output;
 	if (!eglMakeCurrent(output->backend->egl.display,
 		output->egl_surface, output->egl_surface,
 		output->backend->egl.context)) {
@@ -63,8 +63,8 @@ static void output_swap_buffers(struct wlr_output *wlr_output) {
 }
 
 static void output_destroy(struct wlr_output *wlr_output) {
-	struct wlr_headless_backend_output *output =
+	struct wlr_headless_output *output =
-		(struct wlr_headless_backend_output *)wlr_output;
+		(struct wlr_headless_output *)wlr_output;
 	wl_signal_emit(&output->backend->backend.events.output_remove,
 		&output->wlr_output);
 
@@ -83,7 +83,7 @@ static const struct wlr_output_impl output_impl = {
 };
 
 static int signal_frame(void *data) {
-	struct wlr_headless_backend_output *output = data;
+	struct wlr_headless_output *output = data;
 	wl_signal_emit(&output->wlr_output.events.frame, &output->wlr_output);
 	wl_event_source_timer_update(output->frame_timer, output->frame_delay);
 	return 0;
@@ -94,10 +94,10 @@ struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend,
 	struct wlr_headless_backend *backend =
 		(struct wlr_headless_backend *)wlr_backend;
 
-	struct wlr_headless_backend_output *output =
+	struct wlr_headless_output *output =
-		calloc(1, sizeof(struct wlr_headless_backend_output));
+		calloc(1, sizeof(struct wlr_headless_output));
 	if (output == NULL) {
-		wlr_log(L_ERROR, "Failed to allocate wlr_headless_backend_output");
+		wlr_log(L_ERROR, "Failed to allocate wlr_headless_output");
 		return NULL;
 	}
 	output->backend = backend;

backend/meson.build

@@ -11,6 +11,7 @@ backend_files = files(
 	'drm/util.c',
 	'headless/backend.c',
 	'headless/output.c',
+	'headless/input_device.c',
 	'libinput/backend.c',
 	'libinput/events.c',
 	'libinput/keyboard.c',

include/backend/headless.h

@@ -10,11 +10,12 @@ struct wlr_headless_backend {
 	struct wlr_egl egl;
 	struct wl_display *display;
 	struct wl_list outputs;
+	struct wl_list input_devices;
 	struct wl_listener display_destroy;
 	bool started;
 };
 
-struct wlr_headless_backend_output {
+struct wlr_headless_output {
 	struct wlr_output wlr_output;
 
 	struct wlr_headless_backend *backend;
@@ -25,4 +26,10 @@ struct wlr_headless_backend_output {
 	int frame_delay; // ms
 };
 
+struct wlr_headless_input_device {
+	struct wlr_input_device wlr_input_device;
+
+	struct wlr_headless_backend *backend;
+};
+
 #endif

include/wlr/backend/headless.h

@@ -7,8 +7,8 @@
 struct wlr_backend *wlr_headless_backend_create(struct wl_display *display);
 struct wlr_output *wlr_headless_add_output(struct wlr_backend *backend,
 	unsigned int width, unsigned int height);
-struct wlr_input_device *wlr_headless_add_input(struct wlr_backend *backend,
+struct wlr_input_device *wlr_headless_add_input_device(
-	enum wlr_input_device_type type);
+	struct wlr_backend *backend, enum wlr_input_device_type type);
 bool wlr_backend_is_headless(struct wlr_backend *backend);
 
 #endif

rootston/main.c

@@ -33,6 +33,8 @@ int main(int argc, char **argv) {
 	//assert(server.backend = wlr_backend_autocreate(server.wl_display));
 	assert(server.backend = wlr_headless_backend_create(server.wl_display));
 	wlr_headless_add_output(server.backend, 1280, 720);
+	wlr_headless_add_input_device(server.backend, WLR_INPUT_DEVICE_KEYBOARD);
+	wlr_headless_add_input_device(server.backend, WLR_INPUT_DEVICE_POINTER);
 
 	assert(server.renderer = wlr_gles2_renderer_create(server.backend));
 	server.data_device_manager =