diff options
48 files changed, 872 insertions, 866 deletions
@@ -1,7 +1,7 @@ # wlroots Pluggable, composable, unopinionated modules for building a -[Wayland](http://wayland.freedesktop.org/) compositor; or about 40,000 lines of +[Wayland](http://wayland.freedesktop.org/) compositor; or about 50,000 lines of code you were going to write anyway. - wlroots provides backends that abstract the underlying display and input @@ -62,12 +62,12 @@ If you choose to enable X11 support: * xcb * xcb-composite * xcb-xfixes +* xcb-xinput * xcb-image * xcb-render * x11-xcb * xcb-errors (optional, for improved error reporting) * x11-icccm (optional, for improved Xwayland introspection) -* xcb-xkb (optional, for improved keyboard handling on the X11 backend) Run these commands: diff --git a/backend/backend.c b/backend/backend.c index c5dcdb48..b369a135 100644 --- a/backend/backend.c +++ b/backend/backend.c @@ -17,8 +17,7 @@ #include <wlr/util/log.h> #include "backend/multi.h" -/* WLR_HAS_X11_BACKEND needs to be after wlr/config.h */ -#ifdef WLR_HAS_X11_BACKEND +#if WLR_HAS_X11_BACKEND #include <wlr/backend/x11.h> #endif @@ -102,7 +101,7 @@ static struct wlr_backend *attempt_wl_backend(struct wl_display *display, return backend; } -#ifdef WLR_HAS_X11_BACKEND +#if WLR_HAS_X11_BACKEND static struct wlr_backend *attempt_x11_backend(struct wl_display *display, const char *x11_display, wlr_renderer_create_func_t create_renderer_func) { struct wlr_backend *backend = wlr_x11_backend_create(display, x11_display, create_renderer_func); @@ -165,7 +164,7 @@ static struct wlr_backend *attempt_backend_by_name(struct wl_display *display, const char *name, wlr_renderer_create_func_t create_renderer_func) { if (strcmp(name, "wayland") == 0) { return attempt_wl_backend(display, create_renderer_func); -#ifdef WLR_HAS_X11_BACKEND +#if WLR_HAS_X11_BACKEND } else if (strcmp(name, "x11") == 0) { return attempt_x11_backend(display, NULL, create_renderer_func); #endif @@ -248,7 +247,7 @@ struct wlr_backend *wlr_backend_autocreate(struct wl_display *display, } } -#ifdef WLR_HAS_X11_BACKEND +#if WLR_HAS_X11_BACKEND const char *x11_display = getenv("DISPLAY"); if (x11_display) { struct wlr_backend *x11_backend = diff --git a/backend/drm/drm.c b/backend/drm/drm.c index 9fd5c6a3..c2186932 100644 --- a/backend/drm/drm.c +++ b/backend/drm/drm.c @@ -1133,6 +1133,12 @@ void scan_drm_connectors(struct wlr_drm_backend *drm) { wlr_log_errno(WLR_ERROR, "Allocation failed"); continue; } + + if (drm_conn->modes[i].flags & DRM_MODE_FLAG_INTERLACE) { + free(mode); + continue; + } + mode->drm_mode = drm_conn->modes[i]; mode->wlr_mode.width = mode->drm_mode.hdisplay; mode->wlr_mode.height = mode->drm_mode.vdisplay; diff --git a/backend/meson.build b/backend/meson.build index dd1f4df3..03f8ea7d 100644 --- a/backend/meson.build +++ b/backend/meson.build @@ -23,7 +23,6 @@ backend_files = files( 'session/session.c', 'wayland/backend.c', 'wayland/output.c', - 'wayland/registry.c', 'wayland/wl_seat.c', ) diff --git a/backend/session/direct-ipc.c b/backend/session/direct-ipc.c index 3abce46a..2b9634da 100644 --- a/backend/session/direct-ipc.c +++ b/backend/session/direct-ipc.c @@ -24,7 +24,7 @@ enum { DRM_MAJOR = 226 }; -#ifdef WLR_HAS_LIBCAP +#if WLR_HAS_LIBCAP #include <sys/capability.h> static bool have_permissions(void) { diff --git a/backend/session/logind.c b/backend/session/logind.c index b44112e6..bfe12190 100644 --- a/backend/session/logind.c +++ b/backend/session/logind.c @@ -15,10 +15,10 @@ #include <wlr/util/log.h> #include "util/signal.h" -#ifdef WLR_HAS_SYSTEMD +#if WLR_HAS_SYSTEMD #include <systemd/sd-bus.h> #include <systemd/sd-login.h> -#elif defined(WLR_HAS_ELOGIND) +#elif WLR_HAS_ELOGIND #include <elogind/sd-bus.h> #include <elogind/sd-login.h> #endif diff --git a/backend/session/session.c b/backend/session/session.c index 041d8f83..96cde65c 100644 --- a/backend/session/session.c +++ b/backend/session/session.c @@ -19,7 +19,7 @@ extern const struct session_impl session_logind; extern const struct session_impl session_direct; static const struct session_impl *impls[] = { -#if defined(WLR_HAS_SYSTEMD) || defined(WLR_HAS_ELOGIND) +#if WLR_HAS_SYSTEMD || WLR_HAS_ELOGIND &session_logind, #endif &session_direct, @@ -70,7 +70,7 @@ struct wlr_session *wlr_session_create(struct wl_display *disp) { const char *env_wlr_session = getenv("WLR_SESSION"); if (env_wlr_session) { if (!strcmp(env_wlr_session, "logind") || !strcmp(env_wlr_session, "systemd")) { - #if defined(WLR_HAS_SYSTEMD) || defined(WLR_HAS_ELOGIND) + #if WLR_HAS_SYSTEMD || WLR_HAS_ELOGIND session = session_logind.create(disp); #else wlr_log(WLR_ERROR, "wlroots is not compiled with logind support"); diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c index 28f61863..df1bf431 100644 --- a/backend/wayland/backend.c +++ b/backend/wayland/backend.c @@ -1,131 +1,168 @@ #include <assert.h> -#include <EGL/egl.h> -#include <EGL/eglext.h> #include <limits.h> #include <stdint.h> #include <stdlib.h> + +#include <wlr/config.h> + +#include <EGL/egl.h> +#include <EGL/eglext.h> #include <wayland-server.h> + #include <wlr/backend/interface.h> #include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_output.h> #include <wlr/render/egl.h> #include <wlr/render/gles2.h> #include <wlr/util/log.h> + #include "backend/wayland.h" #include "util/signal.h" #include "xdg-shell-unstable-v6-client-protocol.h" -struct wlr_wl_backend *get_wl_backend_from_backend( - struct wlr_backend *wlr_backend) { - assert(wlr_backend_is_wl(wlr_backend)); - return (struct wlr_wl_backend *)wlr_backend; +struct wlr_wl_backend *get_wl_backend_from_backend(struct wlr_backend *backend) { + assert(wlr_backend_is_wl(backend)); + return (struct wlr_wl_backend *)backend; } static int dispatch_events(int fd, uint32_t mask, void *data) { - struct wlr_wl_backend *backend = data; - int count = 0; + struct wlr_wl_backend *wl = data; if ((mask & WL_EVENT_HANGUP) || (mask & WL_EVENT_ERROR)) { - wl_display_terminate(backend->local_display); + wl_display_terminate(wl->local_display); return 0; } if (mask & WL_EVENT_READABLE) { - count = wl_display_dispatch(backend->remote_display); + return wl_display_dispatch(wl->remote_display); + } + if (mask & WL_EVENT_WRITABLE) { + wl_display_flush(wl->remote_display); + return 0; } if (mask == 0) { - count = wl_display_dispatch_pending(backend->remote_display); - wl_display_flush(backend->remote_display); + int count = wl_display_dispatch_pending(wl->remote_display); + wl_display_flush(wl->remote_display); + return count; + } + + return 0; +} + +static void xdg_shell_handle_ping(void *data, struct zxdg_shell_v6 *shell, + uint32_t serial) { + zxdg_shell_v6_pong(shell, serial); +} + +static const struct zxdg_shell_v6_listener xdg_shell_listener = { + xdg_shell_handle_ping, +}; + +static void registry_global(void *data, struct wl_registry *registry, + uint32_t name, const char *iface, uint32_t version) { + struct wlr_wl_backend *wl = data; + + wlr_log(WLR_DEBUG, "Remote wayland global: %s v%d", iface, version); + + if (strcmp(iface, wl_compositor_interface.name) == 0) { + wl->compositor = wl_registry_bind(registry, name, + &wl_compositor_interface, 4); + + } else if (strcmp(iface, wl_seat_interface.name) == 0) { + wl->seat = wl_registry_bind(registry, name, + &wl_seat_interface, 2); + wl_seat_add_listener(wl->seat, &seat_listener, wl); + + } else if (strcmp(iface, wl_shm_interface.name) == 0) { + wl->shm = wl_registry_bind(registry, name, + &wl_shm_interface, 1); + + } else if (strcmp(iface, zxdg_shell_v6_interface.name) == 0) { + wl->shell = wl_registry_bind(registry, name, + &zxdg_shell_v6_interface, 1); + zxdg_shell_v6_add_listener(wl->shell, &xdg_shell_listener, NULL); } - return count; } +static void registry_global_remove(void *data, struct wl_registry *registry, + uint32_t name) { + // TODO +} + +static const struct wl_registry_listener registry_listener = { + .global = registry_global, + .global_remove = registry_global_remove +}; + /* * Initializes the wayland backend. Opens a connection to a remote wayland * compositor and creates surfaces for each output, then registers globals on * the specified display. */ -static bool backend_start(struct wlr_backend *wlr_backend) { - struct wlr_wl_backend *backend = get_wl_backend_from_backend(wlr_backend); +static bool backend_start(struct wlr_backend *backend) { + struct wlr_wl_backend *wl = get_wl_backend_from_backend(backend); wlr_log(WLR_INFO, "Initializating wayland backend"); - poll_wl_registry(backend); - if (!backend->compositor || !backend->shell) { - wlr_log_errno(WLR_ERROR, "Could not obtain retrieve required globals"); - return false; - } - - backend->started = true; + wl->started = true; - for (size_t i = 0; i < backend->requested_outputs; ++i) { - wlr_wl_output_create(&backend->backend); + if (wl->keyboard) { + create_wl_keyboard(wl->keyboard, wl); } - struct wl_event_loop *loop = wl_display_get_event_loop(backend->local_display); - int fd = wl_display_get_fd(backend->remote_display); - int events = WL_EVENT_READABLE | WL_EVENT_ERROR | WL_EVENT_HANGUP; - backend->remote_display_src = wl_event_loop_add_fd(loop, fd, events, - dispatch_events, backend); - wl_event_source_check(backend->remote_display_src); + for (size_t i = 0; i < wl->requested_outputs; ++i) { + wlr_wl_output_create(&wl->backend); + } return true; } -static void backend_destroy(struct wlr_backend *wlr_backend) { - struct wlr_wl_backend *backend = get_wl_backend_from_backend(wlr_backend); - if (backend == NULL) { +static void backend_destroy(struct wlr_backend *backend) { + if (!backend) { return; } + struct wlr_wl_backend *wl = get_wl_backend_from_backend(backend); + struct wlr_wl_output *output, *tmp_output; - wl_list_for_each_safe(output, tmp_output, &backend->outputs, link) { + wl_list_for_each_safe(output, tmp_output, &wl->outputs, link) { wlr_output_destroy(&output->wlr_output); } struct wlr_input_device *input_device, *tmp_input_device; - wl_list_for_each_safe(input_device, tmp_input_device, &backend->devices, link) { + wl_list_for_each_safe(input_device, tmp_input_device, &wl->devices, link) { wlr_input_device_destroy(input_device); } - wlr_signal_emit_safe(&wlr_backend->events.destroy, wlr_backend); + wlr_signal_emit_safe(&wl->backend.events.destroy, &wl->backend); - wl_list_remove(&backend->local_display_destroy.link); + wl_list_remove(&wl->local_display_destroy.link); - free(backend->seat_name); + free(wl->seat_name); - if (backend->remote_display_src) { - wl_event_source_remove(backend->remote_display_src); - } - wlr_renderer_destroy(backend->renderer); - wlr_egl_finish(&backend->egl); - if (backend->pointer) { - wl_pointer_destroy(backend->pointer); - } - if (backend->seat) { - wl_seat_destroy(backend->seat); - } - if (backend->shm) { - wl_shm_destroy(backend->shm); - } - if (backend->shell) { - zxdg_shell_v6_destroy(backend->shell); - } - if (backend->compositor) { - wl_compositor_destroy(backend->compositor); + wl_event_source_remove(wl->remote_display_src); + + wlr_renderer_destroy(wl->renderer); + wlr_egl_finish(&wl->egl); + + if (wl->pointer) { + wl_pointer_destroy(wl->pointer); } - if (backend->registry) { - wl_registry_destroy(backend->registry); + if (wl->seat) { + wl_seat_destroy(wl->seat); } - if (backend->remote_display) { - wl_display_disconnect(backend->remote_display); + if (wl->shm) { + wl_shm_destroy(wl->shm); } - free(backend); + zxdg_shell_v6_destroy(wl->shell); + wl_compositor_destroy(wl->compositor); + wl_registry_destroy(wl->registry); + wl_display_disconnect(wl->remote_display); + free(wl); } -static struct wlr_renderer *backend_get_renderer( - struct wlr_backend *wlr_backend) { - struct wlr_wl_backend *backend = get_wl_backend_from_backend(wlr_backend); - return backend->renderer; +static struct wlr_renderer *backend_get_renderer(struct wlr_backend *backend) { + struct wlr_wl_backend *wl = get_wl_backend_from_backend(backend); + return wl->renderer; } static struct wlr_backend_impl backend_impl = { @@ -139,39 +176,65 @@ bool wlr_backend_is_wl(struct wlr_backend *b) { } static void handle_display_destroy(struct wl_listener *listener, void *data) { - struct wlr_wl_backend *backend = - wl_container_of(listener, backend, local_display_destroy); - backend_destroy(&backend->backend); + struct wlr_wl_backend *wl = + wl_container_of(listener, wl, local_display_destroy); + backend_destroy(&wl->backend); } struct wlr_backend *wlr_wl_backend_create(struct wl_display *display, const char *remote, wlr_renderer_create_func_t create_renderer_func) { wlr_log(WLR_INFO, "Creating wayland backend"); - struct wlr_wl_backend *backend = calloc(1, sizeof(struct wlr_wl_backend)); - if (!backend) { - wlr_log(WLR_ERROR, "Allocation failed: %s", strerror(errno)); + struct wlr_wl_backend *wl = calloc(1, sizeof(*wl)); + if (!wl) { + wlr_log_errno(WLR_ERROR, "Allocation failed"); return NULL; } - wlr_backend_init(&backend->backend, &backend_impl); - wl_list_init(&backend->devices); - wl_list_init(&backend->outputs); + wlr_backend_init(&wl->backend, &backend_impl); - backend->local_display = display; + wl->local_display = display; + wl_list_init(&wl->devices); + wl_list_init(&wl->outputs); - backend->remote_display = wl_display_connect(remote); - if (!backend->remote_display) { + wl->remote_display = wl_display_connect(remote); + if (!wl->remote_display) { wlr_log_errno(WLR_ERROR, "Could not connect to remote display"); - goto error_connect; + goto error_wl; } - backend->registry = wl_display_get_registry(backend->remote_display); - if (backend->registry == NULL) { + wl->registry = wl_display_get_registry(wl->remote_display); + if (!wl->registry) { wlr_log_errno(WLR_ERROR, "Could not obtain reference to remote registry"); + goto error_display; + } + + wl_registry_add_listener(wl->registry, ®istry_listener, wl); + wl_display_dispatch(wl->remote_display); + wl_display_roundtrip(wl->remote_display); + + if (!wl->compositor) { + wlr_log(WLR_ERROR, + "Remote Wayland compositor does not support wl_compositor"); + goto error_registry; + } + if (!wl->shell) { + wlr_log(WLR_ERROR, + "Remote Wayland compositor does not support zxdg_shell_v6"); goto error_registry; } + struct wl_event_loop *loop = wl_display_get_event_loop(wl->local_display); + int fd = wl_display_get_fd(wl->remote_display); + int events = WL_EVENT_READABLE | WL_EVENT_ERROR | WL_EVENT_HANGUP; + wl->remote_display_src = wl_event_loop_add_fd(loop, fd, events, + dispatch_events, wl); + if (!wl->remote_display_src) { + wlr_log(WLR_ERROR, "Failed to create event source"); + goto error_registry; + } + wl_event_source_check(wl->remote_display_src); + static EGLint config_attribs[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RED_SIZE, 1, @@ -185,24 +248,32 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display, create_renderer_func = wlr_renderer_autocreate; } - backend->renderer = create_renderer_func(&backend->egl, EGL_PLATFORM_WAYLAND_EXT, - backend->remote_display, config_attribs, WL_SHM_FORMAT_ARGB8888); + wl->renderer = create_renderer_func(&wl->egl, EGL_PLATFORM_WAYLAND_EXT, + wl->remote_display, config_attribs, WL_SHM_FORMAT_ARGB8888); - if (backend->renderer == NULL) { + if (!wl->renderer) { wlr_log(WLR_ERROR, "Could not create renderer"); - goto error_renderer; + goto error_event; } - backend->local_display_destroy.notify = handle_display_destroy; - wl_display_add_destroy_listener(display, &backend->local_display_destroy); + wl->local_display_destroy.notify = handle_display_destroy; + wl_display_add_destroy_listener(display, &wl->local_display_destroy); - return &backend->backend; + return &wl->backend; -error_renderer: - wl_registry_destroy(backend->registry); +error_event: + wl_event_source_remove(wl->remote_display_src); error_registry: - wl_display_disconnect(backend->remote_display); -error_connect: - free(backend); + if (wl->compositor) { + wl_compositor_destroy(wl->compositor); + } + if (wl->shell) { + zxdg_shell_v6_destroy(wl->shell); + } + wl_registry_destroy(wl->registry); +error_display: + wl_display_disconnect(wl->remote_display); +error_wl: + free(wl); return NULL; } diff --git a/backend/wayland/output.c b/backend/wayland/output.c index f90c6009..03322678 100644 --- a/backend/wayland/output.c +++ b/backend/wayland/output.c @@ -6,11 +6,14 @@ #include <sys/mman.h> #include <sys/types.h> #include <unistd.h> + #include <wayland-client.h> + #include <wlr/interfaces/wlr_output.h> #include <wlr/render/wlr_renderer.h> #include <wlr/types/wlr_matrix.h> #include <wlr/util/log.h> + #include "backend/wayland.h" #include "util/signal.h" #include "xdg-shell-unstable-v6-client-protocol.h" diff --git a/backend/wayland/registry.c b/backend/wayland/registry.c deleted file mode 100644 index 8b154750..00000000 --- a/backend/wayland/registry.c +++ /dev/null @@ -1,55 +0,0 @@ -#include <stdint.h> -#include <stdlib.h> -#include <string.h> -#include <wayland-client.h> -#include <wlr/util/log.h> -#include "backend/wayland.h" -#include "xdg-shell-unstable-v6-client-protocol.h" - -static void xdg_shell_handle_ping(void *data, struct zxdg_shell_v6 *shell, - uint32_t serial) { - zxdg_shell_v6_pong(shell, serial); -} - -static const struct zxdg_shell_v6_listener xdg_shell_listener = { - xdg_shell_handle_ping, -}; - - -static void registry_global(void *data, struct wl_registry *registry, - uint32_t name, const char *interface, uint32_t version) { - struct wlr_wl_backend *backend = data; - wlr_log(WLR_DEBUG, "Remote wayland global: %s v%d", interface, version); - - if (strcmp(interface, wl_compositor_interface.name) == 0) { - backend->compositor = wl_registry_bind(registry, name, - &wl_compositor_interface, version); - } else if (strcmp(interface, zxdg_shell_v6_interface.name) == 0) { - backend->shell = wl_registry_bind(registry, name, - &zxdg_shell_v6_interface, version); - zxdg_shell_v6_add_listener(backend->shell, &xdg_shell_listener, NULL); - } else if (strcmp(interface, wl_shm_interface.name) == 0) { - backend->shm = wl_registry_bind(registry, name, - &wl_shm_interface, version); - } else if (strcmp(interface, wl_seat_interface.name) == 0) { - backend->seat = wl_registry_bind(registry, name, - &wl_seat_interface, version); - wl_seat_add_listener(backend->seat, &seat_listener, backend); - } -} - -static void registry_global_remove(void *data, struct wl_registry *registry, - uint32_t name) { - // TODO -} - -static const struct wl_registry_listener registry_listener = { - .global = registry_global, - .global_remove = registry_global_remove -}; - -void poll_wl_registry(struct wlr_wl_backend *backend) { - wl_registry_add_listener(backend->registry, ®istry_listener, backend); - wl_display_dispatch(backend->remote_display); - wl_display_roundtrip(backend->remote_display); -} diff --git a/backend/wayland/wl_seat.c b/backend/wayland/wl_seat.c index 562d9431..c4098987 100644 --- a/backend/wayland/wl_seat.c +++ b/backend/wayland/wl_seat.c @@ -1,16 +1,20 @@ #define _POSIX_C_SOURCE 200809L + #include <assert.h> #include <stdint.h> #include <stdlib.h> #include <string.h> #include <time.h> + #include <wayland-client.h> + #include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_keyboard.h> #include <wlr/interfaces/wlr_output.h> #include <wlr/interfaces/wlr_pointer.h> #include <wlr/interfaces/wlr_touch.h> #include <wlr/util/log.h> + #include "backend/wayland.h" #include "util/signal.h" @@ -321,8 +325,7 @@ static void pointer_handle_output_destroy(struct wl_listener *listener, wlr_input_device_destroy(&pointer->input_device->wlr_input_device); } -void create_wl_pointer(struct wl_pointer *wl_pointer, - struct wlr_wl_output *output) { +void create_wl_pointer(struct wl_pointer *wl_pointer, struct wlr_wl_output *output) { struct wlr_wl_backend *backend = output->backend; struct wlr_input_device *wlr_dev; @@ -364,6 +367,28 @@ void create_wl_pointer(struct wl_pointer *wl_pointer, wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); } +void create_wl_keyboard(struct wl_keyboard *wl_keyboard, struct wlr_wl_backend *wl) { + struct wlr_wl_input_device *dev = + create_wl_input_device(wl, WLR_INPUT_DEVICE_KEYBOARD); + if (!dev) { + return; + } + + struct wlr_input_device *wlr_dev = &dev->wlr_input_device; + + wlr_dev->keyboard = calloc(1, sizeof(*wlr_dev->keyboard)); + if (!wlr_dev->keyboard) { + wlr_log_errno(WLR_ERROR, "Allocation failed"); + free(dev); + return; + } + wlr_keyboard_init(wlr_dev->keyboard, NULL); + + wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, wlr_dev); + dev->resource = wl_keyboard; + wlr_signal_emit_safe(&wl->backend.events.new_input, wlr_dev); +} + static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat, enum wl_seat_capability caps) { struct wlr_wl_backend *backend = data; @@ -384,25 +409,13 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat, } if ((caps & WL_SEAT_CAPABILITY_KEYBOARD)) { wlr_log(WLR_DEBUG, "seat %p offered keyboard", (void*) wl_seat); - struct wlr_wl_input_device *dev = create_wl_input_device(backend, - WLR_INPUT_DEVICE_KEYBOARD); - if (dev == NULL) { - wlr_log(WLR_ERROR, "Allocation failed"); - return; - } - struct wlr_input_device *wlr_dev = &dev->wlr_input_device; - wlr_dev->keyboard = calloc(1, sizeof(struct wlr_keyboard)); - if (!wlr_dev->keyboard) { - free(dev); - wlr_log(WLR_ERROR, "Allocation failed"); - return; - } - wlr_keyboard_init(wlr_dev->keyboard, NULL); struct wl_keyboard *wl_keyboard = wl_seat_get_keyboard(wl_seat); - wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, wlr_dev); - dev->resource = wl_keyboard; - wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); + backend->keyboard = wl_keyboard; + + if (backend->started) { + create_wl_keyboard(wl_keyboard, backend); + } } } diff --git a/backend/x11/backend.c b/backend/x11/backend.c index c0a11fbb..38715631 100644 --- a/backend/x11/backend.c +++ b/backend/x11/backend.c @@ -1,25 +1,29 @@ #define _POSIX_C_SOURCE 200112L + #include <assert.h> #include <limits.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <time.h> + +#include <wlr/config.h> + +#include <X11/Xlib-xcb.h> #include <wayland-server.h> +#include <xcb/xcb.h> +#include <xcb/xfixes.h> +#include <xcb/xinput.h> + #include <wlr/backend/interface.h> #include <wlr/backend/x11.h> -#include <wlr/config.h> #include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_keyboard.h> #include <wlr/interfaces/wlr_pointer.h> #include <wlr/render/egl.h> -#include <wlr/render/gles2.h> +#include <wlr/render/wlr_renderer.h> #include <wlr/util/log.h> -#include <X11/Xlib-xcb.h> -#include <xcb/xcb.h> -#ifdef WLR_HAS_XCB_XKB -#include <xcb/xkb.h> -#endif + #include "backend/x11.h" #include "util/signal.h" @@ -36,8 +40,6 @@ struct wlr_x11_output *get_x11_output_from_window_id( static void handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *event) { - handle_x11_input_event(x11, event); - switch (event->response_type & XCB_EVENT_RESPONSE_TYPE_MASK) { case XCB_EXPOSE: { xcb_expose_event_t *ev = (xcb_expose_event_t *)event; @@ -69,6 +71,12 @@ static void handle_x11_event(struct wlr_x11_backend *x11, } break; } + case XCB_GE_GENERIC: { + xcb_ge_generic_event_t *ev = (xcb_ge_generic_event_t *)event; + if (ev->extension == x11->xinput_opcode) { + handle_x11_xinput_event(x11, ev); + } + } } } @@ -81,7 +89,7 @@ static int x11_event(int fd, uint32_t mask, void *data) { } xcb_generic_event_t *e; - while ((e = xcb_poll_for_event(x11->xcb_conn))) { + while ((e = xcb_poll_for_event(x11->xcb))) { handle_x11_event(x11, e); free(e); } @@ -99,83 +107,6 @@ static bool backend_start(struct wlr_backend *backend) { struct wlr_x11_backend *x11 = get_x11_backend_from_backend(backend); x11->started = true; - struct { - const char *name; - xcb_intern_atom_cookie_t cookie; - xcb_atom_t *atom; - } atom[] = { - { - .name = "WM_PROTOCOLS", - .atom = &x11->atoms.wm_protocols, - }, - { - .name = "WM_DELETE_WINDOW", - .atom = &x11->atoms.wm_delete_window, - }, - { - .name = "_NET_WM_NAME", - .atom = &x11->atoms.net_wm_name, - }, - { - .name = "UTF8_STRING", - .atom = &x11->atoms.utf8_string, - }, - }; - - for (size_t i = 0; i < sizeof(atom) / sizeof(atom[0]); ++i) { - atom[i].cookie = xcb_intern_atom(x11->xcb_conn, - true, strlen(atom[i].name), atom[i].name); - } - - for (size_t i = 0; i < sizeof(atom) / sizeof(atom[0]); ++i) { - xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply( - x11->xcb_conn, atom[i].cookie, NULL); - - if (reply) { - *atom[i].atom = reply->atom; - free(reply); - } else { - *atom[i].atom = XCB_ATOM_NONE; - } - } - - // create a blank cursor - xcb_pixmap_t pix = xcb_generate_id(x11->xcb_conn); - xcb_create_pixmap(x11->xcb_conn, 1, pix, x11->screen->root, 1, 1); - - x11->cursor = xcb_generate_id(x11->xcb_conn); - xcb_create_cursor(x11->xcb_conn, x11->cursor, pix, pix, 0, 0, 0, 0, 0, 0, - 0, 0); - xcb_free_pixmap(x11->xcb_conn, pix); - -#ifdef WLR_HAS_XCB_XKB - const xcb_query_extension_reply_t *reply = - xcb_get_extension_data(x11->xcb_conn, &xcb_xkb_id); - if (reply != NULL && reply->present) { - x11->xkb_base_event = reply->first_event; - x11->xkb_base_error = reply->first_error; - - xcb_xkb_use_extension_cookie_t cookie = xcb_xkb_use_extension( - x11->xcb_conn, XCB_XKB_MAJOR_VERSION, XCB_XKB_MINOR_VERSION); - xcb_xkb_use_extension_reply_t *reply = - xcb_xkb_use_extension_reply(x11->xcb_conn, cookie, NULL); - if (reply != NULL && reply->supported) { - x11->xkb_supported = true; - - xcb_xkb_select_events(x11->xcb_conn, - XCB_XKB_ID_USE_CORE_KBD, - XCB_XKB_EVENT_TYPE_STATE_NOTIFY, - 0, - XCB_XKB_EVENT_TYPE_STATE_NOTIFY, - 0, - 0, - 0); - - free(reply); - } - } -#endif - wlr_signal_emit_safe(&x11->backend.events.new_input, &x11->keyboard_dev); for (size_t i = 0; i < x11->requested_outputs; ++i) { @@ -209,9 +140,6 @@ static void backend_destroy(struct wlr_backend *backend) { wlr_renderer_destroy(x11->renderer); wlr_egl_finish(&x11->egl); - if (x11->cursor) { - xcb_free_cursor(x11->xcb_conn, x11->cursor); - } if (x11->xlib_conn) { XCloseDisplay(x11->xlib_conn); } @@ -258,15 +186,82 @@ struct wlr_backend *wlr_x11_backend_create(struct wl_display *display, goto error_x11; } - x11->xcb_conn = XGetXCBConnection(x11->xlib_conn); - if (!x11->xcb_conn || xcb_connection_has_error(x11->xcb_conn)) { + x11->xcb = XGetXCBConnection(x11->xlib_conn); + if (!x11->xcb || xcb_connection_has_error(x11->xcb)) { wlr_log(WLR_ERROR, "Failed to open xcb connection"); goto error_display; } XSetEventQueueOwner(x11->xlib_conn, XCBOwnsEventQueue); - int fd = xcb_get_file_descriptor(x11->xcb_conn); + struct { + const char *name; + xcb_intern_atom_cookie_t cookie; + xcb_atom_t *atom; + } atom[] = { + { .name = "WM_PROTOCOLS", .atom = &x11->atoms.wm_protocols }, + { .name = "WM_DELETE_WINDOW", .atom = &x11->atoms.wm_delete_window }, + { .name = "_NET_WM_NAME", .atom = &x11->atoms.net_wm_name }, + { .name = "UTF8_STRING", .atom = &x11->atoms.utf8_string }, + }; + + for (size_t i = 0; i < sizeof(atom) / sizeof(atom[0]); ++i) { + atom[i].cookie = xcb_intern_atom(x11->xcb, + true, strlen(atom[i].name), atom[i].name); + } + + for (size_t i = 0; i < sizeof(atom) / sizeof(atom[0]); ++i) { + xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply( + x11->xcb, atom[i].cookie, NULL); + + if (reply) { + *atom[i].atom = reply->atom; + free(reply); + } else { + *atom[i].atom = XCB_ATOM_NONE; + } + } + + const xcb_query_extension_reply_t *ext; + + ext = xcb_get_extension_data(x11->xcb, &xcb_xfixes_id); + if (!ext || !ext->present) { + wlr_log(WLR_ERROR, "X11 does not support Xfixes extension"); + goto error_display; + } + + xcb_xfixes_query_version_cookie_t fixes_cookie = + xcb_xfixes_query_version(x11->xcb, 4, 0); + xcb_xfixes_query_version_reply_t *fixes_reply = + xcb_xfixes_query_version_reply(x11->xcb, fixes_cookie, NULL); + + if (!fixes_reply || fixes_reply->major_version < 4) { + wlr_log(WLR_ERROR, "X11 does not support required Xfixes version"); + free(fixes_reply); + goto error_display; + } + free(fixes_reply); + + ext = xcb_get_extension_data(x11->xcb, &xcb_input_id); + if (!ext || !ext->present) { + wlr_log(WLR_ERROR, "X11 does not support Xinput extension"); + goto error_display; + } + x11->xinput_opcode = ext->major_opcode; + + xcb_input_xi_query_version_cookie_t xi_cookie = + xcb_input_xi_query_version(x11->xcb, 2, 0); + xcb_input_xi_query_version_reply_t *xi_reply = + xcb_input_xi_query_version_reply(x11->xcb, xi_cookie, NULL); + + if (!xi_reply || xi_reply->major_version < 2) { + wlr_log(WLR_ERROR, "X11 does not support required Xinput version"); + free(xi_reply); + goto error_display; + } + free(xi_reply); + + int fd = xcb_get_file_descriptor(x11->xcb); struct wl_event_loop *ev = wl_display_get_event_loop(display); uint32_t events = WL_EVENT_READABLE | WL_EVENT_ERROR | WL_EVENT_HANGUP; x11->event_source = wl_event_loop_add_fd(ev, fd, events, x11_event, x11); @@ -276,7 +271,7 @@ struct wlr_backend *wlr_x11_backend_create(struct wl_display *display, } wl_event_source_check(x11->event_source); - x11->screen = xcb_setup_roots_iterator(xcb_get_setup(x11->xcb_conn)).data; + x11->screen = xcb_setup_roots_iterator(xcb_get_setup(x11->xcb)).data; if (!create_renderer_func) { create_renderer_func = wlr_renderer_autocreate; diff --git a/backend/x11/input_device.c b/backend/x11/input_device.c index a16da1c9..a50f478a 100644 --- a/backend/x11/input_device.c +++ b/backend/x11/input_device.c @@ -1,140 +1,201 @@ #include <stdlib.h> + #include <wlr/config.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 <xcb/xcb.h> + #ifdef __linux__ #include <linux/input-event-codes.h> #elif __FreeBSD__ #include <dev/evdev/input-event-codes.h> #endif -#ifdef WLR_HAS_XCB_XKB -#include <xcb/xkb.h> -#endif + +#include <xcb/xcb.h> +#include <xcb/xfixes.h> +#include <xcb/xinput.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" #include "util/signal.h" -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 void send_key_event(struct wlr_x11_backend *x11, uint32_t key, + enum wlr_key_state st, xcb_timestamp_t time) { + struct wlr_event_keyboard_key ev = { + .time_msec = time, + .keycode = key, + .state = st, + .update_state = true, + }; + wlr_keyboard_notify_key(&x11->keyboard, &ev); } -static void x11_handle_pointer_position(struct wlr_x11_output *output, - int16_t x, int16_t y, xcb_timestamp_t time) { - struct wlr_x11_backend *x11 = output->x11; - struct wlr_output *wlr_output = &output->wlr_output; - struct wlr_event_pointer_motion_absolute event = { +static void send_button_event(struct wlr_x11_output *output, uint32_t key, + enum wlr_button_state st, xcb_timestamp_t time) { + struct wlr_event_pointer_button ev = { + .device = &output->pointer_dev, + .time_msec = time, + .button = key, + .state = st, + }; + wlr_signal_emit_safe(&output->pointer.events.button, &ev); +} + +static void send_axis_event(struct wlr_x11_output *output, int32_t delta, + xcb_timestamp_t time) { + struct wlr_event_pointer_axis ev = { .device = &output->pointer_dev, .time_msec = time, - .x = (double)x / wlr_output->width, - .y = (double)y / wlr_output->height, + .source = WLR_AXIS_SOURCE_WHEEL, + .orientation = WLR_AXIS_ORIENTATION_VERTICAL, + // 15 is a typical value libinput sends for one scroll + .delta = delta * 15, + .delta_discrete = delta, }; - wlr_signal_emit_safe(&output->pointer.events.motion_absolute, &event); + wlr_signal_emit_safe(&output->pointer.events.axis, &ev); +} - x11->time = time; +static void send_pointer_position_event(struct wlr_x11_output *output, + int16_t x, int16_t y, xcb_timestamp_t time) { + struct wlr_event_pointer_motion_absolute ev = { + .device = &output->pointer_dev, + .time_msec = time, + .x = (double)x / output->wlr_output.width, + .y = (double)y / output->wlr_output.height, + }; + wlr_signal_emit_safe(&output->pointer.events.motion_absolute, &ev); } -void handle_x11_input_event(struct wlr_x11_backend *x11, - xcb_generic_event_t *event) { - switch (event->response_type & XCB_EVENT_RESPONSE_TYPE_MASK) { - 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 = { - .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); +void handle_x11_xinput_event(struct wlr_x11_backend *x11, + xcb_ge_generic_event_t *event) { + struct wlr_x11_output *output; + + switch (event->event_type) { + case XCB_INPUT_KEY_PRESS: { + xcb_input_key_press_event_t *ev = + (xcb_input_key_press_event_t *)event; + + wlr_keyboard_notify_modifiers(&x11->keyboard, ev->mods.base, + ev->mods.latched, ev->mods.locked, ev->mods.effective); + send_key_event(x11, ev->detail - 8, WLR_KEY_PRESSED, ev->time); x11->time = ev->time; - return; + break; } - case XCB_BUTTON_PRESS: { - xcb_button_press_event_t *ev = (xcb_button_press_event_t *)event; + case XCB_INPUT_KEY_RELEASE: { + xcb_input_key_release_event_t *ev = + (xcb_input_key_release_event_t *)event; - struct wlr_x11_output *output = - get_x11_output_from_window_id(x11, ev->event); - if (output == NULL) { - break; + wlr_keyboard_notify_modifiers(&x11->keyboard, ev->mods.base, + ev->mods.latched, ev->mods.locked, ev->mods.effective); + send_key_event(x11, ev->detail - 8, WLR_KEY_RELEASED, ev->time); + x11->time = ev->time; + break; + } + case XCB_INPUT_BUTTON_PRESS: { + xcb_input_button_press_event_t *ev = + (xcb_input_button_press_event_t *)event; + + output = get_x11_output_from_window_id(x11, ev->event); + if (!output) { + return; } - if (ev->detail == XCB_BUTTON_INDEX_4 || - ev->detail == XCB_BUTTON_INDEX_5) { - int32_t delta_discrete = ev->detail == XCB_BUTTON_INDEX_4 ? -1 : 1; - struct wlr_event_pointer_axis axis = { - .device = &output->pointer_dev, - .time_msec = ev->time, - .source = WLR_AXIS_SOURCE_WHEEL, - .orientation = WLR_AXIS_ORIENTATION_VERTICAL, - // 15 is a typical value libinput sends for one scroll - .delta = delta_discrete * 15, - .delta_discrete = delta_discrete, - }; - wlr_signal_emit_safe(&output->pointer.events.axis, &axis); - x11->time = ev->time; + switch (ev->detail) { + case XCB_BUTTON_INDEX_1: + send_button_event(output, BTN_LEFT, WLR_BUTTON_PRESSED, + ev->time); + break; + case XCB_BUTTON_INDEX_2: + send_button_event(output, BTN_MIDDLE, WLR_BUTTON_PRESSED, + ev->time); + break; + case XCB_BUTTON_INDEX_3: + send_button_event(output, BTN_RIGHT, WLR_BUTTON_PRESSED, + ev->time); + break; + case XCB_BUTTON_INDEX_4: + send_axis_event(output, -1, ev->time); + break; + case XCB_BUTTON_INDEX_5: + send_axis_event(output, 1, ev->time); break; } + + x11->time = ev->time; + break; } - /* fallthrough */ - case XCB_BUTTON_RELEASE: { - xcb_button_press_event_t *ev = (xcb_button_press_event_t *)event; + case XCB_INPUT_BUTTON_RELEASE: { + xcb_input_button_release_event_t *ev = + (xcb_input_button_release_event_t *)event; - struct wlr_x11_output *output = - get_x11_output_from_window_id(x11, ev->event); - if (output == NULL) { + output = get_x11_output_from_window_id(x11, ev->event); + if (!output) { + return; + } + + switch (ev->detail) { + case XCB_BUTTON_INDEX_1: + send_button_event(output, BTN_LEFT, WLR_BUTTON_RELEASED, + ev->time); + break; + case XCB_BUTTON_INDEX_2: + send_button_event(output, BTN_MIDDLE, WLR_BUTTON_RELEASED, + ev->time); + break; + case XCB_BUTTON_INDEX_3: + send_button_event(output, BTN_RIGHT, WLR_BUTTON_RELEASED, + ev->time); break; } - if (ev->detail != XCB_BUTTON_INDEX_4 && - ev->detail != XCB_BUTTON_INDEX_5) { - struct wlr_event_pointer_button button = { - .device = &output->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, - }; - - wlr_signal_emit_safe(&output->pointer.events.button, &button); + x11->time = ev->time; + break; + } + case XCB_INPUT_MOTION: { + xcb_input_motion_event_t *ev = (xcb_input_motion_event_t *)event; + + output = get_x11_output_from_window_id(x11, ev->event); + if (!output) { + return; } + + send_pointer_position_event(output, ev->event_x >> 16, + ev->event_y >> 16, ev->time); x11->time = ev->time; - return; + break; } - case XCB_MOTION_NOTIFY: { - xcb_motion_notify_event_t *ev = (xcb_motion_notify_event_t *)event; + case XCB_INPUT_ENTER: { + xcb_input_enter_event_t *ev = (xcb_input_enter_event_t *)event; + + output = get_x11_output_from_window_id(x11, ev->event); + if (!output) { + return; + } - struct wlr_x11_output *output = - get_x11_output_from_window_id(x11, ev->event); - if (output != NULL) { - x11_handle_pointer_position(output, ev->event_x, ev->event_y, ev->time); + if (!output->cursor_hidden) { + xcb_xfixes_hide_cursor(x11->xcb, output->win); + xcb_flush(x11->xcb); + output->cursor_hidden = true; } - return; + break; } - default: -#ifdef WLR_HAS_XCB_XKB - if (x11->xkb_supported && event->response_type == x11->xkb_base_event) { - xcb_xkb_state_notify_event_t *ev = - (xcb_xkb_state_notify_event_t *)event; - wlr_keyboard_notify_modifiers(&x11->keyboard, ev->baseMods, - ev->latchedMods, ev->lockedMods, ev->lockedGroup); + case XCB_INPUT_LEAVE: { + xcb_input_leave_event_t *ev = (xcb_input_leave_event_t *)event; + + output = get_x11_output_from_window_id(x11, ev->event); + if (!output) { return; } -#endif + + if (output->cursor_hidden) { + xcb_xfixes_show_cursor(x11->xcb, output->win); + xcb_flush(x11->xcb); + output->cursor_hidden = false; + } break; } + } } static void input_device_destroy(struct wlr_input_device *wlr_device) { @@ -166,14 +227,14 @@ void update_x11_pointer_position(struct wlr_x11_output *output, struct wlr_x11_backend *x11 = output->x11; xcb_query_pointer_cookie_t cookie = - xcb_query_pointer(x11->xcb_conn, output->win); + xcb_query_pointer(x11->xcb, output->win); xcb_query_pointer_reply_t *reply = - xcb_query_pointer_reply(x11->xcb_conn, cookie, NULL); + xcb_query_pointer_reply(x11->xcb, cookie, NULL); if (!reply) { return; } - x11_handle_pointer_position(output, reply->win_x, reply->win_y, time); + send_pointer_position_event(output, reply->win_x, reply->win_y, time); free(reply); } diff --git a/backend/x11/meson.build b/backend/x11/meson.build index 1164df1e..19e873ab 100644 --- a/backend/x11/meson.build +++ b/backend/x11/meson.build @@ -1,10 +1,9 @@ x11_libs = [] x11_required = [ - 'xcb', 'x11-xcb', -] -x11_optional = [ - 'xcb-xkb', + 'xcb', + 'xcb-xinput', + 'xcb-xfixes', ] foreach lib : x11_required @@ -16,14 +15,6 @@ foreach lib : x11_required x11_libs += dep endforeach -foreach lib : x11_optional - dep = dependency(lib, required: get_option(lib)) - if dep.found() - x11_libs += dep - conf_data.set('WLR_HAS_' + lib.underscorify().to_upper(), true) - endif -endforeach - lib_wlr_backend_x11 = static_library( 'wlr_backend_x11', files( @@ -41,4 +32,4 @@ lib_wlr_backend_x11 = static_library( ) backend_parts += lib_wlr_backend_x11 -conf_data.set('WLR_HAS_X11_BACKEND', true) +conf_data.set10('WLR_HAS_X11_BACKEND', true) diff --git a/backend/x11/output.c b/backend/x11/output.c index 1ac12a8d..6f98c590 100644 --- a/backend/x11/output.c +++ b/backend/x11/output.c @@ -1,10 +1,16 @@ #define _POSIX_C_SOURCE 200809L + #include <assert.h> #include <stdlib.h> #include <string.h> + +#include <xcb/xcb.h> +#include <xcb/xinput.h> + #include <wlr/interfaces/wlr_output.h> #include <wlr/interfaces/wlr_pointer.h> #include <wlr/util/log.h> + #include "backend/x11.h" #include "util/signal.h" @@ -16,8 +22,8 @@ static int signal_frame(void *data) { } static void parse_xcb_setup(struct wlr_output *output, - xcb_connection_t *xcb_conn) { - const xcb_setup_t *xcb_setup = xcb_get_setup(xcb_conn); + xcb_connection_t *xcb) { + const xcb_setup_t *xcb_setup = xcb_get_setup(xcb); snprintf(output->make, sizeof(output->make), "%.*s", xcb_setup_vendor_length(xcb_setup), @@ -55,11 +61,11 @@ static bool output_set_custom_mode(struct wlr_output *wlr_output, const uint32_t values[] = { width, height }; xcb_void_cookie_t cookie = xcb_configure_window_checked( - x11->xcb_conn, output->win, + x11->xcb, output->win, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values); xcb_generic_error_t *error; - if ((error = xcb_request_check(x11->xcb_conn, cookie))) { + if ((error = xcb_request_check(x11->xcb, cookie))) { wlr_log(WLR_ERROR, "Could not set window size to %dx%d\n", width, height); free(error); @@ -84,8 +90,8 @@ static void output_destroy(struct wlr_output *wlr_output) { wl_list_remove(&output->link); wl_event_source_remove(output->frame_timer); wlr_egl_destroy_surface(&x11->egl, output->surf); - xcb_destroy_window(x11->xcb_conn, output->win); - xcb_flush(x11->xcb_conn); + xcb_destroy_window(x11->xcb, output->win); + xcb_flush(x11->xcb); free(output); } @@ -142,21 +148,32 @@ struct wlr_output *wlr_x11_output_create(struct wlr_backend *backend) { snprintf(wlr_output->name, sizeof(wlr_output->name), "X11-%d", wl_list_length(&x11->outputs) + 1); - parse_xcb_setup(wlr_output, x11->xcb_conn); + parse_xcb_setup(wlr_output, x11->xcb); uint32_t mask = XCB_CW_EVENT_MASK; uint32_t values[] = { - 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 + XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY }; - output->win = xcb_generate_id(x11->xcb_conn); - xcb_create_window(x11->xcb_conn, XCB_COPY_FROM_PARENT, output->win, + output->win = xcb_generate_id(x11->xcb); + xcb_create_window(x11->xcb, XCB_COPY_FROM_PARENT, output->win, x11->screen->root, 0, 0, wlr_output->width, wlr_output->height, 1, XCB_WINDOW_CLASS_INPUT_OUTPUT, x11->screen->root_visual, mask, values); + struct { + xcb_input_event_mask_t head; + xcb_input_xi_event_mask_t mask; + } xinput_mask = { + .head = { .deviceid = XCB_INPUT_DEVICE_ALL_MASTER, .mask_len = 1 }, + .mask = XCB_INPUT_XI_EVENT_MASK_KEY_PRESS | + XCB_INPUT_XI_EVENT_MASK_KEY_RELEASE | + XCB_INPUT_XI_EVENT_MASK_BUTTON_PRESS | + XCB_INPUT_XI_EVENT_MASK_BUTTON_RELEASE | + XCB_INPUT_XI_EVENT_MASK_MOTION | + XCB_INPUT_XI_EVENT_MASK_ENTER | + XCB_INPUT_XI_EVENT_MASK_LEAVE, + }; + xcb_input_xi_select_events(x11->xcb, output->win, 1, &xinput_mask.head); + output->surf = wlr_egl_create_surface(&x11->egl, &output->win); if (!output->surf) { wlr_log(WLR_ERROR, "Failed to create EGL surface"); @@ -164,23 +181,19 @@ struct wlr_output *wlr_x11_output_create(struct wlr_backend *backend) { return NULL; } - xcb_change_property(x11->xcb_conn, XCB_PROP_MODE_REPLACE, output->win, + xcb_change_property(x11->xcb, XCB_PROP_MODE_REPLACE, output->win, x11->atoms.wm_protocols, XCB_ATOM_ATOM, 32, 1, &x11->atoms.wm_delete_window); char title[32]; if (snprintf(title, sizeof(title), "wlroots - %s", wlr_output->name)) { - xcb_change_property(x11->xcb_conn, XCB_PROP_MODE_REPLACE, output->win, + xcb_change_property(x11->xcb, XCB_PROP_MODE_REPLACE, output->win, x11->atoms.net_wm_name, x11->atoms.utf8_string, 8, strlen(title), title); } - uint32_t cursor_values[] = { x11->cursor }; - xcb_change_window_attributes(x11->xcb_conn, output->win, XCB_CW_CURSOR, - cursor_values); - - xcb_map_window(x11->xcb_conn, output->win); - xcb_flush(x11->xcb_conn); + xcb_map_window(x11->xcb, output->win); + xcb_flush(x11->xcb); struct wl_event_loop *ev = wl_display_get_event_loop(x11->wl_display); output->frame_timer = wl_event_loop_add_timer(ev, signal_frame, output); diff --git a/include/backend/wayland.h b/include/backend/wayland.h index 47585d9e..dbc309ca 100644 --- a/include/backend/wayland.h +++ b/include/backend/wayland.h @@ -2,10 +2,12 @@ #define BACKEND_WAYLAND_H #include <stdbool.h> + #include <wayland-client.h> #include <wayland-egl.h> #include <wayland-server.h> #include <wayland-util.h> + #include <wlr/backend/wayland.h> #include <wlr/render/egl.h> #include <wlr/render/wlr_renderer.h> @@ -32,6 +34,7 @@ struct wlr_wl_backend { struct wl_shm *shm; struct wl_seat *seat; struct wl_pointer *pointer; + struct wl_keyboard *keyboard; struct wlr_wl_pointer *current_pointer; char *seat_name; }; @@ -78,13 +81,11 @@ struct wlr_wl_pointer { struct wl_listener output_destroy; }; -struct wlr_wl_backend *get_wl_backend_from_backend( - struct wlr_backend *wlr_backend); -void poll_wl_registry(struct wlr_wl_backend *backend); +struct wlr_wl_backend *get_wl_backend_from_backend(struct wlr_backend *backend); void update_wl_output_cursor(struct wlr_wl_output *output); struct wlr_wl_pointer *pointer_get_wl(struct wlr_pointer *wlr_pointer); -void create_wl_pointer(struct wl_pointer *wl_pointer, - struct wlr_wl_output *output); +void create_wl_pointer(struct wl_pointer *wl_pointer, struct wlr_wl_output *output); +void create_wl_keyboard(struct wl_keyboard *wl_keyboard, struct wlr_wl_backend *wl); extern const struct wl_seat_listener seat_listener; diff --git a/include/backend/x11.h b/include/backend/x11.h index 37e3e4b6..1a8341f6 100644 --- a/include/backend/x11.h +++ b/include/backend/x11.h @@ -2,14 +2,17 @@ #define BACKEND_X11_H #include <stdbool.h> + +#include <X11/Xlib-xcb.h> #include <wayland-server.h> -#include <wlr/config.h> +#include <xcb/xcb.h> + #include <wlr/backend/x11.h> +#include <wlr/config.h> #include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_output.h> #include <wlr/render/egl.h> -#include <X11/Xlib-xcb.h> -#include <xcb/xcb.h> +#include <wlr/render/wlr_renderer.h> #define XCB_EVENT_RESPONSE_TYPE_MASK 0x7f @@ -30,6 +33,8 @@ struct wlr_x11_output { struct wl_event_source *frame_timer; int frame_delay; + + bool cursor_hidden; }; struct wlr_x11_backend { @@ -38,7 +43,7 @@ struct wlr_x11_backend { bool started; Display *xlib_conn; - xcb_connection_t *xcb_conn; + xcb_connection_t *xcb; xcb_screen_t *screen; size_t requested_outputs; @@ -61,14 +66,7 @@ struct wlr_x11_backend { // The time we last received an event xcb_timestamp_t time; - // A blank cursor - xcb_cursor_t cursor; - -#ifdef WLR_HAS_XCB_XKB - bool xkb_supported; - uint8_t xkb_base_event; - uint8_t xkb_base_error; -#endif + uint8_t xinput_opcode; struct wl_listener display_destroy; }; @@ -82,8 +80,8 @@ extern const struct wlr_keyboard_impl keyboard_impl; extern const struct wlr_pointer_impl pointer_impl; extern const struct wlr_input_device_impl input_device_impl; -void handle_x11_input_event(struct wlr_x11_backend *x11, - xcb_generic_event_t *event); +void handle_x11_xinput_event(struct wlr_x11_backend *x11, + xcb_ge_generic_event_t *event); void update_x11_pointer_position(struct wlr_x11_output *output, xcb_timestamp_t time); diff --git a/include/rootston/desktop.h b/include/rootston/desktop.h index 345c9c09..4ce92e2b 100644 --- a/include/rootston/desktop.h +++ b/include/rootston/desktop.h @@ -76,7 +76,7 @@ struct roots_desktop { struct wl_listener virtual_keyboard_new; struct wl_listener pointer_constraint; -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND struct wlr_xwayland *xwayland; struct wl_listener xwayland_surface; #endif diff --git a/include/rootston/server.h b/include/rootston/server.h index 7ab15682..1836a374 100644 --- a/include/rootston/server.h +++ b/include/rootston/server.h @@ -7,7 +7,7 @@ #include <wlr/config.h> #include <wlr/render/wlr_renderer.h> #include <wlr/types/wlr_data_device.h> -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND #include <wlr/xwayland.h> #endif #include "rootston/config.h" diff --git a/include/rootston/view.h b/include/rootston/view.h index 14448fc6..0c75737b 100644 --- a/include/rootston/view.h +++ b/include/rootston/view.h @@ -79,7 +79,7 @@ enum roots_view_type { ROOTS_WL_SHELL_VIEW, ROOTS_XDG_SHELL_V6_VIEW, ROOTS_XDG_SHELL_VIEW, -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND ROOTS_XWAYLAND_VIEW, #endif }; @@ -117,7 +117,7 @@ struct roots_view { struct wlr_wl_shell_surface *wl_shell_surface; struct wlr_xdg_surface_v6 *xdg_surface_v6; struct wlr_xdg_surface *xdg_surface; -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND struct wlr_xwayland_surface *xwayland_surface; #endif }; @@ -125,7 +125,7 @@ struct roots_view { struct roots_wl_shell_surface *roots_wl_shell_surface; struct roots_xdg_surface_v6 *roots_xdg_surface_v6; struct roots_xdg_surface *roots_xdg_surface; -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND struct roots_xwayland_surface *roots_xwayland_surface; #endif }; diff --git a/include/wlr/backend/meson.build b/include/wlr/backend/meson.build index e005b854..3d6f0e40 100644 --- a/include/wlr/backend/meson.build +++ b/include/wlr/backend/meson.build @@ -9,7 +9,7 @@ install_headers( subdir: 'wlr/backend', ) -if conf_data.get('WLR_HAS_X11_BACKEND', false) +if conf_data.get('WLR_HAS_X11_BACKEND', 0) == 1 install_headers('x11.h', subdir: 'wlr/backend') endif diff --git a/include/wlr/backend/x11.h b/include/wlr/backend/x11.h index 56360bf7..5793a3b9 100644 --- a/include/wlr/backend/x11.h +++ b/include/wlr/backend/x11.h @@ -2,7 +2,9 @@ #define WLR_BACKEND_X11_H #include <stdbool.h> + #include <wayland-server.h> + #include <wlr/backend.h> #include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_output.h> diff --git a/include/wlr/config.h.in b/include/wlr/config.h.in index 17277c07..94273fac 100644 --- a/include/wlr/config.h.in +++ b/include/wlr/config.h.in @@ -12,6 +12,5 @@ #mesondefine WLR_HAS_XCB_ERRORS #mesondefine WLR_HAS_XCB_ICCCM -#mesondefine WLR_HAS_XCB_XKB #endif diff --git a/include/wlr/meson.build b/include/wlr/meson.build index 43b5aec9..8874dbc7 100644 --- a/include/wlr/meson.build +++ b/include/wlr/meson.build @@ -15,7 +15,7 @@ install_headers( 'xcursor.h', subdir: 'wlr' ) -if conf_data.get('WLR_HAS_XWAYLAND', false) +if conf_data.get('WLR_HAS_XWAYLAND', 0) == 1 install_headers('xwayland.h', subdir: 'wlr') endif diff --git a/include/wlr/render/egl.h b/include/wlr/render/egl.h index 9ba2996a..fedb6fdd 100644 --- a/include/wlr/render/egl.h +++ b/include/wlr/render/egl.h @@ -11,7 +11,7 @@ #include <wlr/config.h> -#if !(defined(WLR_HAS_X11_BACKEND) || defined(WLR_HAS_WAYLAND)) +#if !WLR_HAS_X11_BACKEND && !WLR_HAS_XWAYLAND #define MESA_EGL_NO_X11_HEADERS #endif diff --git a/include/wlr/render/interface.h b/include/wlr/render/interface.h index 9500bced..a7f97a89 100644 --- a/include/wlr/render/interface.h +++ b/include/wlr/render/interface.h @@ -11,7 +11,7 @@ #include <wlr/config.h> -#if !(defined(WLR_HAS_X11_BACKEND) || defined(WLR_HAS_WAYLAND)) +#if !WLR_HAS_X11_BACKEND && !WLR_HAS_XWAYLAND #define MESA_EGL_NO_X11_HEADERS #endif diff --git a/include/wlr/render/wlr_renderer.h b/include/wlr/render/wlr_renderer.h index 02b4a11e..9c031b7f 100644 --- a/include/wlr/render/wlr_renderer.h +++ b/include/wlr/render/wlr_renderer.h @@ -97,11 +97,6 @@ int wlr_renderer_get_dmabuf_formats(struct wlr_renderer *renderer, int wlr_renderer_get_dmabuf_modifiers(struct wlr_renderer *renderer, int format, uint64_t **modifiers); /** - * Get the preferred format for reading pixels. - */ -bool wlr_renderer_preferred_read_format(struct wlr_renderer *renderer, - enum wl_shm_format *fmt); -/** * Reads out of pixels of the currently bound surface into data. `stride` is in * bytes. * diff --git a/include/wlr/types/wlr_output.h b/include/wlr/types/wlr_output.h index 9ccfbbb5..6d38152a 100644 --- a/include/wlr/types/wlr_output.h +++ b/include/wlr/types/wlr_output.h @@ -106,11 +106,6 @@ struct wlr_output { struct wl_event_source *idle_frame; - struct wlr_surface *fullscreen_surface; - struct wl_listener fullscreen_surface_commit; - struct wl_listener fullscreen_surface_destroy; - int fullscreen_width, fullscreen_height; - struct wl_list cursors; // wlr_output_cursor::link struct wlr_output_cursor *hardware_cursor; int software_cursor_locks; // number of locks forcing software cursors @@ -198,6 +193,12 @@ void wlr_output_effective_resolution(struct wlr_output *output, */ bool wlr_output_make_current(struct wlr_output *output, int *buffer_age); /** + * Get the preferred format for reading pixels. + * This function might change the current rendering context. + */ +bool wlr_output_preferred_read_format(struct wlr_output *output, + enum wl_shm_format *fmt); +/** * Swaps the output buffers. If the time of the frame isn't known, set `when` to * NULL. If the compositor doesn't support damage tracking, set `damage` to * NULL. @@ -226,8 +227,6 @@ bool wlr_output_set_gamma(struct wlr_output *output, size_t size, const uint16_t *r, const uint16_t *g, const uint16_t *b); bool wlr_output_export_dmabuf(struct wlr_output *output, struct wlr_dmabuf_attributes *attribs); -void wlr_output_set_fullscreen_surface(struct wlr_output *output, - struct wlr_surface *surface); struct wlr_output *wlr_output_from_resource(struct wl_resource *resource); /** * Locks the output to only use software cursors instead of hardware cursors. @@ -237,6 +236,12 @@ struct wlr_output *wlr_output_from_resource(struct wl_resource *resource); * a lock. */ void wlr_output_lock_software_cursors(struct wlr_output *output, bool lock); +/** + * Renders software cursors. This is a utility function that can be called when + * compositors render. + */ +void wlr_output_render_software_cursors(struct wlr_output *output, + pixman_region32_t *damage); struct wlr_output_cursor *wlr_output_cursor_create(struct wlr_output *output); diff --git a/include/wlr/types/wlr_primary_selection.h b/include/wlr/types/wlr_primary_selection.h index f33f6368..192bfc02 100644 --- a/include/wlr/types/wlr_primary_selection.h +++ b/include/wlr/types/wlr_primary_selection.h @@ -14,6 +14,7 @@ struct wlr_primary_selection_device_manager { struct wl_global *global; + struct wl_list resources; struct wl_listener display_destroy; @@ -24,8 +25,6 @@ struct wlr_primary_selection_device_manager { void *data; }; -struct wlr_primary_selection_offer; - struct wlr_primary_selection_source { // source metadata struct wl_array mime_types; @@ -36,7 +35,6 @@ struct wlr_primary_selection_source { void (*cancel)(struct wlr_primary_selection_source *source); // source status - struct wlr_primary_selection_offer *offer; struct wlr_seat_client *seat_client; struct { diff --git a/include/xwayland/xwm.h b/include/xwayland/xwm.h index dc40cc3e..c1be572b 100644 --- a/include/xwayland/xwm.h +++ b/include/xwayland/xwm.h @@ -5,10 +5,10 @@ #include <wlr/config.h> #include <wlr/xwayland.h> #include <xcb/render.h> -#ifdef WLR_HAS_XCB_ICCCM +#if WLR_HAS_XCB_ICCCM #include <xcb/xcb_icccm.h> #endif -#ifdef WLR_HAS_XCB_ERRORS +#if WLR_HAS_XCB_ERRORS #include <xcb/xcb_errors.h> #endif #include "xwayland/selection.h" @@ -122,7 +122,7 @@ struct wlr_xwm { struct wlr_xwayland_surface *drag_focus; const xcb_query_extension_reply_t *xfixes; -#ifdef WLR_HAS_XCB_ERRORS +#if WLR_HAS_XCB_ERRORS xcb_errors_context_t *errors_context; #endif diff --git a/meson.build b/meson.build index 1ed93c04..3d96d052 100644 --- a/meson.build +++ b/meson.build @@ -16,17 +16,25 @@ project( # for a reference about clean library versioning. so_version = ['0', '0', '0'] -add_project_arguments('-Wno-unused-parameter', language: 'c') add_project_arguments( - '-DWLR_SRC_DIR="@0@"'.format(meson.current_source_dir()), - language: 'c', -) -add_project_arguments( - '-DWLR_USE_UNSTABLE', + [ + '-DWLR_SRC_DIR="@0@"'.format(meson.current_source_dir()), + '-DWLR_USE_UNSTABLE', + + '-Wno-unused-parameter', + '-Wundef', + ], language: 'c', ) conf_data = configuration_data() +conf_data.set10('WLR_HAS_LIBCAP', false) +conf_data.set10('WLR_HAS_SYSTEMD', false) +conf_data.set10('WLR_HAS_ELOGIND', false) +conf_data.set10('WLR_HAS_X11_BACKEND', false) +conf_data.set10('WLR_HAS_XWAYLAND', false) +conf_data.set10('WLR_HAS_XCB_ERRORS', false) +conf_data.set10('WLR_HAS_XCB_ICCCM', false) wlr_inc = include_directories('.', 'include') @@ -63,12 +71,12 @@ wlr_parts = [] wlr_deps = [] if libcap.found() - conf_data.set('WLR_HAS_LIBCAP', true) + conf_data.set10('WLR_HAS_LIBCAP', true) wlr_deps += libcap endif if logind.found() - conf_data.set('WLR_HAS_' + get_option('logind-provider').to_upper(), true) + conf_data.set10('WLR_HAS_' + get_option('logind-provider').to_upper(), true) wlr_deps += logind endif diff --git a/meson_options.txt b/meson_options.txt index 360c6f6a..19a6cad7 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -3,7 +3,6 @@ option('logind', type: 'feature', value: 'auto', description: 'Enable support fo option('logind-provider', type: 'combo', choices: ['systemd', 'elogind'], value: 'systemd', description: 'Provider of logind support library') option('xcb-errors', type: 'feature', value: 'auto', description: 'Use xcb-errors util library') option('xcb-icccm', type: 'feature', value: 'auto', description: 'Use xcb-icccm util library') -option('xcb-xkb', type: 'feature', value: 'auto', description: 'Use xcb-xkb util library') option('xwayland', type: 'feature', value: 'auto', description: 'Enable support for X11 applications') option('x11-backend', type: 'feature', value: 'auto', description: 'Enable X11 backend') option('rootston', type: 'boolean', value: true, description: 'Build the rootston example compositor') diff --git a/render/egl.c b/render/egl.c index 644f94ac..cc00dece 100644 --- a/render/egl.c +++ b/render/egl.c @@ -1,11 +1,12 @@ #include <assert.h> -#include <stdio.h> +#include <drm_fourcc.h> #include <EGL/egl.h> #include <EGL/eglext.h> +#include <stdio.h> #include <stdlib.h> -#include <drm_fourcc.h> #include <wlr/render/egl.h> #include <wlr/util/log.h> +#include <wlr/util/region.h> #include "glapi.h" static bool egl_get_config(EGLDisplay disp, EGLint *attribs, EGLConfig *out, @@ -329,9 +330,18 @@ bool wlr_egl_swap_buffers(struct wlr_egl *egl, EGLSurface surface, EGLBoolean ret; if (damage != NULL && (egl->exts.swap_buffers_with_damage_ext || egl->exts.swap_buffers_with_damage_khr)) { + EGLint width = 0, height = 0; + eglQuerySurface(egl->display, surface, EGL_WIDTH, &width); + eglQuerySurface(egl->display, surface, EGL_HEIGHT, &height); + + pixman_region32_t flipped_damage; + pixman_region32_init(&flipped_damage); + wlr_region_transform(&flipped_damage, damage, + WL_OUTPUT_TRANSFORM_FLIPPED_180, width, height); + int nrects; pixman_box32_t *rects = - pixman_region32_rectangles(damage, &nrects); + pixman_region32_rectangles(&flipped_damage, &nrects); EGLint egl_damage[4 * nrects]; for (int i = 0; i < nrects; ++i) { egl_damage[4*i] = rects[i].x1; @@ -340,6 +350,8 @@ bool wlr_egl_swap_buffers(struct wlr_egl *egl, EGLSurface surface, egl_damage[4*i + 3] = rects[i].y2 - rects[i].y1; } + pixman_region32_fini(&flipped_damage); + if (egl->exts.swap_buffers_with_damage_ext) { ret = eglSwapBuffersWithDamageEXT(egl->display, surface, egl_damage, nrects); diff --git a/render/wlr_renderer.c b/render/wlr_renderer.c index ca1a337d..58731d7f 100644 --- a/render/wlr_renderer.c +++ b/render/wlr_renderer.c @@ -139,15 +139,6 @@ int wlr_renderer_get_dmabuf_modifiers(struct wlr_renderer *r, int format, return r->impl->get_dmabuf_modifiers(r, format, modifiers); } -bool wlr_renderer_preferred_read_format(struct wlr_renderer *r, - enum wl_shm_format *fmt) { - if (!r->impl->preferred_read_format || !r->impl->read_pixels) { - return false; - } - *fmt = r->impl->preferred_read_format(r); - return true; -} - bool wlr_renderer_read_pixels(struct wlr_renderer *r, enum wl_shm_format fmt, uint32_t *flags, uint32_t stride, uint32_t width, uint32_t height, uint32_t src_x, uint32_t src_y, uint32_t dst_x, uint32_t dst_y, diff --git a/rootston/desktop.c b/rootston/desktop.c index 7da64ef8..e49d61a1 100644 --- a/rootston/desktop.c +++ b/rootston/desktop.c @@ -619,7 +619,7 @@ static bool view_at(struct roots_view *view, double lx, double ly, _surface = wlr_wl_shell_surface_surface_at(view->wl_shell_surface, view_sx, view_sy, &_sx, &_sy); break; -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND case ROOTS_XWAYLAND_VIEW: _surface = wlr_surface_surface_at(view->wlr_surface, view_sx, view_sy, &_sx, &_sy); @@ -890,14 +890,14 @@ struct roots_desktop *desktop_create(struct roots_server *server, desktop->tablet_v2 = wlr_tablet_v2_create(server->wl_display); const char *cursor_theme = NULL; -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND const char *cursor_default = ROOTS_XCURSOR_DEFAULT; #endif struct roots_cursor_config *cc = roots_config_get_cursor(config, ROOTS_CONFIG_DEFAULT_SEAT_NAME); if (cc != NULL) { cursor_theme = cc->theme; -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND if (cc->default_image != NULL) { cursor_default = cc->default_image; } @@ -912,7 +912,7 @@ struct roots_desktop *desktop_create(struct roots_server *server, setenv("XCURSOR_THEME", cursor_theme, 1); } -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND desktop->xcursor_manager = wlr_xcursor_manager_create(cursor_theme, ROOTS_XCURSOR_SIZE); if (desktop->xcursor_manager == NULL) { diff --git a/rootston/input.c b/rootston/input.c index b7a5f1ba..7b4001b3 100644 --- a/rootston/input.c +++ b/rootston/input.c @@ -8,7 +8,7 @@ #include <wlr/types/wlr_cursor.h> #include <wlr/util/log.h> #include <wlr/xcursor.h> -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND #include <wlr/xwayland.h> #endif #include "rootston/config.h" diff --git a/rootston/main.c b/rootston/main.c index cc3ffd3e..7e25dab1 100644 --- a/rootston/main.c +++ b/rootston/main.c @@ -53,7 +53,7 @@ int main(int argc, char **argv) { } setenv("WAYLAND_DISPLAY", socket, true); -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND if (server.desktop->xwayland != NULL) { struct roots_seat *xwayland_seat = input_get_seat(server.input, ROOTS_CONFIG_DEFAULT_SEAT_NAME); @@ -72,7 +72,7 @@ int main(int argc, char **argv) { } wl_display_run(server.wl_display); -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND wlr_xwayland_destroy(server.desktop->xwayland); #endif wl_display_destroy_clients(server.wl_display); diff --git a/rootston/meson.build b/rootston/meson.build index d650dc51..d41e00b0 100644 --- a/rootston/meson.build +++ b/rootston/meson.build @@ -16,7 +16,7 @@ sources = [ 'xdg_shell_v6.c', ] -if conf_data.get('WLR_HAS_XWAYLAND', false) +if conf_data.get('WLR_HAS_XWAYLAND', 0) == 1 sources += 'xwayland.c' endif diff --git a/rootston/output.c b/rootston/output.c index 9aa7de65..9ca55447 100644 --- a/rootston/output.c +++ b/rootston/output.c @@ -86,7 +86,7 @@ static void view_for_each_surface(struct roots_view *view, wlr_wl_shell_surface_for_each_surface(view->wl_shell_surface, iterator, user_data); break; -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND case ROOTS_XWAYLAND_VIEW: wlr_surface_for_each_surface(view->wlr_surface, iterator, user_data); break; @@ -94,7 +94,7 @@ static void view_for_each_surface(struct roots_view *view, } } -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND static void xwayland_children_for_each_surface( struct wlr_xwayland_surface *surface, wlr_surface_iterator_func_t iterator, struct layout_data *layout_data, @@ -157,14 +157,10 @@ static void output_for_each_surface(struct roots_output *output, if (output->fullscreen_view != NULL) { struct roots_view *view = output->fullscreen_view; - if (wlr_output->fullscreen_surface == view->wlr_surface) { - // The surface is managed by the wlr_output - return; - } view_for_each_surface(view, layout_data, iterator, user_data); -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND if (view->type == ROOTS_XWAYLAND_VIEW) { xwayland_children_for_each_surface(view->xwayland_surface, iterator, layout_data, user_data); @@ -388,26 +384,6 @@ static void render_layer(struct roots_output *output, &data->layout, data); } -static bool has_standalone_surface(struct roots_view *view) { - if (!wl_list_empty(&view->wlr_surface->subsurfaces)) { - return false; - } - - switch (view->type) { - case ROOTS_XDG_SHELL_V6_VIEW: - return wl_list_empty(&view->xdg_surface_v6->popups); - case ROOTS_XDG_SHELL_VIEW: - return wl_list_empty(&view->xdg_surface->popups); - case ROOTS_WL_SHELL_VIEW: - return wl_list_empty(&view->wl_shell_surface->popups); -#ifdef WLR_HAS_XWAYLAND - case ROOTS_XWAYLAND_VIEW: - return wl_list_empty(&view->xwayland_surface->children); -#endif - } - return true; -} - static void surface_send_frame_done(struct wlr_surface *surface, int sx, int sy, void *_data) { struct render_data *data = _data; @@ -459,17 +435,8 @@ static void render_output(struct roots_output *output) { output_box->y; view_move(view, view_x, view_y); - if (has_standalone_surface(view) && - wl_list_empty(&output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY])) { - wlr_output_set_fullscreen_surface(wlr_output, view->wlr_surface); - } else { - wlr_output_set_fullscreen_surface(wlr_output, NULL); - } - // Fullscreen views are rendered on a black background clear_color[0] = clear_color[1] = clear_color[2] = 0; - } else { - wlr_output_set_fullscreen_surface(wlr_output, NULL); } bool needs_swap; @@ -518,11 +485,6 @@ static void render_output(struct roots_output *output) { if (output->fullscreen_view != NULL) { struct roots_view *view = output->fullscreen_view; - if (wlr_output->fullscreen_surface == view->wlr_surface) { - // The output will render the fullscreen view - goto renderer_end; - } - if (view->wlr_surface != NULL) { view_for_each_surface(view, &data.layout, render_surface, &data); } @@ -530,7 +492,7 @@ static void render_output(struct roots_output *output) { // During normal rendering the xwayland window tree isn't traversed // because all windows are rendered. Here we only want to render // the fullscreen window's children so we have to traverse the tree. -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND if (view->type == ROOTS_XWAYLAND_VIEW) { xwayland_children_for_each_surface(view->xwayland_surface, render_surface, &data.layout, &data); @@ -556,6 +518,7 @@ static void render_output(struct roots_output *output) { &output->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]); renderer_end: + wlr_output_render_software_cursors(wlr_output, &damage); wlr_renderer_scissor(renderer, NULL); wlr_renderer_end(renderer); @@ -593,7 +556,7 @@ static bool view_accept_damage(struct roots_output *output, if (output->fullscreen_view == view) { return true; } -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND if (output->fullscreen_view->type == ROOTS_XWAYLAND_VIEW && view->type == ROOTS_XWAYLAND_VIEW) { // Special case: accept damage from children diff --git a/rootston/seat.c b/rootston/seat.c index 82444dcb..95e7d6c9 100644 --- a/rootston/seat.c +++ b/rootston/seat.c @@ -1131,7 +1131,7 @@ void roots_seat_set_focus(struct roots_seat *seat, struct roots_view *view) { bool unfullscreen = true; -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND if (view && view->type == ROOTS_XWAYLAND_VIEW && view->xwayland_surface->override_redirect) { unfullscreen = false; @@ -1160,7 +1160,7 @@ void roots_seat_set_focus(struct roots_seat *seat, struct roots_view *view) { return; } -#ifdef WLR_HAS_XWAYLAND +#if WLR_HAS_XWAYLAND if (view && view->type == ROOTS_XWAYLAND_VIEW && !wlr_xwayland_or_surface_wants_focus( view->xwayland_surface)) { diff --git a/types/wlr_output.c b/types/wlr_output.c index 9936e015..dc8e34b8 100644 --- a/types/wlr_output.c +++ b/types/wlr_output.c @@ -6,6 +6,7 @@ #include <time.h> #include <wayland-server.h> #include <wlr/interfaces/wlr_output.h> +#include <wlr/render/interface.h> #include <wlr/render/wlr_renderer.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_matrix.h> @@ -294,7 +295,6 @@ void wlr_output_destroy(struct wlr_output *output) { wl_list_remove(&output->display_destroy.link); wlr_output_destroy_global(output); - wlr_output_set_fullscreen_surface(output, NULL); wlr_signal_emit_safe(&output->events.destroy, output); @@ -340,130 +340,18 @@ bool wlr_output_make_current(struct wlr_output *output, int *buffer_age) { return output->impl->make_current(output, buffer_age); } -static void output_scissor(struct wlr_output *output, pixman_box32_t *rect) { - struct wlr_renderer *renderer = wlr_backend_get_renderer(output->backend); - assert(renderer); - - struct wlr_box box = { - .x = rect->x1, - .y = rect->y1, - .width = rect->x2 - rect->x1, - .height = rect->y2 - rect->y1, - }; - - int ow, oh; - wlr_output_transformed_resolution(output, &ow, &oh); - - // Scissor is in renderer coordinates, ie. upside down - enum wl_output_transform transform = - wlr_output_transform_invert(output->transform); - wlr_box_transform(&box, transform, ow, oh, &box); - - wlr_renderer_scissor(renderer, &box); -} - -static void output_fullscreen_surface_get_box(struct wlr_output *output, - struct wlr_surface *surface, struct wlr_box *box) { - int width, height; - wlr_output_effective_resolution(output, &width, &height); - - int x = (width - surface->current.width) / 2; - int y = (height - surface->current.height) / 2; - - box->x = x * output->scale; - box->y = y * output->scale; - box->width = surface->current.width * output->scale; - box->height = surface->current.height * output->scale; -} - -static void output_fullscreen_surface_render(struct wlr_output *output, - struct wlr_surface *surface, const struct timespec *when, - pixman_region32_t *damage) { - struct wlr_renderer *renderer = wlr_backend_get_renderer(output->backend); - assert(renderer); - - struct wlr_texture *texture = wlr_surface_get_texture(surface); - if (texture == NULL) { - wlr_renderer_clear(renderer, (float[]){0, 0, 0, 1}); - return; - } - - struct wlr_box box; - output_fullscreen_surface_get_box(output, surface, &box); - - float matrix[9]; - enum wl_output_transform transform = - wlr_output_transform_invert(surface->current.transform); - wlr_matrix_project_box(matrix, &box, transform, 0, - output->transform_matrix); - - int nrects; - pixman_box32_t *rects = pixman_region32_rectangles(damage, &nrects); - for (int i = 0; i < nrects; ++i) { - output_scissor(output, &rects[i]); - wlr_renderer_clear(renderer, (float[]){0, 0, 0, 1}); - wlr_render_texture_with_matrix(surface->renderer, texture, matrix, 1.0f); - } - wlr_renderer_scissor(renderer, NULL); - - wlr_surface_send_frame_done(surface, when); -} - -/** - * Returns the cursor box, scaled for its output. - */ -static void output_cursor_get_box(struct wlr_output_cursor *cursor, - struct wlr_box *box) { - box->x = cursor->x - cursor->hotspot_x; - box->y = cursor->y - cursor->hotspot_y; - box->width = cursor->width; - box->height = cursor->height; -} - -static void output_cursor_render(struct wlr_output_cursor *cursor, - const struct timespec *when, pixman_region32_t *damage) { - struct wlr_renderer *renderer = - wlr_backend_get_renderer(cursor->output->backend); - assert(renderer); - - struct wlr_texture *texture = cursor->texture; - if (cursor->surface != NULL) { - texture = wlr_surface_get_texture(cursor->surface); - } - if (texture == NULL) { - return; - } - - struct wlr_box box; - output_cursor_get_box(cursor, &box); - - pixman_region32_t surface_damage; - pixman_region32_init(&surface_damage); - pixman_region32_union_rect(&surface_damage, &surface_damage, box.x, box.y, - box.width, box.height); - pixman_region32_intersect(&surface_damage, &surface_damage, damage); - if (!pixman_region32_not_empty(&surface_damage)) { - goto surface_damage_finish; - } - - float matrix[9]; - wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, 0, - cursor->output->transform_matrix); - - int nrects; - pixman_box32_t *rects = pixman_region32_rectangles(&surface_damage, &nrects); - for (int i = 0; i < nrects; ++i) { - output_scissor(cursor->output, &rects[i]); - wlr_render_texture_with_matrix(renderer, texture, matrix, 1.0f); +bool wlr_output_preferred_read_format(struct wlr_output *output, + enum wl_shm_format *fmt) { + if (!wlr_output_make_current(output, NULL)) { + return false; } - wlr_renderer_scissor(renderer, NULL); - if (cursor->surface != NULL) { - wlr_surface_send_frame_done(cursor->surface, when); + struct wlr_renderer *renderer = wlr_backend_get_renderer(output->backend); + if (!renderer->impl->preferred_read_format || !renderer->impl->read_pixels) { + return false; } - -surface_damage_finish: - pixman_region32_fini(&surface_damage); + *fmt = renderer->impl->preferred_read_format(renderer); + return true; } bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when, @@ -480,37 +368,12 @@ bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when, int width, height; wlr_output_transformed_resolution(output, &width, &height); - pixman_region32_t render_damage; - pixman_region32_init(&render_damage); - pixman_region32_union_rect(&render_damage, &render_damage, 0, 0, - width, height); - if (damage != NULL) { - // Damage tracking supported - pixman_region32_intersect(&render_damage, &render_damage, damage); - } - struct timespec now; if (when == NULL) { clock_gettime(CLOCK_MONOTONIC, &now); when = &now; } - if (pixman_region32_not_empty(&render_damage)) { - if (output->fullscreen_surface != NULL) { - output_fullscreen_surface_render(output, output->fullscreen_surface, - when, &render_damage); - } - - struct wlr_output_cursor *cursor; - wl_list_for_each(cursor, &output->cursors, link) { - if (!cursor->enabled || !cursor->visible || - output->hardware_cursor == cursor) { - continue; - } - output_cursor_render(cursor, when, &render_damage); - } - } - struct wlr_output_event_swap_buffers event = { .output = output, .when = when, @@ -518,22 +381,40 @@ bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when, }; wlr_signal_emit_safe(&output->events.swap_buffers, &event); + pixman_region32_t render_damage; + pixman_region32_init(&render_damage); + pixman_region32_union_rect(&render_damage, &render_damage, 0, 0, + width, height); + if (damage != NULL) { + // Damage tracking supported + pixman_region32_intersect(&render_damage, &render_damage, damage); + } + // Transform damage into renderer coordinates, ie. upside down - enum wl_output_transform transform = wlr_output_transform_compose( - wlr_output_transform_invert(output->transform), - WL_OUTPUT_TRANSFORM_FLIPPED_180); - wlr_region_transform(&render_damage, &render_damage, transform, width, - height); + // TODO: take transformed coords, make the renderer flip the damage + enum wl_output_transform transform = + wlr_output_transform_invert(output->transform); + wlr_region_transform(&render_damage, &render_damage, transform, + width, height); if (!output->impl->swap_buffers(output, damage ? &render_damage : NULL)) { + pixman_region32_fini(&render_damage); return false; } + pixman_region32_fini(&render_damage); + + struct wlr_output_cursor *cursor; + wl_list_for_each(cursor, &output->cursors, link) { + if (!cursor->enabled || !cursor->visible || cursor->surface == NULL) { + continue; + } + wlr_surface_send_frame_done(cursor->surface, when); + } + output->frame_pending = true; output->needs_swap = false; pixman_region32_clear(&output->damage); - - pixman_region32_fini(&render_damage); return true; } @@ -626,76 +507,6 @@ void wlr_output_damage_whole(struct wlr_output *output) { wlr_output_update_needs_swap(output); } -static void output_fullscreen_surface_reset(struct wlr_output *output) { - if (output->fullscreen_surface != NULL) { - wl_list_remove(&output->fullscreen_surface_commit.link); - wl_list_remove(&output->fullscreen_surface_destroy.link); - output->fullscreen_surface = NULL; - wlr_output_damage_whole(output); - } -} - -static void output_fullscreen_surface_handle_commit( - struct wl_listener *listener, void *data) { - struct wlr_output *output = wl_container_of(listener, output, - fullscreen_surface_commit); - struct wlr_surface *surface = output->fullscreen_surface; - - if (output->fullscreen_width != surface->current.width || - output->fullscreen_height != surface->current.height) { - output->fullscreen_width = surface->current.width; - output->fullscreen_height = surface->current.height; - wlr_output_damage_whole(output); - return; - } - - struct wlr_box box; - output_fullscreen_surface_get_box(output, surface, &box); - - pixman_region32_t damage; - pixman_region32_init(&damage); - pixman_region32_copy(&damage, &surface->current.surface_damage); - wlr_region_scale(&damage, &damage, output->scale); - pixman_region32_translate(&damage, box.x, box.y); - pixman_region32_union(&output->damage, &output->damage, &damage); - pixman_region32_fini(&damage); - - wlr_output_update_needs_swap(output); -} - -static void output_fullscreen_surface_handle_destroy( - struct wl_listener *listener, void *data) { - struct wlr_output *output = wl_container_of(listener, output, - fullscreen_surface_destroy); - output_fullscreen_surface_reset(output); -} - -void wlr_output_set_fullscreen_surface(struct wlr_output *output, - struct wlr_surface *surface) { - // TODO: hardware fullscreen - - if (output->fullscreen_surface == surface) { - return; - } - - output_fullscreen_surface_reset(output); - - output->fullscreen_surface = surface; - wlr_output_damage_whole(output); - - if (surface == NULL) { - return; - } - - output->fullscreen_surface_commit.notify = - output_fullscreen_surface_handle_commit; - wl_signal_add(&surface->events.commit, &output->fullscreen_surface_commit); - output->fullscreen_surface_destroy.notify = - output_fullscreen_surface_handle_destroy; - wl_signal_add(&surface->events.destroy, - &output->fullscreen_surface_destroy); -} - struct wlr_output *wlr_output_from_resource(struct wl_resource *resource) { assert(wl_resource_instance_of(resource, &wl_output_interface, &output_impl)); @@ -728,6 +539,111 @@ void wlr_output_lock_software_cursors(struct wlr_output *output, bool lock) { // again. } +static void output_scissor(struct wlr_output *output, pixman_box32_t *rect) { + struct wlr_renderer *renderer = wlr_backend_get_renderer(output->backend); + assert(renderer); + + struct wlr_box box = { + .x = rect->x1, + .y = rect->y1, + .width = rect->x2 - rect->x1, + .height = rect->y2 - rect->y1, + }; + + int ow, oh; + wlr_output_transformed_resolution(output, &ow, &oh); + + enum wl_output_transform transform = + wlr_output_transform_invert(output->transform); + wlr_box_transform(&box, transform, ow, oh, &box); + + wlr_renderer_scissor(renderer, &box); +} + +static void output_cursor_get_box(struct wlr_output_cursor *cursor, + struct wlr_box *box); + +static void output_cursor_render(struct wlr_output_cursor *cursor, + pixman_region32_t *damage) { + struct wlr_renderer *renderer = + wlr_backend_get_renderer(cursor->output->backend); + assert(renderer); + + struct wlr_texture *texture = cursor->texture; + if (cursor->surface != NULL) { + texture = wlr_surface_get_texture(cursor->surface); + } + if (texture == NULL) { + return; + } + + struct wlr_box box; + output_cursor_get_box(cursor, &box); + + pixman_region32_t surface_damage; + pixman_region32_init(&surface_damage); + pixman_region32_union_rect(&surface_damage, &surface_damage, box.x, box.y, + box.width, box.height); + pixman_region32_intersect(&surface_damage, &surface_damage, damage); + if (!pixman_region32_not_empty(&surface_damage)) { + goto surface_damage_finish; + } + + float matrix[9]; + wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, 0, + cursor->output->transform_matrix); + + int nrects; + pixman_box32_t *rects = pixman_region32_rectangles(&surface_damage, &nrects); + for (int i = 0; i < nrects; ++i) { + output_scissor(cursor->output, &rects[i]); + wlr_render_texture_with_matrix(renderer, texture, matrix, 1.0f); + } + wlr_renderer_scissor(renderer, NULL); + +surface_damage_finish: + pixman_region32_fini(&surface_damage); +} + +void wlr_output_render_software_cursors(struct wlr_output *output, + pixman_region32_t *damage) { + int width, height; + wlr_output_transformed_resolution(output, &width, &height); + + pixman_region32_t render_damage; + pixman_region32_init(&render_damage); + pixman_region32_union_rect(&render_damage, &render_damage, 0, 0, + width, height); + if (damage != NULL) { + // Damage tracking supported + pixman_region32_intersect(&render_damage, &render_damage, damage); + } + + if (pixman_region32_not_empty(&render_damage)) { + struct wlr_output_cursor *cursor; + wl_list_for_each(cursor, &output->cursors, link) { + if (!cursor->enabled || !cursor->visible || + output->hardware_cursor == cursor) { + continue; + } + output_cursor_render(cursor, &render_damage); + } + } + + pixman_region32_fini(&render_damage); +} + + +/** + * Returns the cursor box, scaled for its output. + */ +static void output_cursor_get_box(struct wlr_output_cursor *cursor, + struct wlr_box *box) { + box->x = cursor->x - cursor->hotspot_x; + box->y = cursor->y - cursor->hotspot_y; + box->width = cursor->width; + box->height = cursor->height; +} static void output_cursor_damage_whole(struct wlr_output_cursor *cursor) { struct wlr_box box; @@ -861,9 +777,6 @@ static void output_cursor_commit(struct wlr_output_cursor *cursor, } if (output_cursor_attempt_hardware(cursor)) { - struct timespec now; - clock_gettime(CLOCK_MONOTONIC, &now); - wlr_surface_send_frame_done(surface, &now); return; } diff --git a/types/wlr_primary_selection.c b/types/wlr_primary_selection.c index 3fed0f64..74312540 100644 --- a/types/wlr_primary_selection.c +++ b/types/wlr_primary_selection.c @@ -9,6 +9,8 @@ #include "gtk-primary-selection-protocol.h" #include "util/signal.h" +#define DEVICE_MANAGER_VERSION 1 + static const struct gtk_primary_selection_offer_interface offer_impl; static struct wlr_primary_selection_offer *offer_from_resource( @@ -21,12 +23,12 @@ static struct wlr_primary_selection_offer *offer_from_resource( static void offer_handle_receive(struct wl_client *client, struct wl_resource *resource, const char *mime_type, int32_t fd) { struct wlr_primary_selection_offer *offer = offer_from_resource(resource); - - if (offer->source && offer == offer->source->offer) { - offer->source->send(offer->source, mime_type, fd); - } else { + if (offer == NULL) { close(fd); + return; } + + offer->source->send(offer->source, mime_type, fd); } static void offer_handle_destroy(struct wl_client *client, @@ -39,31 +41,26 @@ static const struct gtk_primary_selection_offer_interface offer_impl = { .destroy = offer_handle_destroy, }; -static void offer_resource_handle_destroy(struct wl_resource *resource) { - struct wlr_primary_selection_offer *offer = offer_from_resource(resource); - - if (!offer->source) { - goto out; +static void offer_destroy(struct wlr_primary_selection_offer *offer) { + if (offer == NULL) { + return; } - + // Make resource inert + wl_resource_set_user_data(offer->resource, NULL); wl_list_remove(&offer->source_destroy.link); - - if (offer->source->offer != offer) { - goto out; - } - - offer->source->offer = NULL; - -out: free(offer); } +static void offer_handle_resource_destroy(struct wl_resource *resource) { + struct wlr_primary_selection_offer *offer = offer_from_resource(resource); + offer_destroy(offer); +} + static void offer_handle_source_destroy(struct wl_listener *listener, void *data) { struct wlr_primary_selection_offer *offer = wl_container_of(listener, offer, source_destroy); - - offer->source = NULL; + offer_destroy(offer); } @@ -85,38 +82,32 @@ static void client_source_cancel( gtk_primary_selection_source_send_cancelled(source->resource); } -static struct wlr_primary_selection_offer *source_send_offer( - struct wlr_primary_selection_source *source, - struct wlr_seat_client *target) { - if (wl_list_empty(&target->primary_selection_devices)) { - return NULL; - } - +static void source_send_offer(struct wlr_primary_selection_source *source, + struct wl_resource *device_resource) { struct wlr_primary_selection_offer *offer = calloc(1, sizeof(struct wlr_primary_selection_offer)); if (offer == NULL) { - return NULL; + wl_resource_post_no_memory(device_resource); + return; } - uint32_t version = wl_resource_get_version( - wl_resource_from_link(target->primary_selection_devices.next)); - offer->resource = wl_resource_create(target->client, + struct wl_client *client = wl_resource_get_client(device_resource); + uint32_t version = wl_resource_get_version(device_resource); + offer->resource = wl_resource_create(client, >k_primary_selection_offer_interface, version, 0); if (offer->resource == NULL) { free(offer); - return NULL; + wl_resource_post_no_memory(device_resource); + return; } wl_resource_set_implementation(offer->resource, &offer_impl, offer, - offer_resource_handle_destroy); + offer_handle_resource_destroy); offer->source_destroy.notify = offer_handle_source_destroy; wl_signal_add(&source->events.destroy, &offer->source_destroy); - struct wl_resource *target_resource; - wl_resource_for_each(target_resource, &target->primary_selection_devices) { - gtk_primary_selection_device_send_data_offer(target_resource, - offer->resource); - } + gtk_primary_selection_device_send_data_offer(device_resource, + offer->resource); char **p; wl_array_for_each(p, &source->mime_types) { @@ -124,9 +115,9 @@ static struct wlr_primary_selection_offer *source_send_offer( } offer->source = source; - source->offer = offer; - return offer; + gtk_primary_selection_device_send_selection(device_resource, + offer->resource); } static const struct gtk_primary_selection_source_interface source_impl; @@ -179,20 +170,13 @@ void wlr_seat_client_send_primary_selection( return; } - if (seat_client->seat->primary_selection_source) { - struct wlr_primary_selection_offer *offer = source_send_offer( - seat_client->seat->primary_selection_source, seat_client); - if (offer == NULL) { - return; - } - - struct wl_resource *resource; - wl_resource_for_each(resource, &seat_client->primary_selection_devices) { - gtk_primary_selection_device_send_selection(resource, offer->resource); - } - } else { - struct wl_resource *resource; - wl_resource_for_each(resource, &seat_client->primary_selection_devices) { + struct wlr_primary_selection_source *source = + seat_client->seat->primary_selection_source; + struct wl_resource *resource; + wl_resource_for_each(resource, &seat_client->primary_selection_devices) { + if (source) { + source_send_offer(source, resource); + } else { gtk_primary_selection_device_send_selection(resource, NULL); } } @@ -228,6 +212,7 @@ void wlr_seat_set_primary_selection(struct wlr_seat *seat, return; } + // TODO: make all offers inert if (seat->primary_selection_source) { wl_list_remove(&seat->primary_selection_source_destroy.link); seat->primary_selection_source->cancel(seat->primary_selection_source); @@ -365,12 +350,17 @@ static void device_manager_handle_destroy(struct wl_client *client, } static const struct gtk_primary_selection_device_manager_interface -device_manager_impl = { + device_manager_impl = { .create_source = device_manager_handle_create_source, .get_device = device_manager_handle_get_device, .destroy = device_manager_handle_destroy, }; +static void device_manager_handle_resource_destroy( + struct wl_resource *resource) { + wl_list_remove(wl_resource_get_link(resource)); +} + static void primary_selection_device_manager_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id) { @@ -383,7 +373,9 @@ static void primary_selection_device_manager_bind(struct wl_client *client, return; } wl_resource_set_implementation(resource, &device_manager_impl, manager, - NULL); + device_manager_handle_resource_destroy); + + wl_list_insert(&manager->resources, wl_resource_get_link(resource)); } static void handle_display_destroy(struct wl_listener *listener, void *data) { @@ -401,13 +393,14 @@ struct wlr_primary_selection_device_manager * return NULL; } manager->global = wl_global_create(display, - >k_primary_selection_device_manager_interface, 1, manager, - primary_selection_device_manager_bind); + >k_primary_selection_device_manager_interface, DEVICE_MANAGER_VERSION, + manager, primary_selection_device_manager_bind); if (manager->global == NULL) { free(manager); return NULL; } + wl_list_init(&manager->resources); wl_signal_init(&manager->events.destroy); manager->display_destroy.notify = handle_display_destroy; @@ -423,7 +416,10 @@ void wlr_primary_selection_device_manager_destroy( } wlr_signal_emit_safe(&manager->events.destroy, manager); wl_list_remove(&manager->display_destroy.link); - // TODO: free resources + struct wl_resource *resource, *resource_tmp; + wl_resource_for_each_safe(resource, resource_tmp, &manager->resources) { + wl_resource_destroy(resource); + } wl_global_destroy(manager->global); free(manager); } diff --git a/types/wlr_screencopy_v1.c b/types/wlr_screencopy_v1.c index b186b89b..1d8550fe 100644 --- a/types/wlr_screencopy_v1.c +++ b/types/wlr_screencopy_v1.c @@ -219,7 +219,7 @@ static void capture_output(struct wl_client *client, struct wlr_renderer *renderer = wlr_backend_get_renderer(output->backend); assert(renderer); - if (!wlr_renderer_preferred_read_format(renderer, &frame->format)) { + if (!wlr_output_preferred_read_format(frame->output, &frame->format)) { wlr_log(WLR_ERROR, "Failed to capture output: no read format supported by renderer"); goto error; diff --git a/types/xdg_shell/wlr_xdg_popup.c b/types/xdg_shell/wlr_xdg_popup.c index b3409261..d23d7dac 100644 --- a/types/xdg_shell/wlr_xdg_popup.c +++ b/types/xdg_shell/wlr_xdg_popup.c @@ -234,12 +234,22 @@ void create_xdg_popup(struct wlr_xdg_surface *xdg_surface, return; } - xdg_surface->popup = calloc(1, sizeof(struct wlr_xdg_popup)); - if (!xdg_surface->popup) { - wl_resource_post_no_memory(xdg_surface->resource); + if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_NONE) { + wl_resource_post_error(xdg_surface->resource, + XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED, + "xdg-surface has already been constructed"); return; } + if (xdg_surface->popup == NULL) { + xdg_surface->popup = calloc(1, sizeof(struct wlr_xdg_popup)); + if (!xdg_surface->popup) { + wl_resource_post_no_memory(xdg_surface->resource); + return; + } + xdg_surface->popup->base = xdg_surface; + } + xdg_surface->popup->resource = wl_resource_create( xdg_surface->client->client, &xdg_popup_interface, wl_resource_get_version(xdg_surface->resource), id); @@ -253,7 +263,6 @@ void create_xdg_popup(struct wlr_xdg_surface *xdg_surface, xdg_popup_handle_resource_destroy); xdg_surface->role = WLR_XDG_SURFACE_ROLE_POPUP; - xdg_surface->popup->base = xdg_surface; // positioner properties memcpy(&xdg_surface->popup->positioner, &positioner->attrs, @@ -265,19 +274,24 @@ void create_xdg_popup(struct wlr_xdg_surface *xdg_surface, xdg_surface->popup->parent = parent->surface; wl_list_insert(&parent->popups, &xdg_surface->popup->link); wlr_signal_emit_safe(&parent->events.new_popup, xdg_surface->popup); + } else { + wl_list_init(&xdg_surface->popup->link); } } -void destroy_xdg_popup(struct wlr_xdg_surface *surface) { - assert(surface->role == WLR_XDG_SURFACE_ROLE_POPUP); - unmap_xdg_surface(surface); +void destroy_xdg_popup(struct wlr_xdg_surface *xdg_surface) { + assert(xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP); + unmap_xdg_surface(xdg_surface); + + // Don't destroy the popup state yet, the compositor might have some + // listeners set up. Anyway the client can only re-create another xdg-popup + // with this xdg-surface because of role restrictions. + wl_resource_set_user_data(xdg_surface->popup->resource, NULL); + xdg_surface->toplevel->resource = NULL; - wl_resource_set_user_data(surface->popup->resource, NULL); - wl_list_remove(&surface->popup->link); - free(surface->popup); - surface->popup = NULL; + wl_list_remove(&xdg_surface->popup->link); - surface->role = WLR_XDG_SURFACE_ROLE_NONE; + xdg_surface->role = WLR_XDG_SURFACE_ROLE_NONE; } void wlr_xdg_popup_get_anchor_point(struct wlr_xdg_popup *popup, diff --git a/types/xdg_shell/wlr_xdg_surface.c b/types/xdg_shell/wlr_xdg_surface.c index e32b7f18..0b1d599f 100644 --- a/types/xdg_shell/wlr_xdg_surface.c +++ b/types/xdg_shell/wlr_xdg_surface.c @@ -83,18 +83,6 @@ void unmap_xdg_surface(struct wlr_xdg_surface *surface) { memset(&surface->next_geometry, 0, sizeof(struct wlr_box)); } -void destroy_xdg_toplevel(struct wlr_xdg_surface *surface) { - assert(surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL); - unmap_xdg_surface(surface); - - wl_resource_set_user_data(surface->toplevel->resource, NULL); - free(surface->toplevel); - surface->toplevel = NULL; - - surface->role = WLR_XDG_SURFACE_ROLE_NONE; -} - - static void xdg_surface_handle_ack_configure(struct wl_client *client, struct wl_resource *resource, uint32_t serial) { @@ -476,6 +464,12 @@ void destroy_xdg_surface(struct wlr_xdg_surface *surface) { break; } + if (surface->surface->role == &xdg_toplevel_surface_role) { + free(surface->toplevel); + } else if (surface->surface->role == &xdg_popup_surface_role) { + free(surface->popup); + } + wl_resource_set_user_data(surface->resource, NULL); surface->surface->role_data = NULL; wl_list_remove(&surface->link); diff --git a/types/xdg_shell/wlr_xdg_toplevel.c b/types/xdg_shell/wlr_xdg_toplevel.c index 77398c7e..d3220994 100644 --- a/types/xdg_shell/wlr_xdg_toplevel.c +++ b/types/xdg_shell/wlr_xdg_toplevel.c @@ -462,37 +462,59 @@ void create_xdg_toplevel(struct wlr_xdg_surface *xdg_surface, return; } - xdg_surface->toplevel = calloc(1, sizeof(struct wlr_xdg_toplevel)); - if (xdg_surface->toplevel == NULL) { - wl_resource_post_no_memory(xdg_surface->resource); + if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_NONE) { + wl_resource_post_error(xdg_surface->resource, + XDG_SURFACE_ERROR_ALREADY_CONSTRUCTED, + "xdg-surface has already been constructed"); return; } - wl_signal_init(&xdg_surface->toplevel->events.request_maximize); - wl_signal_init(&xdg_surface->toplevel->events.request_fullscreen); - wl_signal_init(&xdg_surface->toplevel->events.request_minimize); - wl_signal_init(&xdg_surface->toplevel->events.request_move); - wl_signal_init(&xdg_surface->toplevel->events.request_resize); - wl_signal_init(&xdg_surface->toplevel->events.request_show_window_menu); - wl_signal_init(&xdg_surface->toplevel->events.set_parent); - wl_signal_init(&xdg_surface->toplevel->events.set_title); - wl_signal_init(&xdg_surface->toplevel->events.set_app_id); + + if (xdg_surface->toplevel == NULL) { + xdg_surface->toplevel = calloc(1, sizeof(struct wlr_xdg_toplevel)); + if (xdg_surface->toplevel == NULL) { + wl_resource_post_no_memory(xdg_surface->resource); + return; + } + wl_signal_init(&xdg_surface->toplevel->events.request_maximize); + wl_signal_init(&xdg_surface->toplevel->events.request_fullscreen); + wl_signal_init(&xdg_surface->toplevel->events.request_minimize); + wl_signal_init(&xdg_surface->toplevel->events.request_move); + wl_signal_init(&xdg_surface->toplevel->events.request_resize); + wl_signal_init(&xdg_surface->toplevel->events.request_show_window_menu); + wl_signal_init(&xdg_surface->toplevel->events.set_parent); + wl_signal_init(&xdg_surface->toplevel->events.set_title); + wl_signal_init(&xdg_surface->toplevel->events.set_app_id); + + xdg_surface->toplevel->base = xdg_surface; + } xdg_surface->role = WLR_XDG_SURFACE_ROLE_TOPLEVEL; - xdg_surface->toplevel->base = xdg_surface; - struct wl_resource *toplevel_resource = wl_resource_create( + assert(xdg_surface->toplevel->resource == NULL); + xdg_surface->toplevel->resource = wl_resource_create( xdg_surface->client->client, &xdg_toplevel_interface, wl_resource_get_version(xdg_surface->resource), id); - if (toplevel_resource == NULL) { + if (xdg_surface->toplevel->resource == NULL) { free(xdg_surface->toplevel); wl_resource_post_no_memory(xdg_surface->resource); return; } - wl_resource_set_implementation(toplevel_resource, + wl_resource_set_implementation(xdg_surface->toplevel->resource, &xdg_toplevel_implementation, xdg_surface, xdg_toplevel_handle_resource_destroy); +} + +void destroy_xdg_toplevel(struct wlr_xdg_surface *xdg_surface) { + assert(xdg_surface->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL); + unmap_xdg_surface(xdg_surface); + + // Don't destroy the toplevel state yet, the compositor might have some + // listeners set up. Anyway the client can only re-create another + // xdg-toplevel with this xdg-surface because of role restrictions. + wl_resource_set_user_data(xdg_surface->toplevel->resource, NULL); + xdg_surface->toplevel->resource = NULL; - xdg_surface->toplevel->resource = toplevel_resource; + xdg_surface->role = WLR_XDG_SURFACE_ROLE_NONE; } uint32_t wlr_xdg_toplevel_set_size(struct wlr_xdg_surface *surface, diff --git a/xwayland/meson.build b/xwayland/meson.build index 0bd88924..e5f9b9be 100644 --- a/xwayland/meson.build +++ b/xwayland/meson.build @@ -23,7 +23,7 @@ foreach lib : xwayland_optional dep = dependency(lib, required: get_option(lib)) if dep.found() xwayland_libs += dep - conf_data.set('WLR_HAS_' + lib.underscorify().to_upper(), true) + conf_data.set10('WLR_HAS_' + lib.underscorify().to_upper(), true) endif endforeach @@ -48,4 +48,4 @@ lib_wlr_xwayland = static_library( ) wlr_parts += lib_wlr_xwayland -conf_data.set('WLR_HAS_XWAYLAND', true) +conf_data.set10('WLR_HAS_XWAYLAND', true) diff --git a/xwayland/xwm.c b/xwayland/xwm.c index c61c3ced..91fa7e3d 100644 --- a/xwayland/xwm.c +++ b/xwayland/xwm.c @@ -502,7 +502,7 @@ static void read_surface_protocols(struct wlr_xwm *xwm, wlr_log(WLR_DEBUG, "WM_PROTOCOLS (%zu)", atoms_len); } -#ifdef WLR_HAS_XCB_ICCCM +#if WLR_HAS_XCB_ICCCM static void read_surface_hints(struct wlr_xwm *xwm, struct wlr_xwayland_surface *xsurface, xcb_get_property_reply_t *reply) { @@ -540,7 +540,7 @@ static void read_surface_hints(struct wlr_xwm *xwm, } #endif -#ifdef WLR_HAS_XCB_ICCCM +#if WLR_HAS_XCB_ICCCM static void read_surface_normal_hints(struct wlr_xwm *xwm, struct wlr_xwayland_surface *xsurface, xcb_get_property_reply_t *reply) { @@ -1195,7 +1195,7 @@ static void xwm_handle_focus_in(struct wlr_xwm *xwm, } static void xwm_handle_xcb_error(struct wlr_xwm *xwm, xcb_value_error_t *ev) { -#ifdef WLR_HAS_XCB_ERRORS +#if WLR_HAS_XCB_ERRORS const char *major_name = xcb_errors_get_name_for_major_code(xwm->errors_context, ev->major_opcode); @@ -1233,7 +1233,7 @@ log_raw: } static void xwm_handle_unhandled_event(struct wlr_xwm *xwm, xcb_generic_event_t *ev) { -#ifdef WLR_HAS_XCB_ERRORS +#if WLR_HAS_XCB_ERRORS const char *extension; const char *event_name = xcb_errors_get_name_for_xcb_event(xwm->errors_context, @@ -1418,7 +1418,7 @@ void xwm_destroy(struct wlr_xwm *xwm) { if (xwm->event_source) { wl_event_source_remove(xwm->event_source); } -#ifdef WLR_HAS_XCB_ERRORS +#if WLR_HAS_XCB_ERRORS if (xwm->errors_context) { xcb_errors_context_free(xwm->errors_context); } @@ -1659,7 +1659,7 @@ struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland) { return NULL; } -#ifdef WLR_HAS_XCB_ERRORS +#if WLR_HAS_XCB_ERRORS if (xcb_errors_context_new(xwm->xcb_conn, &xwm->errors_context)) { wlr_log(WLR_ERROR, "Could not allocate error context"); xwm_destroy(xwm); |