diff --git a/backend/drm/drm.c b/backend/drm/drm.c index 96b7d93d..1fceff95 100644 --- a/backend/drm/drm.c +++ b/backend/drm/drm.c @@ -452,8 +452,7 @@ static bool wlr_drm_connector_set_mode(struct wlr_output *output, crtc->cursor ? crtc->cursor - drm->cursor_planes : -1); conn->state = WLR_DRM_CONN_CONNECTED; - conn->output.current_mode = mode; - wlr_output_update_size(&conn->output, mode->width, mode->height); + wlr_output_update_mode(&conn->output, mode); // Since realloc_crtcs can deallocate planes on OTHER outputs, // we actually need to reinitalise any than has changed diff --git a/backend/drm/renderer.c b/backend/drm/renderer.c index 8a8d7d1f..00182c59 100644 --- a/backend/drm/renderer.c +++ b/backend/drm/renderer.c @@ -24,8 +24,8 @@ bool wlr_drm_renderer_init(struct wlr_drm_backend *drm, return false; } - if (!wlr_egl_init(&renderer->egl, EGL_PLATFORM_GBM_MESA, - GBM_FORMAT_ARGB8888, renderer->gbm)) { + if (!wlr_egl_init(&renderer->egl, EGL_PLATFORM_GBM_MESA, renderer->gbm, + NULL, GBM_FORMAT_ARGB8888)) { goto error_gbm; } diff --git a/backend/headless/backend.c b/backend/headless/backend.c new file mode 100644 index 00000000..f95e3897 --- /dev/null +++ b/backend/headless/backend.c @@ -0,0 +1,114 @@ +#include +#include +#include +#include +#include +#include +#include "backend/headless.h" +#include "glapi.h" + +static bool backend_start(struct wlr_backend *wlr_backend) { + struct wlr_headless_backend *backend = + (struct wlr_headless_backend *)wlr_backend; + wlr_log(L_INFO, "Starting headless backend"); + + 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); + } + + 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; + return true; +} + +static void backend_destroy(struct wlr_backend *wlr_backend) { + struct wlr_headless_backend *backend = + (struct wlr_headless_backend *)wlr_backend; + if (!wlr_backend) { + return; + } + + wl_list_remove(&backend->display_destroy.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); +} + +static struct wlr_egl *backend_get_egl(struct wlr_backend *wlr_backend) { + struct wlr_headless_backend *backend = + (struct wlr_headless_backend *)wlr_backend; + return &backend->egl; +} + +static const struct wlr_backend_impl backend_impl = { + .start = backend_start, + .destroy = backend_destroy, + .get_egl = backend_get_egl, +}; + +static void handle_display_destroy(struct wl_listener *listener, void *data) { + struct wlr_headless_backend *backend = + wl_container_of(listener, backend, display_destroy); + backend_destroy(&backend->backend); +} + +struct wlr_backend *wlr_headless_backend_create(struct wl_display *display) { + wlr_log(L_INFO, "Creating headless backend"); + + struct wlr_headless_backend *backend = + calloc(1, sizeof(struct wlr_headless_backend)); + if (!backend) { + wlr_log(L_ERROR, "Failed to allocate wlr_headless_backend"); + return NULL; + } + wlr_backend_init(&backend->backend, &backend_impl); + backend->display = display; + wl_list_init(&backend->outputs); + wl_list_init(&backend->input_devices); + + static const EGLint config_attribs[] = { + EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, + EGL_ALPHA_SIZE, 0, + EGL_BLUE_SIZE, 8, + EGL_GREEN_SIZE, 8, + EGL_RED_SIZE, 8, + EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, + EGL_NONE, + }; + bool ok = wlr_egl_init(&backend->egl, EGL_PLATFORM_SURFACELESS_MESA, NULL, + (EGLint *)config_attribs, 0); + if (!ok) { + free(backend); + return NULL; + } + + backend->display_destroy.notify = handle_display_destroy; + wl_display_add_destroy_listener(display, &backend->display_destroy); + + return &backend->backend; +} + +bool wlr_backend_is_headless(struct wlr_backend *backend) { + return backend->impl == &backend_impl; +} diff --git a/backend/headless/input_device.c b/backend/headless/input_device.c new file mode 100644 index 00000000..05def775 --- /dev/null +++ b/backend/headless/input_device.c @@ -0,0 +1,91 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#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; +} diff --git a/backend/headless/output.c b/backend/headless/output.c new file mode 100644 index 00000000..9c4ba35e --- /dev/null +++ b/backend/headless/output.c @@ -0,0 +1,146 @@ +#include +#include +#include +#include +#include +#include +#include "backend/headless.h" + +static EGLSurface egl_create_surface(struct wlr_egl *egl, unsigned int width, + unsigned int height) { + EGLint attribs[] = {EGL_WIDTH, width, EGL_HEIGHT, height, EGL_NONE}; + + EGLSurface surf = eglCreatePbufferSurface(egl->display, egl->config, attribs); + if (surf == EGL_NO_SURFACE) { + wlr_log(L_ERROR, "Failed to create EGL surface: %s", egl_error()); + return EGL_NO_SURFACE; + } + return surf; +} + +static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width, + int32_t height, int32_t refresh) { + struct wlr_headless_output *output = + (struct wlr_headless_output *)wlr_output; + struct wlr_headless_backend *backend = output->backend; + + if (output->egl_surface) { + eglDestroySurface(backend->egl.display, output->egl_surface); + } + + output->egl_surface = egl_create_surface(&backend->egl, width, height); + if (output->egl_surface == EGL_NO_SURFACE) { + wlr_log(L_ERROR, "Failed to recreate EGL surface"); + wlr_output_destroy(wlr_output); + return false; + } + + output->frame_delay = 1000000 / refresh; + + wlr_output_update_custom_mode(&output->wlr_output, width, height, refresh); + return true; +} + +static void output_transform(struct wlr_output *wlr_output, + enum wl_output_transform transform) { + 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_output *output = + (struct wlr_headless_output *)wlr_output; + if (!eglMakeCurrent(output->backend->egl.display, + output->egl_surface, output->egl_surface, + output->backend->egl.context)) { + wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error()); + } +} + +static void output_swap_buffers(struct wlr_output *wlr_output) { + // No-op +} + +static void output_destroy(struct wlr_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); + + wl_list_remove(&output->link); + + eglDestroySurface(output->backend->egl.display, output->egl_surface); + free(output); +} + +static const struct wlr_output_impl output_impl = { + .set_custom_mode = output_set_custom_mode, + .transform = output_transform, + .destroy = output_destroy, + .make_current = output_make_current, + .swap_buffers = output_swap_buffers, +}; + +static int signal_frame(void *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; +} + +struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend, + unsigned int width, unsigned int height) { + struct wlr_headless_backend *backend = + (struct wlr_headless_backend *)wlr_backend; + + struct wlr_headless_output *output = + calloc(1, sizeof(struct wlr_headless_output)); + if (output == NULL) { + wlr_log(L_ERROR, "Failed to allocate wlr_headless_output"); + return NULL; + } + output->backend = backend; + wlr_output_init(&output->wlr_output, &backend->backend, &output_impl); + struct wlr_output *wlr_output = &output->wlr_output; + + output->egl_surface = egl_create_surface(&backend->egl, width, height); + if (output->egl_surface == EGL_NO_SURFACE) { + wlr_log(L_ERROR, "Failed to create EGL surface"); + goto error; + } + + output_set_custom_mode(wlr_output, width, height, 60*1000); + strncpy(wlr_output->make, "headless", sizeof(wlr_output->make)); + strncpy(wlr_output->model, "headless", sizeof(wlr_output->model)); + snprintf(wlr_output->name, sizeof(wlr_output->name), "HEADLESS-%d", + wl_list_length(&backend->outputs) + 1); + + if (!eglMakeCurrent(output->backend->egl.display, + output->egl_surface, output->egl_surface, + output->backend->egl.context)) { + wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error()); + goto error; + } + + glViewport(0, 0, wlr_output->width, wlr_output->height); + glClearColor(1.0, 1.0, 1.0, 1.0); + glClear(GL_COLOR_BUFFER_BIT); + + struct wl_event_loop *ev = wl_display_get_event_loop(backend->display); + output->frame_timer = wl_event_loop_add_timer(ev, signal_frame, output); + + wl_list_insert(&backend->outputs, &output->link); + + if (backend->started) { + wl_event_source_timer_update(output->frame_timer, output->frame_delay); + wlr_output_create_global(wlr_output, backend->display); + wl_signal_emit(&backend->backend.events.output_add, wlr_output); + } + + return wlr_output; + +error: + wlr_output_destroy(&output->wlr_output); + return NULL; +} diff --git a/backend/meson.build b/backend/meson.build index c9d47317..68d958a7 100644 --- a/backend/meson.build +++ b/backend/meson.build @@ -9,6 +9,9 @@ backend_files = files( 'drm/properties.c', 'drm/renderer.c', 'drm/util.c', + 'headless/backend.c', + 'headless/output.c', + 'headless/input_device.c', 'libinput/backend.c', 'libinput/events.c', 'libinput/keyboard.c', diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c index 6ebc6615..36fbd8e0 100644 --- a/backend/wayland/backend.c +++ b/backend/wayland/backend.c @@ -185,7 +185,7 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) { } wlr_egl_init(&backend->egl, EGL_PLATFORM_WAYLAND_EXT, - WL_SHM_FORMAT_ARGB8888, backend->remote_display); + backend->remote_display, NULL, WL_SHM_FORMAT_ARGB8888); wlr_egl_bind_display(&backend->egl, backend->local_display); backend->local_display_destroy.notify = handle_display_destroy; diff --git a/backend/wayland/output.c b/backend/wayland/output.c index fc09903e..d841ec49 100644 --- a/backend/wayland/output.c +++ b/backend/wayland/output.c @@ -32,7 +32,7 @@ static bool wlr_wl_output_set_custom_mode(struct wlr_output *_output, int32_t width, int32_t height, int32_t refresh) { struct wlr_wl_backend_output *output = (struct wlr_wl_backend_output *)_output; wl_egl_window_resize(output->egl_window, width, height, 0, 0); - wlr_output_update_size(&output->wlr_output, width, height); + wlr_output_update_custom_mode(&output->wlr_output, width, height, 0); return true; } @@ -229,7 +229,7 @@ static void xdg_toplevel_handle_configure(void *data, struct zxdg_toplevel_v6 *x } // loop over states for maximized etc? wl_egl_window_resize(output->egl_window, width, height, 0, 0); - wlr_output_update_size(&output->wlr_output, width, height); + wlr_output_update_custom_mode(&output->wlr_output, width, height, 0); } static void xdg_toplevel_handle_close(void *data, struct zxdg_toplevel_v6 *xdg_toplevel) { @@ -260,7 +260,7 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) { wlr_output_init(&output->wlr_output, &backend->backend, &output_impl); struct wlr_output *wlr_output = &output->wlr_output; - wlr_output_update_size(wlr_output, 1280, 720); + wlr_output_update_custom_mode(wlr_output, 1280, 720, 0); strncpy(wlr_output->make, "wayland", sizeof(wlr_output->make)); strncpy(wlr_output->model, "wayland", sizeof(wlr_output->model)); snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%d", diff --git a/backend/x11/backend.c b/backend/x11/backend.c index c116e78e..a218c589 100644 --- a/backend/x11/backend.c +++ b/backend/x11/backend.c @@ -117,7 +117,8 @@ static bool handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *e 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); + wlr_output_update_custom_mode(&output->wlr_output, ev->width, + ev->height, 0); // Move the pointer to its new location xcb_query_pointer_cookie_t cookie = @@ -310,8 +311,8 @@ struct wlr_backend *wlr_x11_backend_create(struct wl_display *display, 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)) { + if (!wlr_egl_init(&x11->egl, EGL_PLATFORM_X11_KHR, x11->xlib_conn, NULL, + x11->screen->root_visual)) { goto error_event; } diff --git a/include/backend/headless.h b/include/backend/headless.h new file mode 100644 index 00000000..91ff37dd --- /dev/null +++ b/include/backend/headless.h @@ -0,0 +1,35 @@ +#ifndef BACKEND_HEADLESS_H +#define BACKEND_HEADLESS_H + +#include +#include +#include + +struct wlr_headless_backend { + struct wlr_backend 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_output { + struct wlr_output wlr_output; + + struct wlr_headless_backend *backend; + struct wl_list link; + + void *egl_surface; + struct wl_event_source *frame_timer; + int frame_delay; // ms +}; + +struct wlr_headless_input_device { + struct wlr_input_device wlr_input_device; + + struct wlr_headless_backend *backend; +}; + +#endif diff --git a/include/wlr/backend/headless.h b/include/wlr/backend/headless.h new file mode 100644 index 00000000..68ad84da --- /dev/null +++ b/include/wlr/backend/headless.h @@ -0,0 +1,14 @@ +#ifndef WLR_BACKEND_HEADLESS_H +#define WLR_BACKEND_HEADLESS_H + +#include +#include + +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_device( + struct wlr_backend *backend, enum wlr_input_device_type type); +bool wlr_backend_is_headless(struct wlr_backend *backend); + +#endif diff --git a/include/wlr/interfaces/wlr_output.h b/include/wlr/interfaces/wlr_output.h index 1cfe7568..6d71f9b6 100644 --- a/include/wlr/interfaces/wlr_output.h +++ b/include/wlr/interfaces/wlr_output.h @@ -28,8 +28,10 @@ struct wlr_output_impl { void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend, const struct wlr_output_impl *impl); void wlr_output_free(struct wlr_output *output); -void wlr_output_update_size(struct wlr_output *output, int32_t width, - int32_t height); +void wlr_output_update_mode(struct wlr_output *output, + struct wlr_output_mode *mode); +void wlr_output_update_custom_mode(struct wlr_output *output, int32_t width, + int32_t height, int32_t refresh); struct wl_global *wlr_output_create_global(struct wlr_output *wlr_output, struct wl_display *display); void wlr_output_destroy_global(struct wlr_output *wlr_output); diff --git a/include/wlr/render/egl.h b/include/wlr/render/egl.h index 67a81f37..bdb8d286 100644 --- a/include/wlr/render/egl.h +++ b/include/wlr/render/egl.h @@ -22,7 +22,8 @@ struct wlr_egl { * Initializes an egl context for the given platform and remote display. * Will attempt to load all possibly required api functions. */ -bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id, void *display); +bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *remote_display, + EGLint *config_attribs, EGLint visual_id); /** * Frees all related egl resources, makes the context not-current and diff --git a/include/wlr/types/wlr_output.h b/include/wlr/types/wlr_output.h index 037fa515..a974a154 100644 --- a/include/wlr/types/wlr_output.h +++ b/include/wlr/types/wlr_output.h @@ -47,6 +47,7 @@ struct wlr_output { char serial[16]; float scale; int32_t width, height; + int32_t refresh; // mHz int32_t phys_width, phys_height; // mm enum wl_output_subpixel subpixel; enum wl_output_transform transform; diff --git a/render/egl.c b/render/egl.c index e895df8d..fe20973c 100644 --- a/render/egl.c +++ b/render/egl.c @@ -1,3 +1,4 @@ +#include #include #include #include @@ -47,7 +48,8 @@ const char *egl_error(void) { } } -static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) { +static bool egl_get_config(EGLDisplay disp, EGLint *attribs, EGLConfig *out, + EGLint visual_id) { EGLint count = 0, matched = 0, ret; ret = eglGetConfigs(disp, NULL, 0, &count); @@ -58,7 +60,7 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) { EGLConfig configs[count]; - ret = eglChooseConfig(disp, NULL, configs, count, &matched); + ret = eglChooseConfig(disp, attribs, configs, count, &matched); if (ret == EGL_FALSE) { wlr_log(L_ERROR, "eglChooseConfig failed"); return false; @@ -71,7 +73,7 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) { continue; } - if (visual == visual_id) { + if (!visual_id || visual == visual_id) { *out = configs[i]; return true; } @@ -81,8 +83,8 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) { return false; } -bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id, - void *remote_display) { +bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *remote_display, + EGLint *config_attribs, EGLint visual_id) { if (!load_glapi()) { return false; } @@ -92,7 +94,12 @@ bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id, goto error; } - egl->display = eglGetPlatformDisplayEXT(platform, remote_display, NULL); + if (platform == EGL_PLATFORM_SURFACELESS_MESA) { + assert(remote_display == NULL); + egl->display = eglGetDisplay(EGL_DEFAULT_DISPLAY); + } else { + egl->display = eglGetPlatformDisplayEXT(platform, remote_display, NULL); + } if (egl->display == EGL_NO_DISPLAY) { wlr_log(L_ERROR, "Failed to create EGL display: %s", egl_error()); goto error; @@ -104,7 +111,7 @@ bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id, goto error; } - if (!egl_get_config(egl->display, &egl->config, visual_id)) { + if (!egl_get_config(egl->display, config_attribs, &egl->config, visual_id)) { wlr_log(L_ERROR, "Failed to get EGL config"); goto error; } diff --git a/rootston/main.c b/rootston/main.c index 58e5a5e5..d17079d3 100644 --- a/rootston/main.c +++ b/rootston/main.c @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -29,7 +30,11 @@ int main(int argc, char **argv) { assert(server.wl_display = wl_display_create()); assert(server.wl_event_loop = wl_display_get_event_loop(server.wl_display)); - assert(server.backend = wlr_backend_autocreate(server.wl_display)); + //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 = diff --git a/types/wlr_output.c b/types/wlr_output.c index de1d29df..923f8f52 100644 --- a/types/wlr_output.c +++ b/types/wlr_output.c @@ -39,7 +39,7 @@ static void wl_output_send_to_resource(struct wl_resource *resource) { if (wl_list_length(&output->modes) == 0) { // Output has no mode, send the current width/height wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT, - output->width, output->height, 0); + output->width, output->height, output->refresh); } } if (version >= WL_OUTPUT_SCALE_SINCE_VERSION) { @@ -65,9 +65,9 @@ static void wlr_output_send_current_mode_to_resource( wl_output_send_mode(resource, flags | WL_OUTPUT_MODE_CURRENT, mode->width, mode->height, mode->refresh); } else { - // Output has no mode, send the current width/height + // Output has no mode wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT, output->width, - output->height, 0); + output->height, output->refresh); } if (version >= WL_OUTPUT_DONE_SINCE_VERSION) { wl_output_send_done(resource); @@ -192,9 +192,17 @@ bool wlr_output_set_custom_mode(struct wlr_output *output, int32_t width, return result; } -void wlr_output_update_size(struct wlr_output *output, int32_t width, - int32_t height) { - if (output->width == width && output->height == height) { +void wlr_output_update_mode(struct wlr_output *output, + struct wlr_output_mode *mode) { + output->current_mode = mode; + wlr_output_update_custom_mode(output, mode->width, mode->height, + mode->refresh); +} + +void wlr_output_update_custom_mode(struct wlr_output *output, int32_t width, + int32_t height, int32_t refresh) { + if (output->width == width && output->height == height && + output->refresh == refresh) { return; } @@ -202,6 +210,8 @@ void wlr_output_update_size(struct wlr_output *output, int32_t width, output->height = height; wlr_output_update_matrix(output); + output->refresh = refresh; + struct wl_resource *resource; wl_resource_for_each(resource, &output->wl_resources) { wlr_output_send_current_mode_to_resource(resource);