diff options
40 files changed, 498 insertions, 234 deletions
diff --git a/backend/drm/backend.c b/backend/drm/backend.c index 1df5cdd1..bba79bda 100644 --- a/backend/drm/backend.c +++ b/backend/drm/backend.c @@ -15,8 +15,14 @@ #include "backend/drm/drm.h" #include "util/signal.h" +struct wlr_drm_backend *get_drm_backend_from_backend( + struct wlr_backend *wlr_backend) { + assert(wlr_backend_is_drm(wlr_backend)); + return (struct wlr_drm_backend *)wlr_backend; +} + static bool backend_start(struct wlr_backend *backend) { - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)backend; + struct wlr_drm_backend *drm = get_drm_backend_from_backend(backend); scan_drm_connectors(drm); return true; } @@ -26,7 +32,7 @@ static void backend_destroy(struct wlr_backend *backend) { return; } - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)backend; + struct wlr_drm_backend *drm = get_drm_backend_from_backend(backend); restore_drm_outputs(drm); @@ -50,7 +56,7 @@ static void backend_destroy(struct wlr_backend *backend) { static struct wlr_renderer *backend_get_renderer( struct wlr_backend *backend) { - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)backend; + struct wlr_drm_backend *drm = get_drm_backend_from_backend(backend); if (drm->parent) { return drm->parent->renderer.wlr_rend; @@ -141,7 +147,9 @@ struct wlr_backend *wlr_drm_backend_create(struct wl_display *display, wl_list_init(&drm->outputs); drm->fd = gpu_fd; - drm->parent = (struct wlr_drm_backend *)parent; + if (parent != NULL) { + drm->parent = get_drm_backend_from_backend(parent); + } drm->drm_invalidated.notify = drm_invalidated; wlr_session_signal_add(session, gpu_fd, &drm->drm_invalidated); @@ -187,6 +195,6 @@ error_fd: } struct wlr_session *wlr_drm_backend_get_session(struct wlr_backend *backend) { - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)backend; + struct wlr_drm_backend *drm = get_drm_backend_from_backend(backend); return drm->session; } diff --git a/backend/drm/drm.c b/backend/drm/drm.c index eac3a312..8e7c421d 100644 --- a/backend/drm/drm.c +++ b/backend/drm/drm.c @@ -205,16 +205,22 @@ void finish_drm_resources(struct wlr_drm_backend *drm) { free(drm->planes); } +static struct wlr_drm_connector *get_drm_connector_from_output( + struct wlr_output *wlr_output) { + assert(wlr_output_is_drm(wlr_output)); + return (struct wlr_drm_connector *)wlr_output; +} + static bool drm_connector_make_current(struct wlr_output *output, int *buffer_age) { - struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; + struct wlr_drm_connector *conn = get_drm_connector_from_output(output); return make_drm_surface_current(&conn->crtc->primary->surf, buffer_age); } static bool drm_connector_swap_buffers(struct wlr_output *output, pixman_region32_t *damage) { - struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend; + struct wlr_drm_connector *conn = get_drm_connector_from_output(output); + struct wlr_drm_backend *drm = get_drm_backend_from_backend(output->backend); if (!drm->session->active) { return false; } @@ -254,8 +260,8 @@ static void fill_empty_gamma_table(uint32_t size, } static uint32_t drm_connector_get_gamma_size(struct wlr_output *output) { - struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend; + struct wlr_drm_connector *conn = get_drm_connector_from_output(output); + struct wlr_drm_backend *drm = get_drm_backend_from_backend(output->backend); if (conn->crtc) { return drm->iface->crtc_get_gamma_size(drm, conn->crtc); @@ -266,8 +272,8 @@ static uint32_t drm_connector_get_gamma_size(struct wlr_output *output) { static bool drm_connector_set_gamma(struct wlr_output *output, uint32_t size, uint16_t *r, uint16_t *g, uint16_t *b) { - struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend; + struct wlr_drm_connector *conn = get_drm_connector_from_output(output); + struct wlr_drm_backend *drm = get_drm_backend_from_backend(output->backend); if (!conn->crtc) { return false; @@ -297,8 +303,8 @@ static bool drm_connector_set_gamma(struct wlr_output *output, static bool drm_connector_export_dmabuf(struct wlr_output *output, struct wlr_dmabuf_attributes *attribs) { - struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend; + struct wlr_drm_connector *conn = get_drm_connector_from_output(output); + struct wlr_drm_backend *drm = get_drm_backend_from_backend(output->backend); if (!drm->session->active) { return false; @@ -321,7 +327,8 @@ static void drm_connector_start_renderer(struct wlr_drm_connector *conn) { wlr_log(WLR_DEBUG, "Starting renderer on output '%s'", conn->output.name); - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend; + struct wlr_drm_backend *drm = + get_drm_backend_from_backend(conn->output.backend); struct wlr_drm_crtc *crtc = conn->crtc; if (!crtc) { return; @@ -361,8 +368,8 @@ static void attempt_enable_needs_modeset(struct wlr_drm_backend *drm) { } bool enable_drm_connector(struct wlr_output *output, bool enable) { - struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend; + struct wlr_drm_connector *conn = get_drm_connector_from_output(output); + struct wlr_drm_backend *drm = get_drm_backend_from_backend(output->backend); if (conn->state != WLR_DRM_CONN_CONNECTED && conn->state != WLR_DRM_CONN_NEEDS_MODESET) { return false; @@ -456,8 +463,8 @@ static void drm_connector_cleanup(struct wlr_drm_connector *conn); static bool drm_connector_set_mode(struct wlr_output *output, struct wlr_output_mode *mode) { - struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend; + struct wlr_drm_connector *conn = get_drm_connector_from_output(output); + struct wlr_drm_backend *drm = get_drm_backend_from_backend(output->backend); if (conn->crtc == NULL) { // Maybe we can steal a CRTC from a disabled output realloc_crtcs(drm, NULL); @@ -496,7 +503,7 @@ static bool drm_connector_set_mode(struct wlr_output *output, bool wlr_drm_connector_add_mode(struct wlr_output *output, const drmModeModeInfo *modeinfo) { - struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; + struct wlr_drm_connector *conn = get_drm_connector_from_output(output); assert(modeinfo); if (modeinfo->type != DRM_MODE_TYPE_USERDEF) { @@ -528,10 +535,10 @@ static void drm_connector_transform(struct wlr_output *output, static bool drm_connector_set_cursor(struct wlr_output *output, struct wlr_texture *texture, int32_t scale, - enum wl_output_transform transform, int32_t hotspot_x, int32_t hotspot_y, - bool update_texture) { - struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend; + enum wl_output_transform transform, + int32_t hotspot_x, int32_t hotspot_y, bool update_texture) { + struct wlr_drm_connector *conn = get_drm_connector_from_output(output); + struct wlr_drm_backend *drm = get_drm_backend_from_backend(output->backend); struct wlr_drm_crtc *crtc = conn->crtc; if (!crtc) { @@ -664,8 +671,8 @@ static bool drm_connector_set_cursor(struct wlr_output *output, static bool drm_connector_move_cursor(struct wlr_output *output, int x, int y) { - struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend; + struct wlr_drm_connector *conn = get_drm_connector_from_output(output); + struct wlr_drm_backend *drm = get_drm_backend_from_backend(output->backend); if (!conn->crtc) { return false; } @@ -700,7 +707,7 @@ static bool drm_connector_move_cursor(struct wlr_output *output, } static void drm_connector_destroy(struct wlr_output *output) { - struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output; + struct wlr_drm_connector *conn = get_drm_connector_from_output(output); drm_connector_cleanup(conn); wl_event_source_remove(conn->retry_pageflip); wl_list_remove(&conn->link); @@ -742,7 +749,8 @@ static const int32_t subpixel_map[] = { }; static void dealloc_crtc(struct wlr_drm_connector *conn) { - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend; + struct wlr_drm_backend *drm = + get_drm_backend_from_backend(conn->output.backend); if (conn->crtc == NULL) { return; } @@ -1121,7 +1129,8 @@ void scan_drm_connectors(struct wlr_drm_backend *drm) { static void page_flip_handler(int fd, unsigned seq, unsigned tv_sec, unsigned tv_usec, void *user) { struct wlr_drm_connector *conn = user; - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend; + struct wlr_drm_backend *drm = + get_drm_backend_from_backend(conn->output.backend); conn->pageflip_pending = false; if (conn->state != WLR_DRM_CONN_CONNECTED || conn->crtc == NULL) { diff --git a/backend/headless/backend.c b/backend/headless/backend.c index 0138166d..cbc158f3 100644 --- a/backend/headless/backend.c +++ b/backend/headless/backend.c @@ -1,4 +1,4 @@ -#include "util/signal.h" +#include <assert.h> #include <stdlib.h> #include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_output.h> @@ -7,10 +7,17 @@ #include <wlr/util/log.h> #include "backend/headless.h" #include "glapi.h" +#include "util/signal.h" + +struct wlr_headless_backend *headless_backend_from_backend( + struct wlr_backend *wlr_backend) { + assert(wlr_backend_is_headless(wlr_backend)); + return (struct wlr_headless_backend *)wlr_backend; +} static bool backend_start(struct wlr_backend *wlr_backend) { struct wlr_headless_backend *backend = - (struct wlr_headless_backend *)wlr_backend; + headless_backend_from_backend(wlr_backend); wlr_log(WLR_INFO, "Starting headless backend"); struct wlr_headless_output *output; @@ -34,7 +41,7 @@ static bool backend_start(struct wlr_backend *wlr_backend) { static void backend_destroy(struct wlr_backend *wlr_backend) { struct wlr_headless_backend *backend = - (struct wlr_headless_backend *)wlr_backend; + headless_backend_from_backend(wlr_backend); if (!wlr_backend) { return; } @@ -62,7 +69,7 @@ static void backend_destroy(struct wlr_backend *wlr_backend) { static struct wlr_renderer *backend_get_renderer( struct wlr_backend *wlr_backend) { struct wlr_headless_backend *backend = - (struct wlr_headless_backend *)wlr_backend; + headless_backend_from_backend(wlr_backend); return backend->renderer; } @@ -107,9 +114,8 @@ struct wlr_backend *wlr_headless_backend_create(struct wl_display *display, create_renderer_func = wlr_renderer_autocreate; } - backend->renderer = create_renderer_func(&backend->egl, EGL_PLATFORM_SURFACELESS_MESA, - NULL, (EGLint*)config_attribs, 0); - + backend->renderer = create_renderer_func(&backend->egl, + EGL_PLATFORM_SURFACELESS_MESA, NULL, (EGLint*)config_attribs, 0); if (!backend->renderer) { wlr_log(WLR_ERROR, "Failed to create renderer"); free(backend); diff --git a/backend/headless/input_device.c b/backend/headless/input_device.c index a2474aeb..ba251dd7 100644 --- a/backend/headless/input_device.c +++ b/backend/headless/input_device.c @@ -1,3 +1,4 @@ +#include <assert.h> #include <stdlib.h> #include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_keyboard.h> @@ -18,7 +19,7 @@ bool wlr_input_device_is_headless(struct wlr_input_device *wlr_dev) { struct wlr_input_device *wlr_headless_add_input_device( struct wlr_backend *wlr_backend, enum wlr_input_device_type type) { struct wlr_headless_backend *backend = - (struct wlr_headless_backend *)wlr_backend; + headless_backend_from_backend(wlr_backend); struct wlr_headless_input_device *device = calloc(1, sizeof(struct wlr_headless_input_device)); diff --git a/backend/headless/output.c b/backend/headless/output.c index 24fc3bfd..143900d4 100644 --- a/backend/headless/output.c +++ b/backend/headless/output.c @@ -1,3 +1,4 @@ +#include <assert.h> #include <EGL/egl.h> #include <EGL/eglext.h> #include <stdlib.h> @@ -7,6 +8,12 @@ #include "backend/headless.h" #include "util/signal.h" +static struct wlr_headless_output *headless_output_from_output( + struct wlr_output *wlr_output) { + assert(wlr_output_is_headless(wlr_output)); + return (struct wlr_headless_output *)wlr_output; +} + static EGLSurface egl_create_surface(struct wlr_egl *egl, unsigned int width, unsigned int height) { EGLint attribs[] = {EGL_WIDTH, width, EGL_HEIGHT, height, EGL_NONE}; @@ -22,7 +29,7 @@ static EGLSurface egl_create_surface(struct wlr_egl *egl, unsigned int width, static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width, int32_t height, int32_t refresh) { struct wlr_headless_output *output = - (struct wlr_headless_output *)wlr_output; + headless_output_from_output(wlr_output); struct wlr_headless_backend *backend = output->backend; if (refresh <= 0) { @@ -47,13 +54,13 @@ static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width, static void output_transform(struct wlr_output *wlr_output, enum wl_output_transform transform) { struct wlr_headless_output *output = - (struct wlr_headless_output *)wlr_output; + headless_output_from_output(wlr_output); output->wlr_output.transform = transform; } static bool output_make_current(struct wlr_output *wlr_output, int *buffer_age) { struct wlr_headless_output *output = - (struct wlr_headless_output *)wlr_output; + headless_output_from_output(wlr_output); return wlr_egl_make_current(&output->backend->egl, output->egl_surface, buffer_age); } @@ -65,7 +72,7 @@ static bool output_swap_buffers(struct wlr_output *wlr_output, static void output_destroy(struct wlr_output *wlr_output) { struct wlr_headless_output *output = - (struct wlr_headless_output *)wlr_output; + headless_output_from_output(wlr_output); wl_list_remove(&output->link); @@ -97,7 +104,7 @@ static int signal_frame(void *data) { struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend, unsigned int width, unsigned int height) { struct wlr_headless_backend *backend = - (struct wlr_headless_backend *)wlr_backend; + headless_backend_from_backend(wlr_backend); struct wlr_headless_output *output = calloc(1, sizeof(struct wlr_headless_output)); diff --git a/backend/libinput/backend.c b/backend/libinput/backend.c index 19dc779d..8106af00 100644 --- a/backend/libinput/backend.c +++ b/backend/libinput/backend.c @@ -7,6 +7,12 @@ #include "backend/libinput.h" #include "util/signal.h" +static struct wlr_libinput_backend *get_libinput_backend_from_backend( + struct wlr_backend *wlr_backend) { + assert(wlr_backend_is_libinput(wlr_backend)); + return (struct wlr_libinput_backend *)wlr_backend; +} + static int libinput_open_restricted(const char *path, int flags, void *_backend) { struct wlr_libinput_backend *backend = _backend; @@ -43,9 +49,9 @@ static void log_libinput(struct libinput *libinput_context, _wlr_vlog(WLR_ERROR, fmt, args); } -static bool backend_start(struct wlr_backend *_backend) { +static bool backend_start(struct wlr_backend *wlr_backend) { struct wlr_libinput_backend *backend = - (struct wlr_libinput_backend *)_backend; + get_libinput_backend_from_backend(wlr_backend); wlr_log(WLR_DEBUG, "Initializing libinput"); backend->libinput_context = libinput_udev_create_context(&libinput_impl, @@ -101,7 +107,7 @@ static void backend_destroy(struct wlr_backend *wlr_backend) { return; } struct wlr_libinput_backend *backend = - (struct wlr_libinput_backend *)wlr_backend; + get_libinput_backend_from_backend(wlr_backend); for (size_t i = 0; i < backend->wlr_device_lists.length; i++) { struct wl_list *wlr_devices = backend->wlr_device_lists.items[i]; @@ -158,9 +164,8 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { struct wlr_backend *wlr_libinput_backend_create(struct wl_display *display, struct wlr_session *session) { - assert(display && session); - - struct wlr_libinput_backend *backend = calloc(1, sizeof(struct wlr_libinput_backend)); + struct wlr_libinput_backend *backend = + calloc(1, sizeof(struct wlr_libinput_backend)); if (!backend) { wlr_log(WLR_ERROR, "Allocation failed: %s", strerror(errno)); return NULL; @@ -187,8 +192,10 @@ error_backend: return NULL; } -struct libinput_device *wlr_libinput_get_device_handle(struct wlr_input_device *_dev) { - struct wlr_libinput_input_device *dev = (struct wlr_libinput_input_device *)_dev; +struct libinput_device *wlr_libinput_get_device_handle( + struct wlr_input_device *wlr_dev) { + struct wlr_libinput_input_device *dev = + (struct wlr_libinput_input_device *)wlr_dev; return dev->handle; } diff --git a/backend/libinput/events.c b/backend/libinput/events.c index 0548e502..9ce62d6f 100644 --- a/backend/libinput/events.c +++ b/backend/libinput/events.c @@ -9,6 +9,12 @@ #include "backend/libinput.h" #include "util/signal.h" +struct wlr_libinput_input_device *get_libinput_device_from_device( + struct wlr_input_device *wlr_dev) { + assert(wlr_input_device_is_libinput(wlr_dev)); + return (struct wlr_libinput_input_device *)wlr_dev; +} + struct wlr_input_device *get_appropriate_device( enum wlr_input_device_type desired_type, struct libinput_device *libinput_dev) { @@ -25,8 +31,9 @@ struct wlr_input_device *get_appropriate_device( return NULL; } -static void input_device_destroy(struct wlr_input_device *_dev) { - struct wlr_libinput_input_device *dev = (struct wlr_libinput_input_device *)_dev; +static void input_device_destroy(struct wlr_input_device *wlr_dev) { + struct wlr_libinput_input_device *dev = + get_libinput_device_from_device(wlr_dev); libinput_device_unref(dev->handle); wl_list_remove(&dev->wlr_input_device.link); free(dev); @@ -37,16 +44,18 @@ static const struct wlr_input_device_impl input_device_impl = { }; static struct wlr_input_device *allocate_device( - struct wlr_libinput_backend *backend, struct libinput_device *libinput_dev, - struct wl_list *wlr_devices, enum wlr_input_device_type type) { + struct wlr_libinput_backend *backend, + struct libinput_device *libinput_dev, struct wl_list *wlr_devices, + enum wlr_input_device_type type) { int vendor = libinput_device_get_id_vendor(libinput_dev); int product = libinput_device_get_id_product(libinput_dev); const char *name = libinput_device_get_name(libinput_dev); - struct wlr_libinput_input_device *wlr_libinput_dev; - if (!(wlr_libinput_dev = calloc(1, sizeof(struct wlr_libinput_input_device)))) { + struct wlr_libinput_input_device *dev = + calloc(1, sizeof(struct wlr_libinput_input_device)); + if (dev == NULL) { return NULL; } - struct wlr_input_device *wlr_dev = &wlr_libinput_dev->wlr_input_device; + struct wlr_input_device *wlr_dev = &dev->wlr_input_device; libinput_device_get_size(libinput_dev, &wlr_dev->width_mm, &wlr_dev->height_mm); const char *output_name = libinput_device_get_output_name(libinput_dev); @@ -54,7 +63,7 @@ static struct wlr_input_device *allocate_device( wlr_dev->output_name = strdup(output_name); } wl_list_insert(wlr_devices, &wlr_dev->link); - wlr_libinput_dev->handle = libinput_dev; + dev->handle = libinput_dev; libinput_device_ref(libinput_dev); wlr_input_device_init(wlr_dev, type, &input_device_impl, name, vendor, product); @@ -62,12 +71,11 @@ static struct wlr_input_device *allocate_device( } bool wlr_input_device_is_libinput(struct wlr_input_device *wlr_dev) { - return wlr_dev->impl == &input_device_impl; + return wlr_dev->impl == &input_device_impl; } static void handle_device_added(struct wlr_libinput_backend *backend, struct libinput_device *libinput_dev) { - assert(backend && libinput_dev); /* * Note: the wlr API exposes only devices with a single capability, because * that meshes better with how Wayland does things and is a bit simpler. @@ -85,7 +93,8 @@ static void handle_device_added(struct wlr_libinput_backend *backend, wl_list_init(wlr_devices); wlr_log(WLR_DEBUG, "Added %s [%d:%d]", name, vendor, product); - if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_KEYBOARD)) { + if (libinput_device_has_capability( + libinput_dev, LIBINPUT_DEVICE_CAP_KEYBOARD)) { struct wlr_input_device *wlr_dev = allocate_device(backend, libinput_dev, wlr_devices, WLR_INPUT_DEVICE_KEYBOARD); if (!wlr_dev) { @@ -98,7 +107,8 @@ static void handle_device_added(struct wlr_libinput_backend *backend, } wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); } - if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_POINTER)) { + if (libinput_device_has_capability( + libinput_dev, LIBINPUT_DEVICE_CAP_POINTER)) { struct wlr_input_device *wlr_dev = allocate_device(backend, libinput_dev, wlr_devices, WLR_INPUT_DEVICE_POINTER); if (!wlr_dev) { @@ -111,7 +121,8 @@ static void handle_device_added(struct wlr_libinput_backend *backend, } wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); } - if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_TOUCH)) { + if (libinput_device_has_capability( + libinput_dev, LIBINPUT_DEVICE_CAP_TOUCH)) { struct wlr_input_device *wlr_dev = allocate_device(backend, libinput_dev, wlr_devices, WLR_INPUT_DEVICE_TOUCH); if (!wlr_dev) { @@ -124,7 +135,8 @@ static void handle_device_added(struct wlr_libinput_backend *backend, } wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); } - if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_TABLET_TOOL)) { + if (libinput_device_has_capability(libinput_dev, + LIBINPUT_DEVICE_CAP_TABLET_TOOL)) { struct wlr_input_device *wlr_dev = allocate_device(backend, libinput_dev, wlr_devices, WLR_INPUT_DEVICE_TABLET_TOOL); if (!wlr_dev) { @@ -137,7 +149,8 @@ static void handle_device_added(struct wlr_libinput_backend *backend, } wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); } - if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_TABLET_PAD)) { + if (libinput_device_has_capability( + libinput_dev, LIBINPUT_DEVICE_CAP_TABLET_PAD)) { struct wlr_input_device *wlr_dev = allocate_device(backend, libinput_dev, wlr_devices, WLR_INPUT_DEVICE_TABLET_PAD); if (!wlr_dev) { @@ -150,14 +163,16 @@ static void handle_device_added(struct wlr_libinput_backend *backend, } wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); } - if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_GESTURE)) { + if (libinput_device_has_capability( + libinput_dev, LIBINPUT_DEVICE_CAP_GESTURE)) { // TODO } - if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_SWITCH)) { + if (libinput_device_has_capability( + libinput_dev, LIBINPUT_DEVICE_CAP_SWITCH)) { // TODO } - if (wl_list_length(wlr_devices) > 0) { + if (!wl_list_empty(wlr_devices)) { libinput_device_set_user_data(libinput_dev, wlr_devices); wlr_list_push(&backend->wlr_device_lists, wlr_devices); } else { @@ -199,7 +214,6 @@ static void handle_device_removed(struct wlr_libinput_backend *backend, void handle_libinput_event(struct wlr_libinput_backend *backend, struct libinput_event *event) { - assert(backend && event); struct libinput_device *libinput_dev = libinput_event_get_device(event); enum libinput_event_type event_type = libinput_event_get_type(event); switch (event_type) { diff --git a/backend/libinput/keyboard.c b/backend/libinput/keyboard.c index d0059e06..93605e77 100644 --- a/backend/libinput/keyboard.c +++ b/backend/libinput/keyboard.c @@ -12,35 +12,43 @@ struct wlr_libinput_keyboard { struct libinput_device *libinput_dev; }; +static const struct wlr_keyboard_impl impl; + +static struct wlr_libinput_keyboard *get_libinput_keyboard_from_keyboard( + struct wlr_keyboard *wlr_kb) { + assert(wlr_kb->impl == &impl); + return (struct wlr_libinput_keyboard *)wlr_kb; +} + static void keyboard_set_leds(struct wlr_keyboard *wlr_kb, uint32_t leds) { - struct wlr_libinput_keyboard *wlr_libinput_kb = - (struct wlr_libinput_keyboard *)wlr_kb; - libinput_device_led_update(wlr_libinput_kb->libinput_dev, leds); + struct wlr_libinput_keyboard *kb = + get_libinput_keyboard_from_keyboard(wlr_kb); + libinput_device_led_update(kb->libinput_dev, leds); } static void keyboard_destroy(struct wlr_keyboard *wlr_kb) { - struct wlr_libinput_keyboard *wlr_libinput_kb = - (struct wlr_libinput_keyboard *)wlr_kb; - libinput_device_unref(wlr_libinput_kb->libinput_dev); - free(wlr_libinput_kb); + struct wlr_libinput_keyboard *kb = + get_libinput_keyboard_from_keyboard(wlr_kb); + libinput_device_unref(kb->libinput_dev); + free(kb); } -struct wlr_keyboard_impl impl = { +static const struct wlr_keyboard_impl impl = { .destroy = keyboard_destroy, .led_update = keyboard_set_leds }; struct wlr_keyboard *create_libinput_keyboard( struct libinput_device *libinput_dev) { - assert(libinput_dev); - struct wlr_libinput_keyboard *wlr_libinput_kb; - if (!(wlr_libinput_kb= calloc(1, sizeof(struct wlr_libinput_keyboard)))) { + struct wlr_libinput_keyboard *kb = + calloc(1, sizeof(struct wlr_libinput_keyboard)); + if (kb == NULL) { return NULL; } - wlr_libinput_kb->libinput_dev = libinput_dev; + kb->libinput_dev = libinput_dev; libinput_device_ref(libinput_dev); libinput_device_led_update(libinput_dev, 0); - struct wlr_keyboard *wlr_kb = &wlr_libinput_kb->wlr_keyboard; + struct wlr_keyboard *wlr_kb = &kb->wlr_keyboard; wlr_keyboard_init(wlr_kb, &impl); return wlr_kb; } @@ -50,7 +58,8 @@ void handle_keyboard_key(struct libinput_event *event, struct wlr_input_device *wlr_dev = get_appropriate_device(WLR_INPUT_DEVICE_KEYBOARD, libinput_dev); if (!wlr_dev) { - wlr_log(WLR_DEBUG, "Got a keyboard event for a device with no keyboards?"); + wlr_log(WLR_DEBUG, + "Got a keyboard event for a device with no keyboards?"); return; } struct libinput_event_keyboard *kbevent = diff --git a/backend/libinput/tablet_pad.c b/backend/libinput/tablet_pad.c index 0642f925..b053b9a0 100644 --- a/backend/libinput/tablet_pad.c +++ b/backend/libinput/tablet_pad.c @@ -69,7 +69,8 @@ static void add_pad_group_from_libinput(struct wlr_tablet_pad *pad, struct wlr_tablet_pad *create_libinput_tablet_pad( struct libinput_device *libinput_dev) { assert(libinput_dev); - struct wlr_tablet_pad *wlr_tablet_pad = calloc(1, sizeof(struct wlr_tablet_pad)); + struct wlr_tablet_pad *wlr_tablet_pad = + calloc(1, sizeof(struct wlr_tablet_pad)); if (!wlr_tablet_pad) { wlr_log(WLR_ERROR, "Unable to allocate wlr_tablet_pad"); return NULL; @@ -101,7 +102,8 @@ void handle_tablet_pad_button(struct libinput_event *event, struct wlr_input_device *wlr_dev = get_appropriate_device(WLR_INPUT_DEVICE_TABLET_PAD, libinput_dev); if (!wlr_dev) { - wlr_log(WLR_DEBUG, "Got a tablet pad event for a device with no tablet pad?"); + wlr_log(WLR_DEBUG, + "Got a tablet pad event for a device with no tablet pad?"); return; } struct libinput_event_tablet_pad *pevent = @@ -129,7 +131,8 @@ void handle_tablet_pad_ring(struct libinput_event *event, struct wlr_input_device *wlr_dev = get_appropriate_device(WLR_INPUT_DEVICE_TABLET_PAD, libinput_dev); if (!wlr_dev) { - wlr_log(WLR_DEBUG, "Got a tablet pad event for a device with no tablet pad?"); + wlr_log(WLR_DEBUG, + "Got a tablet pad event for a device with no tablet pad?"); return; } struct libinput_event_tablet_pad *pevent = @@ -156,7 +159,8 @@ void handle_tablet_pad_strip(struct libinput_event *event, struct wlr_input_device *wlr_dev = get_appropriate_device(WLR_INPUT_DEVICE_TABLET_PAD, libinput_dev); if (!wlr_dev) { - wlr_log(WLR_DEBUG, "Got a tablet pad event for a device with no tablet pad?"); + wlr_log(WLR_DEBUG, + "Got a tablet pad event for a device with no tablet pad?"); return; } struct libinput_event_tablet_pad *pevent = diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index adfc6221..4e87b700 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -156,7 +156,8 @@ static struct wlr_libinput_tablet_tool *get_wlr_tablet_tool( static void ensure_tool_reference(struct wlr_libinput_tablet_tool *tool, struct wlr_tablet *wlr_dev) { assert(tablet_is_libinput(wlr_dev)); - struct wlr_libinput_tablet *tablet = wl_container_of(wlr_dev, tablet, wlr_tablet); + struct wlr_libinput_tablet *tablet = + wl_container_of(wlr_dev, tablet, wlr_tablet); struct tablet_tool_list_elem *pos; wl_list_for_each(pos, &tablet->tools, link) { @@ -188,7 +189,8 @@ void handle_tablet_tool_axis(struct libinput_event *event, struct wlr_input_device *wlr_dev = get_appropriate_device(WLR_INPUT_DEVICE_TABLET_TOOL, libinput_dev); if (!wlr_dev) { - wlr_log(WLR_DEBUG, "Got a tablet tool event for a device with no tablet tools?"); + wlr_log(WLR_DEBUG, + "Got a tablet tool event for a device with no tablet tools?"); return; } struct libinput_event_tablet_tool *tevent = @@ -248,7 +250,8 @@ void handle_tablet_tool_proximity(struct libinput_event *event, struct wlr_input_device *wlr_dev = get_appropriate_device(WLR_INPUT_DEVICE_TABLET_TOOL, libinput_dev); if (!wlr_dev) { - wlr_log(WLR_DEBUG, "Got a tablet tool event for a device with no tablet tools?"); + wlr_log(WLR_DEBUG, + "Got a tablet tool event for a device with no tablet tools?"); return; } struct libinput_event_tablet_tool *tevent = @@ -272,14 +275,16 @@ void handle_tablet_tool_proximity(struct libinput_event *event, } wlr_signal_emit_safe(&wlr_dev->tablet->events.proximity, &wlr_event); - if (libinput_event_tablet_tool_get_proximity_state(tevent) == LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN) { + if (libinput_event_tablet_tool_get_proximity_state(tevent) == + LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN) { handle_tablet_tool_axis(event, libinput_dev); } // If the tool is not unique, libinput will not find it again after the // proximity out, so we should destroy it if (!tool->unique && - libinput_event_tablet_tool_get_proximity_state(tevent) == LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT) { + libinput_event_tablet_tool_get_proximity_state(tevent) == + LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT) { // The tool isn't unique, it can't be on multiple tablets assert(tool->pad_refs == 1); assert(tablet_is_libinput(wlr_dev->tablet)); @@ -305,7 +310,8 @@ void handle_tablet_tool_tip(struct libinput_event *event, struct wlr_input_device *wlr_dev = get_appropriate_device(WLR_INPUT_DEVICE_TABLET_TOOL, libinput_dev); if (!wlr_dev) { - wlr_log(WLR_DEBUG, "Got a tablet tool event for a device with no tablet tools?"); + wlr_log(WLR_DEBUG, + "Got a tablet tool event for a device with no tablet tools?"); return; } handle_tablet_tool_axis(event, libinput_dev); @@ -336,7 +342,8 @@ void handle_tablet_tool_button(struct libinput_event *event, struct wlr_input_device *wlr_dev = get_appropriate_device(WLR_INPUT_DEVICE_TABLET_TOOL, libinput_dev); if (!wlr_dev) { - wlr_log(WLR_DEBUG, "Got a tablet tool event for a device with no tablet tools?"); + wlr_log(WLR_DEBUG, + "Got a tablet tool event for a device with no tablet tools?"); return; } handle_tablet_tool_axis(event, libinput_dev); diff --git a/backend/multi/backend.c b/backend/multi/backend.c index e0038955..3707fe34 100644 --- a/backend/multi/backend.c +++ b/backend/multi/backend.c @@ -17,8 +17,14 @@ struct subbackend_state { struct wl_list link; }; +static struct wlr_multi_backend *multi_backend_from_backend( + struct wlr_backend *wlr_backend) { + assert(wlr_backend_is_multi(wlr_backend)); + return (struct wlr_multi_backend *)wlr_backend; +} + static bool multi_backend_start(struct wlr_backend *wlr_backend) { - struct wlr_multi_backend *backend = (struct wlr_multi_backend *)wlr_backend; + struct wlr_multi_backend *backend = multi_backend_from_backend(wlr_backend); struct subbackend_state *sub; wl_list_for_each(sub, &backend->backends, link) { if (!wlr_backend_start(sub->backend)) { @@ -38,7 +44,7 @@ static void subbackend_state_destroy(struct subbackend_state *sub) { } static void multi_backend_destroy(struct wlr_backend *wlr_backend) { - struct wlr_multi_backend *backend = (struct wlr_multi_backend *)wlr_backend; + struct wlr_multi_backend *backend = multi_backend_from_backend(wlr_backend); wl_list_remove(&backend->display_destroy.link); @@ -54,7 +60,8 @@ static void multi_backend_destroy(struct wlr_backend *wlr_backend) { static struct wlr_renderer *multi_backend_get_renderer( struct wlr_backend *backend) { - struct wlr_multi_backend *multi = (struct wlr_multi_backend *)backend; + struct wlr_multi_backend *multi = multi_backend_from_backend(backend); + struct subbackend_state *sub; wl_list_for_each(sub, &multi->backends, link) { struct wlr_renderer *rend = wlr_backend_get_renderer(sub->backend); @@ -132,8 +139,7 @@ static struct subbackend_state *multi_backend_get_subbackend(struct wlr_multi_ba bool wlr_multi_backend_add(struct wlr_backend *_multi, struct wlr_backend *backend) { - assert(wlr_backend_is_multi(_multi)); - struct wlr_multi_backend *multi = (struct wlr_multi_backend *)_multi; + struct wlr_multi_backend *multi = multi_backend_from_backend(_multi); if (multi_backend_get_subbackend(multi, backend)) { // already added @@ -174,8 +180,7 @@ bool wlr_multi_backend_add(struct wlr_backend *_multi, void wlr_multi_backend_remove(struct wlr_backend *_multi, struct wlr_backend *backend) { - assert(wlr_backend_is_multi(_multi)); - struct wlr_multi_backend *multi = (struct wlr_multi_backend *)_multi; + struct wlr_multi_backend *multi = multi_backend_from_backend(_multi); struct subbackend_state *sub = multi_backend_get_subbackend(multi, backend); @@ -187,9 +192,7 @@ void wlr_multi_backend_remove(struct wlr_backend *_multi, } struct wlr_session *wlr_multi_get_session(struct wlr_backend *_backend) { - assert(wlr_backend_is_multi(_backend)); - - struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend; + struct wlr_multi_backend *backend = multi_backend_from_backend(_backend); struct subbackend_state *sub; wl_list_for_each(sub, &backend->backends, link) { if (wlr_backend_is_drm(sub->backend)) { @@ -204,3 +207,13 @@ bool wlr_multi_is_empty(struct wlr_backend *_backend) { struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend; return wl_list_length(&backend->backends) < 1; } + +void wlr_multi_for_each_backend(struct wlr_backend *_backend, + void (*callback)(struct wlr_backend *backend, void *data), void *data) { + assert(wlr_backend_is_multi(_backend)); + struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend; + struct subbackend_state *sub; + wl_list_for_each(sub, &backend->backends, link) { + callback(sub->backend, data); + } +} diff --git a/backend/session/direct-freebsd.c b/backend/session/direct-freebsd.c index cecfb0c1..342d0d4e 100644 --- a/backend/session/direct-freebsd.c +++ b/backend/session/direct-freebsd.c @@ -1,3 +1,4 @@ +#include <assert.h> #include <dev/evdev/input.h> #include <errno.h> #include <fcntl.h> @@ -32,8 +33,14 @@ struct direct_session { struct wl_event_source *vt_source; }; +static struct direct_session *direct_session_from_session( + struct wlr_session *base) { + assert(base->impl == &session_direct); + return (struct direct_session *)base; +} + static int direct_session_open(struct wlr_session *base, const char *path) { - struct direct_session *session = wl_container_of(base, session, base); + struct direct_session *session = direct_session_from_session(base); int fd = direct_ipc_open(session->sock, path); if (fd < 0) { @@ -46,7 +53,7 @@ static int direct_session_open(struct wlr_session *base, const char *path) { } static void direct_session_close(struct wlr_session *base, int fd) { - struct direct_session *session = wl_container_of(base, session, base); + struct direct_session *session = direct_session_from_session(base); int ev; struct drm_version dv = {0}; @@ -60,33 +67,43 @@ static void direct_session_close(struct wlr_session *base, int fd) { } static bool direct_change_vt(struct wlr_session *base, unsigned vt) { - struct direct_session *session = wl_container_of(base, session, base); + struct direct_session *session = direct_session_from_session(base); + + // Only seat0 has VTs associated with it + if (strcmp(session->base.seat, "seat0") != 0) { + return true; + } + return ioctl(session->tty_fd, VT_ACTIVATE, (int)vt) == 0; } static void direct_session_destroy(struct wlr_session *base) { - struct direct_session *session = wl_container_of(base, session, base); - struct vt_mode mode = { - .mode = VT_AUTO, - }; + struct direct_session *session = direct_session_from_session(base); - errno = 0; + if (strcmp(session->base.seat, "seat0") == 0) { + struct vt_mode mode = { + .mode = VT_AUTO, + }; - ioctl(session->tty_fd, KDSKBMODE, session->old_kbmode); - ioctl(session->tty_fd, KDSETMODE, KD_TEXT); - ioctl(session->tty_fd, VT_SETMODE, &mode); + errno = 0; - ioctl(session->tty_fd, VT_ACTIVATE, session->old_tty); + ioctl(session->tty_fd, KDSKBMODE, session->old_kbmode); + ioctl(session->tty_fd, KDSETMODE, KD_TEXT); + ioctl(session->tty_fd, VT_SETMODE, &mode); - if (errno) { - wlr_log(WLR_ERROR, "Failed to restore tty"); + ioctl(session->tty_fd, VT_ACTIVATE, session->old_tty); + + if (errno) { + wlr_log(WLR_ERROR, "Failed to restore tty"); + } + + wl_event_source_remove(session->vt_source); + close(session->tty_fd); } direct_ipc_finish(session->sock, session->child); close(session->sock); - wl_event_source_remove(session->vt_source); - close(session->tty_fd); free(session); } @@ -157,7 +174,8 @@ static bool setup_tty(struct direct_session *session, struct wl_display *display } if (ioctl(fd, KDSKBMODE, K_CODE)) { - wlr_log_errno(WLR_ERROR, "Failed to set keyboard mode K_CODE on tty %d", tty); + wlr_log_errno(WLR_ERROR, + "Failed to set keyboard mode K_CODE on tty %d", tty); goto error; } @@ -213,13 +231,23 @@ static struct wlr_session *direct_session_create(struct wl_display *disp) { goto error_session; } - if (!setup_tty(session, disp)) { - goto error_ipc; + const char *seat = getenv("XDG_SEAT"); + if (!seat) { + seat = "seat0"; + } + + if (strcmp(seat, "seat0") == 0) { + if (!setup_tty(session, disp)) { + goto error_ipc; + } + } else { + session->base.vtnr = 0; + session->tty_fd = -1; } wlr_log(WLR_INFO, "Successfully loaded direct session"); - snprintf(session->base.seat, sizeof(session->base.seat), "seat0"); + snprintf(session->base.seat, sizeof(session->base.seat), "%s", seat); session->base.impl = &session_direct; return &session->base; diff --git a/backend/session/direct.c b/backend/session/direct.c index ed7a0c65..0912cd58 100644 --- a/backend/session/direct.c +++ b/backend/session/direct.c @@ -1,4 +1,5 @@ #define _POSIX_C_SOURCE 200809L +#include <assert.h> #include <errno.h> #include <fcntl.h> #include <linux/input.h> @@ -33,8 +34,14 @@ struct direct_session { struct wl_event_source *vt_source; }; +static struct direct_session *direct_session_from_session( + struct wlr_session *base) { + assert(base->impl == &session_direct); + return (struct direct_session *)base; +} + static int direct_session_open(struct wlr_session *base, const char *path) { - struct direct_session *session = wl_container_of(base, session, base); + struct direct_session *session = direct_session_from_session(base); int fd = direct_ipc_open(session->sock, path); if (fd < 0) { @@ -57,7 +64,7 @@ static int direct_session_open(struct wlr_session *base, const char *path) { } static void direct_session_close(struct wlr_session *base, int fd) { - struct direct_session *session = wl_container_of(base, session, base); + struct direct_session *session = direct_session_from_session(base); struct stat st; if (fstat(fd, &st) < 0) { @@ -76,7 +83,7 @@ static void direct_session_close(struct wlr_session *base, int fd) { } static bool direct_change_vt(struct wlr_session *base, unsigned vt) { - struct direct_session *session = wl_container_of(base, session, base); + struct direct_session *session = direct_session_from_session(base); // Only seat0 has VTs associated with it if (strcmp(session->base.seat, "seat0") != 0) { @@ -87,7 +94,7 @@ static bool direct_change_vt(struct wlr_session *base, unsigned vt) { } static void direct_session_destroy(struct wlr_session *base) { - struct direct_session *session = wl_container_of(base, session, base); + struct direct_session *session = direct_session_from_session(base); if (strcmp(session->base.seat, "seat0") == 0) { struct vt_mode mode = { diff --git a/backend/session/logind.c b/backend/session/logind.c index 2f816b95..39143a2f 100644 --- a/backend/session/logind.c +++ b/backend/session/logind.c @@ -37,8 +37,14 @@ struct logind_session { char *path; }; +static struct logind_session *logind_session_from_session( + struct wlr_session *base) { + assert(base->impl == &session_logind); + return (struct logind_session *)base; +} + static int logind_take_device(struct wlr_session *base, const char *path) { - struct logind_session *session = wl_container_of(base, session, base); + struct logind_session *session = logind_session_from_session(base); int ret; int fd = -1; @@ -83,7 +89,7 @@ error: } static void logind_release_device(struct wlr_session *base, int fd) { - struct logind_session *session = wl_container_of(base, session, base); + struct logind_session *session = logind_session_from_session(base); int ret; sd_bus_message *msg = NULL; @@ -108,7 +114,7 @@ static void logind_release_device(struct wlr_session *base, int fd) { } static bool logind_change_vt(struct wlr_session *base, unsigned vt) { - struct logind_session *session = wl_container_of(base, session, base); + struct logind_session *session = logind_session_from_session(base); // Only seat0 has VTs associated with it if (strcmp(session->base.seat, "seat0") != 0) { @@ -212,7 +218,7 @@ static void release_control(struct logind_session *session) { } static void logind_session_destroy(struct wlr_session *base) { - struct logind_session *session = wl_container_of(base, session, base); + struct logind_session *session = logind_session_from_session(base); release_control(session); diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c index 506bcd5e..28f61863 100644 --- a/backend/wayland/backend.c +++ b/backend/wayland/backend.c @@ -15,6 +15,12 @@ #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; +} + static int dispatch_events(int fd, uint32_t mask, void *data) { struct wlr_wl_backend *backend = data; int count = 0; @@ -39,8 +45,8 @@ static int dispatch_events(int fd, uint32_t mask, void *data) { * compositor and creates surfaces for each output, then registers globals on * the specified display. */ -static bool backend_start(struct wlr_backend *_backend) { - struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend; +static bool backend_start(struct wlr_backend *wlr_backend) { + struct wlr_wl_backend *backend = get_wl_backend_from_backend(wlr_backend); wlr_log(WLR_INFO, "Initializating wayland backend"); poll_wl_registry(backend); @@ -66,7 +72,7 @@ static bool backend_start(struct wlr_backend *_backend) { } static void backend_destroy(struct wlr_backend *wlr_backend) { - struct wlr_wl_backend *backend = (struct wlr_wl_backend *)wlr_backend; + struct wlr_wl_backend *backend = get_wl_backend_from_backend(wlr_backend); if (backend == NULL) { return; } @@ -118,7 +124,7 @@ static void backend_destroy(struct wlr_backend *wlr_backend) { static struct wlr_renderer *backend_get_renderer( struct wlr_backend *wlr_backend) { - struct wlr_wl_backend *backend = (struct wlr_wl_backend *)wlr_backend; + struct wlr_wl_backend *backend = get_wl_backend_from_backend(wlr_backend); return backend->renderer; } diff --git a/backend/wayland/output.c b/backend/wayland/output.c index 2fd35a3a..4eb99a3b 100644 --- a/backend/wayland/output.c +++ b/backend/wayland/output.c @@ -15,7 +15,11 @@ #include "util/signal.h" #include "xdg-shell-unstable-v6-client-protocol.h" -int os_create_anonymous_file(off_t size); +static struct wlr_wl_output *get_wl_output_from_output( + struct wlr_output *wlr_output) { + assert(wlr_output_is_wl(wlr_output)); + return (struct wlr_wl_output *)wlr_output; +} static struct wl_callback_listener frame_listener; @@ -33,9 +37,9 @@ static struct wl_callback_listener frame_listener = { .done = surface_frame_callback }; -static bool output_set_custom_mode(struct wlr_output *_output, +static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width, int32_t height, int32_t refresh) { - struct wlr_wl_output *output = (struct wlr_wl_output *)_output; + struct wlr_wl_output *output = get_wl_output_from_output(wlr_output); wl_egl_window_resize(output->egl_window, width, height, 0, 0); wlr_output_update_custom_mode(&output->wlr_output, width, height, 0); return true; @@ -44,7 +48,7 @@ static bool output_set_custom_mode(struct wlr_output *_output, static bool output_make_current(struct wlr_output *wlr_output, int *buffer_age) { struct wlr_wl_output *output = - (struct wlr_wl_output *)wlr_output; + get_wl_output_from_output(wlr_output); return wlr_egl_make_current(&output->backend->egl, output->egl_surface, buffer_age); } @@ -52,7 +56,7 @@ static bool output_make_current(struct wlr_output *wlr_output, static bool output_swap_buffers(struct wlr_output *wlr_output, pixman_region32_t *damage) { struct wlr_wl_output *output = - (struct wlr_wl_output *)wlr_output; + get_wl_output_from_output(wlr_output); if (output->frame_callback != NULL) { wlr_log(WLR_ERROR, "Skipping buffer swap"); @@ -66,21 +70,22 @@ static bool output_swap_buffers(struct wlr_output *wlr_output, damage); } -static void output_transform(struct wlr_output *_output, +static void output_transform(struct wlr_output *wlr_output, enum wl_output_transform transform) { - struct wlr_wl_output *output = (struct wlr_wl_output *)_output; + struct wlr_wl_output *output = get_wl_output_from_output(wlr_output); output->wlr_output.transform = transform; } static bool output_set_cursor(struct wlr_output *wlr_output, struct wlr_texture *texture, int32_t scale, - enum wl_output_transform transform, int32_t hotspot_x, int32_t hotspot_y, - bool update_texture) { - struct wlr_wl_output *output = (struct wlr_wl_output *)wlr_output; + enum wl_output_transform transform, + int32_t hotspot_x, int32_t hotspot_y, bool update_texture) { + struct wlr_wl_output *output = get_wl_output_from_output(wlr_output); struct wlr_wl_backend *backend = output->backend; struct wlr_box hotspot = { .x = hotspot_x, .y = hotspot_y }; - wlr_box_transform(&hotspot, wlr_output_transform_invert(wlr_output->transform), + wlr_box_transform(&hotspot, + wlr_output_transform_invert(wlr_output->transform), output->cursor.width, output->cursor.height, &hotspot); // TODO: use output->wlr_output.transform to transform pixels and hotpot @@ -147,8 +152,7 @@ static bool output_set_cursor(struct wlr_output *wlr_output, } static void output_destroy(struct wlr_output *wlr_output) { - struct wlr_wl_output *output = - (struct wlr_wl_output *)wlr_output; + struct wlr_wl_output *output = get_wl_output_from_output(wlr_output); if (output == NULL) { return; } @@ -215,7 +219,8 @@ static struct zxdg_surface_v6_listener xdg_surface_listener = { .configure = xdg_surface_handle_configure, }; -static void xdg_toplevel_handle_configure(void *data, struct zxdg_toplevel_v6 *xdg_toplevel, +static void xdg_toplevel_handle_configure(void *data, + struct zxdg_toplevel_v6 *xdg_toplevel, int32_t width, int32_t height, struct wl_array *states) { struct wlr_wl_output *output = data; assert(output && output->xdg_toplevel == xdg_toplevel); @@ -228,7 +233,8 @@ static void xdg_toplevel_handle_configure(void *data, struct zxdg_toplevel_v6 *x wlr_output_update_custom_mode(&output->wlr_output, width, height, 0); } -static void xdg_toplevel_handle_close(void *data, struct zxdg_toplevel_v6 *xdg_toplevel) { +static void xdg_toplevel_handle_close(void *data, + struct zxdg_toplevel_v6 *xdg_toplevel) { struct wlr_wl_output *output = data; assert(output && output->xdg_toplevel == xdg_toplevel); @@ -240,9 +246,8 @@ static struct zxdg_toplevel_v6_listener xdg_toplevel_listener = { .close = xdg_toplevel_handle_close, }; -struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) { - assert(wlr_backend_is_wl(_backend)); - struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend; +struct wlr_output *wlr_wl_output_create(struct wlr_backend *wlr_backend) { + struct wlr_wl_backend *backend = get_wl_backend_from_backend(wlr_backend); if (!backend->started) { ++backend->requested_outputs; return NULL; diff --git a/backend/wayland/wl_seat.c b/backend/wayland/wl_seat.c index 8fb4aa5f..562d9431 100644 --- a/backend/wayland/wl_seat.c +++ b/backend/wayland/wl_seat.c @@ -122,11 +122,11 @@ static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer, } static void pointer_handle_frame(void *data, struct wl_pointer *wl_pointer) { - + // This space is intentionally left blank } -static void pointer_handle_axis_source(void *data, struct wl_pointer *wl_pointer, - uint32_t axis_source) { +static void pointer_handle_axis_source(void *data, + struct wl_pointer *wl_pointer, uint32_t axis_source) { struct wlr_wl_backend *backend = data; struct wlr_wl_pointer *pointer = backend->current_pointer; if (pointer == NULL) { @@ -138,11 +138,11 @@ static void pointer_handle_axis_source(void *data, struct wl_pointer *wl_pointer static void pointer_handle_axis_stop(void *data, struct wl_pointer *wl_pointer, uint32_t time, uint32_t axis) { - + // This space is intentionally left blank } -static void pointer_handle_axis_discrete(void *data, struct wl_pointer *wl_pointer, - uint32_t axis, int32_t discrete) { +static void pointer_handle_axis_discrete(void *data, + struct wl_pointer *wl_pointer, uint32_t axis, int32_t discrete) { struct wlr_wl_backend *backend = data; struct wlr_wl_pointer *pointer = backend->current_pointer; if (pointer == NULL) { @@ -239,9 +239,9 @@ static void keyboard_handle_modifiers(void *data, struct wl_keyboard *wl_keyboar mods_locked, group); } -static void keyboard_handle_repeat_info(void *data, struct wl_keyboard *wl_keyboard, - int32_t rate, int32_t delay) { - +static void keyboard_handle_repeat_info(void *data, + struct wl_keyboard *wl_keyboard, int32_t rate, int32_t delay) { + // This space is intentionally left blank } static struct wl_keyboard_listener keyboard_listener = { @@ -253,8 +253,15 @@ static struct wl_keyboard_listener keyboard_listener = { .repeat_info = keyboard_handle_repeat_info }; +static struct wlr_wl_input_device *get_wl_input_device_from_input_device( + struct wlr_input_device *wlr_dev) { + assert(wlr_input_device_is_wl(wlr_dev)); + return (struct wlr_wl_input_device *)wlr_dev; +} + static void input_device_destroy(struct wlr_input_device *wlr_dev) { - struct wlr_wl_input_device *dev = (struct wlr_wl_input_device *)wlr_dev; + struct wlr_wl_input_device *dev = + get_wl_input_device_from_input_device(wlr_dev); if (dev->resource) { wl_proxy_destroy(dev->resource); } @@ -399,7 +406,8 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat, } } -static void seat_handle_name(void *data, struct wl_seat *wl_seat, const char *name) { +static void seat_handle_name(void *data, struct wl_seat *wl_seat, + const char *name) { struct wlr_wl_backend *backend = data; assert(backend->seat == wl_seat); // Do we need to check if seatName was previously set for name change? diff --git a/backend/x11/backend.c b/backend/x11/backend.c index 0ff2925d..7053e2f0 100644 --- a/backend/x11/backend.c +++ b/backend/x11/backend.c @@ -1,4 +1,5 @@ #define _POSIX_C_SOURCE 200112L +#include <assert.h> #include <limits.h> #include <stdbool.h> #include <stdio.h> @@ -22,8 +23,8 @@ #include "backend/x11.h" #include "util/signal.h" -struct wlr_x11_output *get_x11_output_from_window_id(struct wlr_x11_backend *x11, - xcb_window_t window) { +struct wlr_x11_output *get_x11_output_from_window_id( + struct wlr_x11_backend *x11, xcb_window_t window) { struct wlr_x11_output *output; wl_list_for_each(output, &x11->outputs, link) { if (output->win == window) { @@ -88,8 +89,14 @@ static int x11_event(int fd, uint32_t mask, void *data) { return 0; } +struct wlr_x11_backend *get_x11_backend_from_backend( + struct wlr_backend *wlr_backend) { + assert(wlr_backend_is_x11(wlr_backend)); + return (struct wlr_x11_backend *)wlr_backend; +} + static bool backend_start(struct wlr_backend *backend) { - struct wlr_x11_backend *x11 = (struct wlr_x11_backend *)backend; + struct wlr_x11_backend *x11 = get_x11_backend_from_backend(backend); x11->started = true; struct { @@ -183,7 +190,7 @@ static void backend_destroy(struct wlr_backend *backend) { return; } - struct wlr_x11_backend *x11 = (struct wlr_x11_backend *)backend; + struct wlr_x11_backend *x11 = get_x11_backend_from_backend(backend); struct wlr_x11_output *output, *tmp; wl_list_for_each_safe(output, tmp, &x11->outputs, link) { @@ -213,7 +220,7 @@ static void backend_destroy(struct wlr_backend *backend) { static struct wlr_renderer *backend_get_renderer( struct wlr_backend *backend) { - struct wlr_x11_backend *x11 = (struct wlr_x11_backend *)backend; + struct wlr_x11_backend *x11 = get_x11_backend_from_backend(backend); return x11->renderer; } @@ -234,7 +241,8 @@ static void handle_display_destroy(struct wl_listener *listener, void *data) { } struct wlr_backend *wlr_x11_backend_create(struct wl_display *display, - const char *x11_display, wlr_renderer_create_func_t create_renderer_func) { + const char *x11_display, + wlr_renderer_create_func_t create_renderer_func) { struct wlr_x11_backend *x11 = calloc(1, sizeof(*x11)); if (!x11) { return NULL; diff --git a/backend/x11/output.c b/backend/x11/output.c index b678296d..e0210b1a 100644 --- a/backend/x11/output.c +++ b/backend/x11/output.c @@ -15,7 +15,8 @@ static int signal_frame(void *data) { return 0; } -static void parse_xcb_setup(struct wlr_output *output, xcb_connection_t *xcb_conn) { +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); snprintf(output->make, sizeof(output->make), "%.*s", @@ -26,8 +27,14 @@ static void parse_xcb_setup(struct wlr_output *output, xcb_connection_t *xcb_con xcb_setup->protocol_minor_version); } +static struct wlr_x11_output *get_x11_output_from_output( + struct wlr_output *wlr_output) { + assert(wlr_output_is_x11(wlr_output)); + return (struct wlr_x11_output *)wlr_output; +} + static void output_set_refresh(struct wlr_output *wlr_output, int32_t refresh) { - struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output; + struct wlr_x11_output *output = get_x11_output_from_output(wlr_output); if (refresh <= 0) { refresh = X11_DEFAULT_REFRESH; @@ -41,18 +48,20 @@ static void output_set_refresh(struct wlr_output *wlr_output, int32_t refresh) { static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width, int32_t height, int32_t refresh) { - struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output; + struct wlr_x11_output *output = get_x11_output_from_output(wlr_output); struct wlr_x11_backend *x11 = output->x11; output_set_refresh(&output->wlr_output, refresh); const uint32_t values[] = { width, height }; - xcb_void_cookie_t cookie = xcb_configure_window_checked(x11->xcb_conn, output->win, + xcb_void_cookie_t cookie = xcb_configure_window_checked( + x11->xcb_conn, 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))) { - wlr_log(WLR_ERROR, "Could not set window size to %dx%d\n", width, height); + wlr_log(WLR_ERROR, "Could not set window size to %dx%d\n", + width, height); free(error); return false; } @@ -62,12 +71,12 @@ static bool output_set_custom_mode(struct wlr_output *wlr_output, static void output_transform(struct wlr_output *wlr_output, enum wl_output_transform transform) { - struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output; + struct wlr_x11_output *output = get_x11_output_from_output(wlr_output); output->wlr_output.transform = transform; } static void output_destroy(struct wlr_output *wlr_output) { - struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output; + struct wlr_x11_output *output = get_x11_output_from_output(wlr_output); struct wlr_x11_backend *x11 = output->x11; wlr_input_device_destroy(&output->pointer_dev); @@ -80,8 +89,9 @@ static void output_destroy(struct wlr_output *wlr_output) { free(output); } -static bool output_make_current(struct wlr_output *wlr_output, int *buffer_age) { - struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output; +static bool output_make_current(struct wlr_output *wlr_output, + int *buffer_age) { + struct wlr_x11_output *output = get_x11_output_from_output(wlr_output); struct wlr_x11_backend *x11 = output->x11; return wlr_egl_make_current(&x11->egl, output->surf, buffer_age); @@ -104,8 +114,7 @@ static const struct wlr_output_impl output_impl = { }; struct wlr_output *wlr_x11_output_create(struct wlr_backend *backend) { - assert(wlr_backend_is_x11(backend)); - struct wlr_x11_backend *x11 = (struct wlr_x11_backend *)backend; + struct wlr_x11_backend *x11 = get_x11_backend_from_backend(backend); if (!x11->started) { ++x11->requested_outputs; @@ -198,7 +207,8 @@ void handle_x11_configure_notify(struct wlr_x11_output *output, // Move the pointer to its new location update_x11_pointer_position(output, output->x11->time); } else { - wlr_log(WLR_DEBUG,"Ignoring X11 configure event for height=%d, width=%d", + wlr_log(WLR_DEBUG, + "Ignoring X11 configure event for height=%d, width=%d", ev->width, ev->height); } } diff --git a/examples/dmabuf-capture.c b/examples/dmabuf-capture.c index de3567f4..2c510b5a 100644 --- a/examples/dmabuf-capture.c +++ b/examples/dmabuf-capture.c @@ -45,6 +45,7 @@ struct capture_context { /* Target */ struct wl_output *target_output; + bool with_cursor; /* Main frame callback */ struct zwlr_export_dmabuf_frame_v1 *frame_callback; @@ -454,7 +455,7 @@ static const struct zwlr_export_dmabuf_frame_v1_listener frame_listener = { static void register_cb(struct capture_context *ctx) { ctx->frame_callback = zwlr_export_dmabuf_manager_v1_capture_output( - ctx->export_manager, 0, ctx->target_output); + ctx->export_manager, ctx->with_cursor, ctx->target_output); zwlr_export_dmabuf_frame_v1_add_listener(ctx->frame_callback, &frame_listener, ctx); @@ -802,6 +803,7 @@ int main(int argc, char *argv[]) { } ctx.target_output = o->output; + ctx.with_cursor = true; ctx.hw_device_type = av_hwdevice_find_type_by_name(argv[2]); ctx.hardware_device = argv[3]; diff --git a/examples/layer-shell.c b/examples/layer-shell.c index f56825c3..114b98f6 100644 --- a/examples/layer-shell.c +++ b/examples/layer-shell.c @@ -596,10 +596,16 @@ int main(int argc, char **argv) { assert(cursor_theme); struct wl_cursor *cursor = wl_cursor_theme_get_cursor(cursor_theme, "crosshair"); + if (cursor == NULL) { + cursor = wl_cursor_theme_get_cursor(cursor_theme, "left_ptr"); + } assert(cursor); cursor_image = cursor->images[0]; cursor = wl_cursor_theme_get_cursor(cursor_theme, "tcross"); + if (cursor == NULL) { + cursor = wl_cursor_theme_get_cursor(cursor_theme, "left_ptr"); + } assert(cursor); popup_cursor_image = cursor->images[0]; diff --git a/include/backend/drm/drm.h b/include/backend/drm/drm.h index 6fe031e2..ac23cd9a 100644 --- a/include/backend/drm/drm.h +++ b/include/backend/drm/drm.h @@ -138,6 +138,8 @@ struct wlr_drm_connector { struct wl_list link; }; +struct wlr_drm_backend *get_drm_backend_from_backend( + struct wlr_backend *wlr_backend); bool check_drm_features(struct wlr_drm_backend *drm); bool init_drm_resources(struct wlr_drm_backend *drm); void finish_drm_resources(struct wlr_drm_backend *drm); diff --git a/include/backend/headless.h b/include/backend/headless.h index add4c4e8..35280862 100644 --- a/include/backend/headless.h +++ b/include/backend/headless.h @@ -34,4 +34,7 @@ struct wlr_headless_input_device { struct wlr_headless_backend *backend; }; +struct wlr_headless_backend *headless_backend_from_backend( + struct wlr_backend *wlr_backend); + #endif diff --git a/include/backend/libinput.h b/include/backend/libinput.h index d1fb3a44..9531091f 100644 --- a/include/backend/libinput.h +++ b/include/backend/libinput.h @@ -4,6 +4,7 @@ #include <libinput.h> #include <wayland-server-core.h> #include <wlr/backend/interface.h> +#include <wlr/backend/libinput.h> #include <wlr/interfaces/wlr_input_device.h> #include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_list.h> diff --git a/include/backend/wayland.h b/include/backend/wayland.h index 46f18c84..47585d9e 100644 --- a/include/backend/wayland.h +++ b/include/backend/wayland.h @@ -78,6 +78,8 @@ 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); void update_wl_output_cursor(struct wlr_wl_output *output); struct wlr_wl_pointer *pointer_get_wl(struct wlr_pointer *wlr_pointer); diff --git a/include/backend/x11.h b/include/backend/x11.h index f5557343..38aaad50 100644 --- a/include/backend/x11.h +++ b/include/backend/x11.h @@ -72,8 +72,10 @@ struct wlr_x11_backend { struct wl_listener display_destroy; }; -struct wlr_x11_output *get_x11_output_from_window_id(struct wlr_x11_backend *x11, - xcb_window_t window); +struct wlr_x11_backend *get_x11_backend_from_backend( + struct wlr_backend *wlr_backend); +struct wlr_x11_output *get_x11_output_from_window_id( + struct wlr_x11_backend *x11, xcb_window_t window); extern const struct wlr_keyboard_impl keyboard_impl; extern const struct wlr_pointer_impl pointer_impl; diff --git a/include/wlr/backend/multi.h b/include/wlr/backend/multi.h index 7137b075..ef908d26 100644 --- a/include/wlr/backend/multi.h +++ b/include/wlr/backend/multi.h @@ -31,4 +31,7 @@ bool wlr_backend_is_multi(struct wlr_backend *backend); struct wlr_session *wlr_multi_get_session(struct wlr_backend *base); bool wlr_multi_is_empty(struct wlr_backend *backend); +void wlr_multi_for_each_backend(struct wlr_backend *backend, + void (*callback)(struct wlr_backend *backend, void *data), void *data); + #endif diff --git a/include/wlr/types/wlr_export_dmabuf_v1.h b/include/wlr/types/wlr_export_dmabuf_v1.h index 56767540..8669574d 100644 --- a/include/wlr/types/wlr_export_dmabuf_v1.h +++ b/include/wlr/types/wlr_export_dmabuf_v1.h @@ -9,6 +9,7 @@ #ifndef WLR_TYPES_WLR_EXPORT_DMABUF_V1_H #define WLR_TYPES_WLR_EXPORT_DMABUF_V1_H +#include <stdbool.h> #include <wayland-server.h> #include <wlr/render/dmabuf.h> @@ -22,6 +23,8 @@ struct wlr_export_dmabuf_frame_v1 { struct wlr_dmabuf_attributes attribs; struct wlr_output *output; + bool cursor_locked; + struct wl_listener output_swap_buffers; }; diff --git a/include/wlr/types/wlr_keyboard.h b/include/wlr/types/wlr_keyboard.h index 3e207523..ae279541 100644 --- a/include/wlr/types/wlr_keyboard.h +++ b/include/wlr/types/wlr_keyboard.h @@ -50,7 +50,7 @@ struct wlr_keyboard_modifiers { struct wlr_keyboard { const struct wlr_keyboard_impl *impl; - int keymap_fd; + char *keymap_string; size_t keymap_size; struct xkb_keymap *keymap; struct xkb_state *xkb_state; diff --git a/include/wlr/types/wlr_output.h b/include/wlr/types/wlr_output.h index ded57959..ecd4f759 100644 --- a/include/wlr/types/wlr_output.h +++ b/include/wlr/types/wlr_output.h @@ -107,6 +107,7 @@ struct wlr_output { struct wl_list cursors; // wlr_output_cursor::link struct wlr_output_cursor *hardware_cursor; + int software_cursor_locks; // number of locks forcing software cursors // the output position in layout space reported to clients int32_t lx, ly; @@ -196,6 +197,14 @@ bool wlr_output_export_dmabuf(struct wlr_output *output, 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. + * This is useful if hardware cursors need to be temporarily disabled (e.g. + * during screen capture). There must be as many unlocks as there have been + * locks to restore the original state. There should never be an unlock before + * a lock. + */ +void wlr_output_lock_software_cursors(struct wlr_output *output, bool lock); struct wlr_output_cursor *wlr_output_cursor_create(struct wlr_output *output); diff --git a/include/wlr/types/wlr_screencopy_v1.h b/include/wlr/types/wlr_screencopy_v1.h index aba32a45..c7197bab 100644 --- a/include/wlr/types/wlr_screencopy_v1.h +++ b/include/wlr/types/wlr_screencopy_v1.h @@ -9,6 +9,7 @@ #ifndef WLR_TYPES_WLR_SCREENCOPY_V1_H #define WLR_TYPES_WLR_SCREENCOPY_V1_H +#include <stdbool.h> #include <wayland-server.h> #include <wlr/types/wlr_box.h> @@ -35,6 +36,8 @@ struct wlr_screencopy_frame_v1 { struct wlr_box box; int stride; + bool overlay_cursor, cursor_locked; + struct wl_shm_buffer *buffer; struct wl_listener buffer_destroy; diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h index eb5d6985..8247aa15 100644 --- a/include/wlr/xwayland.h +++ b/include/wlr/xwayland.h @@ -163,6 +163,7 @@ struct wlr_xwayland_surface { struct wl_signal set_pid; struct wl_signal set_window_type; struct wl_signal set_hints; + struct wl_signal set_decorations; struct wl_signal set_override_redirect; struct wl_signal ping_timeout; } events; diff --git a/protocol/meson.build b/protocol/meson.build index a02ca5f5..e03b88e8 100644 --- a/protocol/meson.build +++ b/protocol/meson.build @@ -79,7 +79,7 @@ endforeach lib_wl_protos = static_library( 'wl_protos', wl_protos_src + wl_protos_headers, - dependencies: wayland_client.partial_dependency(includes: true), + dependencies: wayland_client.partial_dependency(compile_args: true), ) wlr_protos = declare_dependency( diff --git a/types/seat/wlr_seat_keyboard.c b/types/seat/wlr_seat_keyboard.c index e8ea300e..0400db14 100644 --- a/types/seat/wlr_seat_keyboard.c +++ b/types/seat/wlr_seat_keyboard.c @@ -3,6 +3,8 @@ #include <stdlib.h> #include <string.h> #include <time.h> +#include <sys/mman.h> +#include <unistd.h> #include <wayland-server.h> #include <wlr/types/wlr_data_device.h> #include <wlr/types/wlr_input_device.h> @@ -10,6 +12,7 @@ #include <wlr/util/log.h> #include "types/wlr_seat.h" #include "util/signal.h" +#include "util/os-compatibility.h" static void default_keyboard_enter(struct wlr_seat_keyboard_grab *grab, struct wlr_surface *surface, uint32_t keycodes[], size_t num_keycodes, @@ -338,9 +341,28 @@ static void seat_client_send_keymap(struct wlr_seat_client *client, continue; } + int keymap_fd = os_create_anonymous_file(keyboard->keymap_size); + if (keymap_fd < 0) { + wlr_log(WLR_ERROR, "creating a keymap file for %zu bytes failed", keyboard->keymap_size); + continue; + } + + void *ptr = mmap(NULL, keyboard->keymap_size, PROT_READ | PROT_WRITE, + MAP_SHARED, keymap_fd, 0); + if (ptr == MAP_FAILED) { + wlr_log(WLR_ERROR, "failed to mmap() %zu bytes", keyboard->keymap_size); + close(keymap_fd); + continue; + } + + strcpy(ptr, keyboard->keymap_string); + munmap(ptr, keyboard->keymap_size); + wl_keyboard_send_keymap(resource, - WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1, keyboard->keymap_fd, + WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1, keymap_fd, keyboard->keymap_size); + + close(keymap_fd); } } diff --git a/types/wlr_buffer.c b/types/wlr_buffer.c index 55ed4792..ce733f40 100644 --- a/types/wlr_buffer.c +++ b/types/wlr_buffer.c @@ -87,6 +87,10 @@ struct wlr_buffer *wlr_buffer_create(struct wlr_renderer *renderer, // the buffer yet. } else { wlr_log(WLR_ERROR, "Cannot upload texture: unknown buffer type"); + + // Instead of just logging the error, also disconnect the client with a + // fatal protocol error so that it's clear something went wrong. + wl_resource_post_error(resource, 0, "unknown buffer type"); return NULL; } diff --git a/types/wlr_export_dmabuf_v1.c b/types/wlr_export_dmabuf_v1.c index 72c9bcec..85ccf1eb 100644 --- a/types/wlr_export_dmabuf_v1.c +++ b/types/wlr_export_dmabuf_v1.c @@ -29,14 +29,26 @@ static const struct zwlr_export_dmabuf_frame_v1_interface frame_impl = { .destroy = frame_handle_destroy, }; -static void frame_handle_resource_destroy(struct wl_resource *resource) { - struct wlr_export_dmabuf_frame_v1 *frame = frame_from_resource(resource); +static void frame_destroy(struct wlr_export_dmabuf_frame_v1 *frame) { + if (frame == NULL) { + return; + } + if (frame->cursor_locked) { + wlr_output_lock_software_cursors(frame->output, false); + } wl_list_remove(&frame->link); wl_list_remove(&frame->output_swap_buffers.link); wlr_dmabuf_attributes_finish(&frame->attribs); + // Make the frame resource inert + wl_resource_set_user_data(frame->resource, NULL); free(frame); } +static void frame_handle_resource_destroy(struct wl_resource *resource) { + struct wlr_export_dmabuf_frame_v1 *frame = frame_from_resource(resource); + frame_destroy(frame); +} + static void frame_output_handle_swap_buffers(struct wl_listener *listener, void *data) { struct wlr_export_dmabuf_frame_v1 *frame = @@ -51,6 +63,7 @@ static void frame_output_handle_swap_buffers(struct wl_listener *listener, uint32_t tv_sec_lo = tv_sec & 0xFFFFFFFF; zwlr_export_dmabuf_frame_v1_send_ready(frame->resource, tv_sec_hi, tv_sec_lo, event->when->tv_nsec); + frame_destroy(frame); } @@ -96,6 +109,7 @@ static void manager_handle_capture_output(struct wl_client *client, if (!output->impl->export_dmabuf) { zwlr_export_dmabuf_frame_v1_send_cancel(frame->resource, ZWLR_EXPORT_DMABUF_FRAME_V1_CANCEL_REASON_PERMANENT); + frame_destroy(frame); return; } @@ -103,9 +117,15 @@ static void manager_handle_capture_output(struct wl_client *client, if (!wlr_output_export_dmabuf(output, attribs)) { zwlr_export_dmabuf_frame_v1_send_cancel(frame->resource, ZWLR_EXPORT_DMABUF_FRAME_V1_CANCEL_REASON_TEMPORARY); + frame_destroy(frame); return; } + if (overlay_cursor) { + wlr_output_lock_software_cursors(frame->output, true); + frame->cursor_locked = true; + } + uint32_t frame_flags = ZWLR_EXPORT_DMABUF_FRAME_V1_FLAGS_TRANSIENT; uint32_t mod_high = attribs->modifier >> 32; uint32_t mod_low = attribs->modifier & 0xFFFFFFFF; diff --git a/types/wlr_keyboard.c b/types/wlr_keyboard.c index 3a4f5f67..89c7ca50 100644 --- a/types/wlr_keyboard.c +++ b/types/wlr_keyboard.c @@ -2,16 +2,12 @@ #include <assert.h> #include <stdlib.h> #include <string.h> -#include <sys/mman.h> -#include <unistd.h> #include <wayland-server.h> #include <wlr/interfaces/wlr_keyboard.h> #include <wlr/types/wlr_keyboard.h> #include <wlr/util/log.h> #include "util/signal.h" -int os_create_anonymous_file(off_t size); - static void keyboard_led_update(struct wlr_keyboard *keyboard) { if (keyboard->xkb_state == NULL) { return; @@ -126,7 +122,6 @@ void wlr_keyboard_init(struct wlr_keyboard *kb, wl_signal_init(&kb->events.modifiers); wl_signal_init(&kb->events.keymap); wl_signal_init(&kb->events.repeat_info); - kb->keymap_fd = -1; // Sane defaults kb->repeat_info.rate = 25; @@ -139,9 +134,7 @@ void wlr_keyboard_destroy(struct wlr_keyboard *kb) { } xkb_state_unref(kb->xkb_state); xkb_keymap_unref(kb->keymap); - if (kb->keymap_fd >= 0) { - close(kb->keymap_fd); - } + free(kb->keymap_string); if (kb->impl && kb->impl->destroy) { kb->impl->destroy(kb); } else { @@ -158,8 +151,6 @@ void wlr_keyboard_led_update(struct wlr_keyboard *kb, uint32_t leds) { void wlr_keyboard_set_keymap(struct wlr_keyboard *kb, struct xkb_keymap *keymap) { - char *keymap_str = NULL; - xkb_keymap_unref(kb->keymap); kb->keymap = xkb_keymap_ref(keymap); @@ -194,26 +185,15 @@ void wlr_keyboard_set_keymap(struct wlr_keyboard *kb, kb->mod_indexes[i] = xkb_map_mod_get_index(kb->keymap, mod_names[i]); } - keymap_str = xkb_keymap_get_as_string(kb->keymap, + char *tmp_keymap_string = xkb_keymap_get_as_string(kb->keymap, XKB_KEYMAP_FORMAT_TEXT_V1); - kb->keymap_size = strlen(keymap_str) + 1; - if (kb->keymap_fd >= 0) { - close(kb->keymap_fd); - } - kb->keymap_fd = os_create_anonymous_file(kb->keymap_size); - if (kb->keymap_fd < 0) { - wlr_log(WLR_ERROR, "creating a keymap file for %zu bytes failed", kb->keymap_size); + if (tmp_keymap_string == NULL) { + wlr_log(WLR_ERROR, "Failed to get string version of keymap"); goto err; } - void *ptr = mmap(NULL, kb->keymap_size, - PROT_READ | PROT_WRITE, MAP_SHARED, kb->keymap_fd, 0); - if (ptr == (void*)-1) { - wlr_log(WLR_ERROR, "failed to mmap() %zu bytes", kb->keymap_size); - goto err; - } - strcpy(ptr, keymap_str); - free(keymap_str); - munmap(ptr, kb->keymap_size); + free(kb->keymap_string); + kb->keymap_string = tmp_keymap_string; + kb->keymap_size = strlen(kb->keymap_string) + 1; for (size_t i = 0; i < kb->num_keycodes; ++i) { xkb_keycode_t keycode = kb->keycodes[i] + 8; @@ -230,11 +210,8 @@ err: kb->xkb_state = NULL; xkb_keymap_unref(keymap); kb->keymap = NULL; - if (kb->keymap_fd >= 0) { - close(kb->keymap_fd); - kb->keymap_fd = -1; - } - free(keymap_str); + free(kb->keymap_string); + kb->keymap_string = NULL; } void wlr_keyboard_set_repeat_info(struct wlr_keyboard *kb, int32_t rate, diff --git a/types/wlr_output.c b/types/wlr_output.c index 4e564534..62fd9fb7 100644 --- a/types/wlr_output.c +++ b/types/wlr_output.c @@ -273,6 +273,13 @@ void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend, wl_signal_init(&output->events.destroy); pixman_region32_init(&output->damage); + const char *no_hardware_cursors = getenv("WLR_NO_HARDWARE_CURSORS"); + if (no_hardware_cursors != NULL && strcmp(no_hardware_cursors, "1") == 0) { + wlr_log(WLR_DEBUG, + "WLR_NO_HARDWARE_CURSORS set, forcing software cursors"); + output->software_cursor_locks = 1; + } + output->display_destroy.notify = handle_display_destroy; wl_display_add_destroy_listener(display, &output->display_destroy); @@ -469,13 +476,6 @@ bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when, output->idle_frame = NULL; } - struct wlr_output_event_swap_buffers event = { - .output = output, - .when = when, - .damage = damage, - }; - wlr_signal_emit_safe(&output->events.swap_buffers, &event); - int width, height; wlr_output_transformed_resolution(output, &width, &height); @@ -510,6 +510,13 @@ bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when, } } + struct wlr_output_event_swap_buffers event = { + .output = output, + .when = when, + .damage = damage, + }; + wlr_signal_emit_safe(&output->events.swap_buffers, &event); + // Transform damage into renderer coordinates, ie. upside down enum wl_output_transform transform = wlr_output_transform_compose( wlr_output_transform_invert(output->transform), @@ -666,6 +673,32 @@ struct wlr_output *wlr_output_from_resource(struct wl_resource *resource) { return wl_resource_get_user_data(resource); } +static void output_cursor_damage_whole(struct wlr_output_cursor *cursor); + +void wlr_output_lock_software_cursors(struct wlr_output *output, bool lock) { + if (lock) { + ++output->software_cursor_locks; + } else { + assert(output->software_cursor_locks > 0); + --output->software_cursor_locks; + } + wlr_log(WLR_DEBUG, "%s hardware cursors on output '%s' (locks: %d)", + lock ? "Disabling" : "Enabling", output->name, + output->software_cursor_locks); + + if (output->software_cursor_locks > 0 && output->hardware_cursor != NULL) { + assert(output->impl->set_cursor); + output->impl->set_cursor(output, NULL, 1, + WL_OUTPUT_TRANSFORM_NORMAL, 0, 0, true); + output_cursor_damage_whole(output->hardware_cursor); + output->hardware_cursor = NULL; + } + + // If it's possible to use hardware cursors again, don't switch immediately + // since a recorder is likely to lock software cursors for the next frame + // again. +} + static void output_cursor_damage_whole(struct wlr_output_cursor *cursor) { struct wlr_box box; @@ -721,10 +754,7 @@ static bool output_cursor_attempt_hardware(struct wlr_output_cursor *cursor) { transform = cursor->surface->current.transform; } - const char *no_hardware_cursors = getenv("WLR_NO_HARDWARE_CURSORS"); - if (no_hardware_cursors != NULL && strcmp(no_hardware_cursors, "1") == 0) { - wlr_log(WLR_DEBUG, - "WLR_NO_HARDWARE_CURSORS set, forcing software cursors"); + if (cursor->output->software_cursor_locks > 0) { return false; } diff --git a/types/wlr_screencopy_v1.c b/types/wlr_screencopy_v1.c index 4f044eba..0819e48d 100644 --- a/types/wlr_screencopy_v1.c +++ b/types/wlr_screencopy_v1.c @@ -22,6 +22,9 @@ static void frame_destroy(struct wlr_screencopy_frame_v1 *frame) { if (frame == NULL) { return; } + if (frame->cursor_locked) { + wlr_output_lock_software_cursors(frame->output, false); + } wl_list_remove(&frame->link); wl_list_remove(&frame->output_swap_buffers.link); wl_list_remove(&frame->buffer_destroy.link); @@ -133,6 +136,11 @@ static void frame_handle_copy(struct wl_client *client, // Schedule a buffer swap output->needs_swap = true; wlr_output_schedule_frame(output); + + if (frame->overlay_cursor) { + wlr_output_lock_software_cursors(output, true); + frame->cursor_locked = true; + } } static void frame_handle_destroy(struct wl_client *client, @@ -189,6 +197,7 @@ static void capture_output(struct wl_client *client, } frame->manager = manager; frame->output = output; + frame->overlay_cursor = !!overlay_cursor; frame->resource = wl_resource_create(client, &zwlr_screencopy_frame_v1_interface, version, id); diff --git a/xwayland/xwm.c b/xwayland/xwm.c index 9c803543..c05c650d 100644 --- a/xwayland/xwm.c +++ b/xwayland/xwm.c @@ -159,6 +159,7 @@ static struct wlr_xwayland_surface *xwayland_surface_create( wl_signal_init(&surface->events.set_pid); wl_signal_init(&surface->events.set_window_type); wl_signal_init(&surface->events.set_hints); + wl_signal_init(&surface->events.set_decorations); wl_signal_init(&surface->events.set_override_redirect); wl_signal_init(&surface->events.ping_timeout); @@ -594,6 +595,7 @@ static void read_surface_motif_hints(struct wlr_xwm *xwm, WLR_XWAYLAND_SURFACE_DECORATIONS_NO_TITLE; } } + wlr_signal_emit_safe(&xsurface->events.set_decorations, xsurface); } wlr_log(WLR_DEBUG, "MOTIF_WM_HINTS (%d)", reply->value_len); |