aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--README.md4
-rw-r--r--backend/backend.c9
-rw-r--r--backend/drm/drm.c6
-rw-r--r--backend/meson.build1
-rw-r--r--backend/session/direct-ipc.c2
-rw-r--r--backend/session/logind.c4
-rw-r--r--backend/session/session.c4
-rw-r--r--backend/wayland/backend.c257
-rw-r--r--backend/wayland/output.c3
-rw-r--r--backend/wayland/registry.c55
-rw-r--r--backend/wayland/wl_seat.c51
-rw-r--r--backend/x11/backend.c183
-rw-r--r--backend/x11/input_device.c261
-rw-r--r--backend/x11/meson.build17
-rw-r--r--backend/x11/output.c57
-rw-r--r--include/backend/wayland.h11
-rw-r--r--include/backend/x11.h26
-rw-r--r--include/rootston/desktop.h2
-rw-r--r--include/rootston/server.h2
-rw-r--r--include/rootston/view.h6
-rw-r--r--include/wlr/backend/meson.build2
-rw-r--r--include/wlr/backend/x11.h2
-rw-r--r--include/wlr/config.h.in1
-rw-r--r--include/wlr/meson.build2
-rw-r--r--include/wlr/render/egl.h2
-rw-r--r--include/wlr/render/interface.h2
-rw-r--r--include/wlr/render/wlr_renderer.h5
-rw-r--r--include/wlr/types/wlr_output.h19
-rw-r--r--include/wlr/types/wlr_primary_selection.h4
-rw-r--r--include/xwayland/xwm.h6
-rw-r--r--meson.build24
-rw-r--r--meson_options.txt1
-rw-r--r--render/egl.c18
-rw-r--r--render/wlr_renderer.c9
-rw-r--r--rootston/desktop.c8
-rw-r--r--rootston/input.c2
-rw-r--r--rootston/main.c4
-rw-r--r--rootston/meson.build2
-rw-r--r--rootston/output.c49
-rw-r--r--rootston/seat.c4
-rw-r--r--types/wlr_output.c367
-rw-r--r--types/wlr_primary_selection.c114
-rw-r--r--types/wlr_screencopy_v1.c2
-rw-r--r--types/xdg_shell/wlr_xdg_popup.c38
-rw-r--r--types/xdg_shell/wlr_xdg_surface.c18
-rw-r--r--types/xdg_shell/wlr_xdg_toplevel.c56
-rw-r--r--xwayland/meson.build4
-rw-r--r--xwayland/xwm.c12
48 files changed, 872 insertions, 866 deletions
diff --git a/README.md b/README.md
index 1519d0b3..2ebef443 100644
--- a/README.md
+++ b/README.md
@@ -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, &registry_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, &registry_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,
&gtk_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,
- &gtk_primary_selection_device_manager_interface, 1, manager,
- primary_selection_device_manager_bind);
+ &gtk_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);