hyprwm/wlroots-hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/wlroots-hyprland.git synced 2024-11-04 20:55:58 +01:00
Code Issues Projects Releases Packages Wiki Activity

Add headless input devices

Browse source
This commit is contained in:
emersion 2017-12-17 18:49:20 +01:00
parent 0256de0002
commit bc5bdb7793
No known key found for this signature in database
GPG key ID: 0FDE7BE0E88F5E48
7 changed files with 136 additions and 19 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
backend/headless/backend.c
View file

@ -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;
wl_list_for_each_safe(output, tmp, &backend->outputs, link) {
struct wlr_headless_output *output, *output_tmp;
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);

91
backend/headless/input_device.c Normal file
View file

@ -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;
}

24
backend/headless/output.c
View file

@ -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_backend_output *)wlr_output;
struct wlr_headless_output *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_backend_output *)wlr_output;
struct wlr_headless_output *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_backend_output *)wlr_output;
struct wlr_headless_output *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_backend_output *)wlr_output;
struct wlr_headless_output *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 =
calloc(1, sizeof(struct wlr_headless_backend_output));
struct wlr_headless_output *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;

1
backend/meson.build
View file

@ -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',

9
include/backend/headless.h
View file

@ -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

4
include/wlr/backend/headless.h
View file

@ -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,
enum wlr_input_device_type type);
struct wlr_input_device *wlr_headless_add_input_device(
struct wlr_backend *backend, enum wlr_input_device_type type);
bool wlr_backend_is_headless(struct wlr_backend *backend);
#endif

2
rootston/main.c
View file

@ -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 =