diff options
143 files changed, 900 insertions, 944 deletions
diff --git a/backend/backend.c b/backend/backend.c index 98b94c5c..c67be617 100644 --- a/backend/backend.c +++ b/backend/backend.c @@ -1,17 +1,17 @@ -#include <wayland-server.h> -#include <unistd.h> -#include <stdlib.h> -#include <string.h> -#include <errno.h> #include <assert.h> +#include <errno.h> #include <libinput.h> -#include <wlr/backend/session.h> -#include <wlr/backend/interface.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <wayland-server.h> #include <wlr/backend/drm.h> +#include <wlr/backend/interface.h> #include <wlr/backend/libinput.h> +#include <wlr/backend/multi.h> +#include <wlr/backend/session.h> #include <wlr/backend/wayland.h> #include <wlr/backend/x11.h> -#include <wlr/backend/multi.h> #include <wlr/util/log.h> void wlr_backend_init(struct wlr_backend *backend, @@ -19,10 +19,8 @@ void wlr_backend_init(struct wlr_backend *backend, assert(backend); backend->impl = impl; wl_signal_init(&backend->events.destroy); - wl_signal_init(&backend->events.input_add); - wl_signal_init(&backend->events.input_remove); - wl_signal_init(&backend->events.output_add); - wl_signal_init(&backend->events.output_remove); + wl_signal_init(&backend->events.new_input); + wl_signal_init(&backend->events.new_output); } bool wlr_backend_start(struct wlr_backend *backend) { diff --git a/backend/drm/atomic.c b/backend/drm/atomic.c index 526b2731..29b5ccb1 100644 --- a/backend/drm/atomic.c +++ b/backend/drm/atomic.c @@ -1,8 +1,8 @@ -#include <stdlib.h> #include <gbm.h> +#include <stdlib.h> +#include <wlr/util/log.h> #include <xf86drm.h> #include <xf86drmMode.h> -#include <wlr/util/log.h> #include "backend/drm/drm.h" #include "backend/drm/iface.h" #include "backend/drm/util.h" diff --git a/backend/drm/backend.c b/backend/drm/backend.c index 3782817c..47dff227 100644 --- a/backend/drm/backend.c +++ b/backend/drm/backend.c @@ -1,18 +1,19 @@ -#include <unistd.h> -#include <stdlib.h> +#include <assert.h> +#include <errno.h> #include <stdio.h> +#include <stdlib.h> #include <string.h> -#include <errno.h> -#include <assert.h> +#include <unistd.h> #include <wayland-server.h> -#include <xf86drm.h> -#include <wlr/backend/session.h> #include <wlr/backend/interface.h> +#include <wlr/backend/session.h> #include <wlr/interfaces/wlr_output.h> +#include <wlr/render/egl.h> #include <wlr/types/wlr_list.h> #include <wlr/util/log.h> -#include <wlr/render/egl.h> +#include <xf86drm.h> #include "backend/drm/drm.h" +#include "util/signal.h" static bool wlr_drm_backend_start(struct wlr_backend *backend) { struct wlr_drm_backend *drm = (struct wlr_drm_backend *)backend; @@ -34,7 +35,7 @@ static void wlr_drm_backend_destroy(struct wlr_backend *backend) { wlr_output_destroy(&conn->output); } - wl_signal_emit(&backend->events.destroy, backend); + wlr_signal_emit_safe(&backend->events.destroy, backend); wl_list_remove(&drm->display_destroy.link); wl_list_remove(&drm->session_signal.link); diff --git a/backend/drm/drm.c b/backend/drm/drm.c index 56a78851..e60b7e1c 100644 --- a/backend/drm/drm.c +++ b/backend/drm/drm.c @@ -1,29 +1,30 @@ #include <assert.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include <inttypes.h> -#include <errno.h> -#include <time.h> -#include <xf86drm.h> -#include <xf86drmMode.h> #include <drm_mode.h> #include <EGL/egl.h> #include <EGL/eglext.h> +#include <errno.h> #include <gbm.h> #include <GLES2/gl2.h> #include <GLES2/gl2ext.h> +#include <inttypes.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> #include <wayland-server.h> #include <wayland-util.h> #include <wlr/backend/interface.h> #include <wlr/interfaces/wlr_output.h> -#include <wlr/util/log.h> -#include <wlr/render/matrix.h> -#include <wlr/render/gles2.h> #include <wlr/render.h> +#include <wlr/render/gles2.h> +#include <wlr/render/matrix.h> +#include <wlr/util/log.h> +#include <xf86drm.h> +#include <xf86drmMode.h> #include "backend/drm/drm.h" #include "backend/drm/iface.h" #include "backend/drm/util.h" +#include "util/signal.h" bool wlr_drm_check_features(struct wlr_drm_backend *drm) { if (drmSetClientCap(drm->fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1)) { @@ -870,7 +871,8 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) { wlr_conn->state = WLR_DRM_CONN_NEEDS_MODESET; wlr_log(L_INFO, "Sending modesetting signal for '%s'", wlr_conn->output.name); - wl_signal_emit(&drm->backend.events.output_add, &wlr_conn->output); + wlr_signal_emit_safe(&drm->backend.events.new_output, + &wlr_conn->output); } else if (wlr_conn->state == WLR_DRM_CONN_CONNECTED && drm_conn->connection != DRM_MODE_CONNECTED) { wlr_log(L_INFO, "'%s' disconnected", wlr_conn->output.name); @@ -978,8 +980,6 @@ void wlr_drm_connector_cleanup(struct wlr_drm_connector *conn) { return; } - struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend; - switch (conn->state) { case WLR_DRM_CONN_CONNECTED: case WLR_DRM_CONN_CLEANUP:; @@ -1013,8 +1013,8 @@ void wlr_drm_connector_cleanup(struct wlr_drm_connector *conn) { /* Fallthrough */ case WLR_DRM_CONN_NEEDS_MODESET: wlr_log(L_INFO, "Emitting destruction signal for '%s'", - conn->output.name); - wl_signal_emit(&drm->backend.events.output_remove, &conn->output); + conn->output.name); + wlr_signal_emit_safe(&conn->output.events.destroy, &conn->output); break; case WLR_DRM_CONN_DISCONNECTED: break; diff --git a/backend/drm/legacy.c b/backend/drm/legacy.c index eec8c642..88a01b89 100644 --- a/backend/drm/legacy.c +++ b/backend/drm/legacy.c @@ -1,7 +1,7 @@ #include <gbm.h> +#include <wlr/util/log.h> #include <xf86drm.h> #include <xf86drmMode.h> -#include <wlr/util/log.h> #include "backend/drm/drm.h" #include "backend/drm/iface.h" #include "backend/drm/util.h" diff --git a/backend/drm/properties.c b/backend/drm/properties.c index 153e845e..3d35beb5 100644 --- a/backend/drm/properties.c +++ b/backend/drm/properties.c @@ -2,9 +2,9 @@ #include <stddef.h> #include <stdint.h> #include <stdlib.h> +#include <wlr/util/log.h> #include <xf86drm.h> #include <xf86drmMode.h> -#include <wlr/util/log.h> #include "backend/drm/properties.h" /* diff --git a/backend/drm/renderer.c b/backend/drm/renderer.c index 80d3bd9a..f3e570f7 100644 --- a/backend/drm/renderer.c +++ b/backend/drm/renderer.c @@ -1,18 +1,16 @@ +#include <EGL/egl.h> +#include <EGL/eglext.h> +#include <gbm.h> +#include <GLES2/gl2.h> #include <stdbool.h> #include <stdlib.h> #include <unistd.h> - -#include <gbm.h> -#include <GLES2/gl2.h> -#include <EGL/egl.h> -#include <EGL/eglext.h> #include <wayland-util.h> - -#include <wlr/util/log.h> +#include <wlr/render.h> #include <wlr/render/egl.h> -#include <wlr/render/matrix.h> #include <wlr/render/gles2.h> -#include <wlr/render.h> +#include <wlr/render/matrix.h> +#include <wlr/util/log.h> #include "backend/drm/drm.h" #include "glapi.h" diff --git a/backend/drm/util.c b/backend/drm/util.c index 37d99aa8..41ba47d1 100644 --- a/backend/drm/util.c +++ b/backend/drm/util.c @@ -1,10 +1,10 @@ -#include <stdio.h> -#include <string.h> -#include <drm.h> #include <drm_mode.h> +#include <drm.h> #include <gbm.h> -#include "backend/drm/util.h" +#include <stdio.h> +#include <string.h> #include <wlr/util/log.h> +#include "backend/drm/util.h" int32_t calculate_refresh_rate(drmModeModeInfo *mode) { int32_t refresh = (mode->clock * 1000000LL / mode->htotal + diff --git a/backend/headless/backend.c b/backend/headless/backend.c index 0bf5ec28..663bc13b 100644 --- a/backend/headless/backend.c +++ b/backend/headless/backend.c @@ -1,9 +1,10 @@ +#include "util/signal.h" #include <stdlib.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 <wlr/interfaces/wlr_output.h> -#include <wlr/interfaces/wlr_input_device.h> #include "backend/headless.h" #include "glapi.h" @@ -16,14 +17,14 @@ static bool backend_start(struct wlr_backend *wlr_backend) { wl_list_for_each(output, &backend->outputs, link) { wl_event_source_timer_update(output->frame_timer, output->frame_delay); wlr_output_update_enabled(&output->wlr_output, true); - wl_signal_emit(&backend->backend.events.output_add, + wlr_signal_emit_safe(&backend->backend.events.new_output, &output->wlr_output); } struct wlr_headless_input_device *input_device; wl_list_for_each(input_device, &backend->input_devices, wlr_input_device.link) { - wl_signal_emit(&backend->backend.events.input_add, + wlr_signal_emit_safe(&backend->backend.events.new_input, &input_device->wlr_input_device); } @@ -51,7 +52,7 @@ static void backend_destroy(struct wlr_backend *wlr_backend) { wlr_input_device_destroy(&input_device->wlr_input_device); } - wl_signal_emit(&wlr_backend->events.destroy, backend); + wlr_signal_emit_safe(&wlr_backend->events.destroy, backend); wlr_egl_finish(&backend->egl); free(backend); diff --git a/backend/headless/input_device.c b/backend/headless/input_device.c index 5c62e87f..ea335aff 100644 --- a/backend/headless/input_device.c +++ b/backend/headless/input_device.c @@ -1,17 +1,17 @@ #include <stdlib.h> #include <wlr/interfaces/wlr_input_device.h> -#include <wlr/interfaces/wlr_pointer.h> #include <wlr/interfaces/wlr_keyboard.h> -#include <wlr/interfaces/wlr_touch.h> -#include <wlr/interfaces/wlr_tablet_tool.h> +#include <wlr/interfaces/wlr_pointer.h> #include <wlr/interfaces/wlr_tablet_pad.h> +#include <wlr/interfaces/wlr_tablet_tool.h> +#include <wlr/interfaces/wlr_touch.h> #include <wlr/util/log.h> #include "backend/headless.h" +#include "util/signal.h" static void input_device_destroy(struct wlr_input_device *wlr_dev) { struct wlr_headless_input_device *device = (struct wlr_headless_input_device *)wlr_dev; - wl_signal_emit(&device->backend->backend.events.input_remove, wlr_dev); free(device); } @@ -88,7 +88,7 @@ struct wlr_input_device *wlr_headless_add_input_device( wl_list_insert(&backend->input_devices, &wlr_device->link); if (backend->started) { - wl_signal_emit(&backend->backend.events.input_add, wlr_device); + wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_device); } return wlr_device; diff --git a/backend/headless/output.c b/backend/headless/output.c index 507595a5..ba4a094e 100644 --- a/backend/headless/output.c +++ b/backend/headless/output.c @@ -1,10 +1,11 @@ -#include <stdlib.h> #include <EGL/egl.h> #include <EGL/eglext.h> #include <GLES2/gl2.h> +#include <stdlib.h> #include <wlr/interfaces/wlr_output.h> #include <wlr/util/log.h> #include "backend/headless.h" +#include "util/signal.h" static EGLSurface egl_create_surface(struct wlr_egl *egl, unsigned int width, unsigned int height) { @@ -136,7 +137,7 @@ struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend, if (backend->started) { wl_event_source_timer_update(output->frame_timer, output->frame_delay); wlr_output_update_enabled(wlr_output, true); - wl_signal_emit(&backend->backend.events.output_add, wlr_output); + wlr_signal_emit_safe(&backend->backend.events.new_output, wlr_output); } return wlr_output; diff --git a/backend/libinput/backend.c b/backend/libinput/backend.c index 86477947..71fe0d93 100644 --- a/backend/libinput/backend.c +++ b/backend/libinput/backend.c @@ -1,10 +1,11 @@ -#include <stdlib.h> #include <assert.h> #include <libinput.h> -#include <wlr/backend/session.h> +#include <stdlib.h> #include <wlr/backend/interface.h> +#include <wlr/backend/session.h> #include <wlr/util/log.h> #include "backend/libinput.h" +#include "util/signal.h" static int wlr_libinput_open_restricted(const char *path, int flags, void *_backend) { @@ -106,13 +107,12 @@ static void wlr_libinput_backend_destroy(struct wlr_backend *wlr_backend) { struct wl_list *wlr_devices = backend->wlr_device_lists.items[i]; struct wlr_input_device *wlr_dev, *next; wl_list_for_each_safe(wlr_dev, next, wlr_devices, link) { - wl_signal_emit(&backend->backend.events.input_remove, wlr_dev); wlr_input_device_destroy(wlr_dev); } free(wlr_devices); } - wl_signal_emit(&wlr_backend->events.destroy, wlr_backend); + wlr_signal_emit_safe(&wlr_backend->events.destroy, wlr_backend); wl_list_remove(&backend->display_destroy.link); wl_list_remove(&backend->session_signal.link); diff --git a/backend/libinput/events.c b/backend/libinput/events.c index 758a9f25..603eed07 100644 --- a/backend/libinput/events.c +++ b/backend/libinput/events.c @@ -1,11 +1,12 @@ -#include <stdlib.h> #include <assert.h> #include <libinput.h> +#include <stdlib.h> +#include <wayland-util.h> #include <wlr/backend/session.h> #include <wlr/interfaces/wlr_input_device.h> #include <wlr/util/log.h> -#include <wayland-util.h> #include "backend/libinput.h" +#include "util/signal.h" struct wlr_input_device *get_appropriate_device( enum wlr_input_device_type desired_type, @@ -88,7 +89,7 @@ static void handle_device_added(struct wlr_libinput_backend *backend, free(wlr_dev); goto fail; } - wl_signal_emit(&backend->backend.events.input_add, wlr_dev); + wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); } if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_POINTER)) { struct wlr_input_device *wlr_dev = allocate_device(backend, @@ -101,7 +102,7 @@ static void handle_device_added(struct wlr_libinput_backend *backend, free(wlr_dev); goto fail; } - wl_signal_emit(&backend->backend.events.input_add, wlr_dev); + wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); } if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_TOUCH)) { struct wlr_input_device *wlr_dev = allocate_device(backend, @@ -114,7 +115,7 @@ static void handle_device_added(struct wlr_libinput_backend *backend, free(wlr_dev); goto fail; } - wl_signal_emit(&backend->backend.events.input_add, wlr_dev); + wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); } if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_TABLET_TOOL)) { struct wlr_input_device *wlr_dev = allocate_device(backend, @@ -127,7 +128,7 @@ static void handle_device_added(struct wlr_libinput_backend *backend, free(wlr_dev); goto fail; } - wl_signal_emit(&backend->backend.events.input_add, wlr_dev); + wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); } if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_TABLET_PAD)) { struct wlr_input_device *wlr_dev = allocate_device(backend, @@ -140,7 +141,7 @@ static void handle_device_added(struct wlr_libinput_backend *backend, free(wlr_dev); goto fail; } - wl_signal_emit(&backend->backend.events.input_add, wlr_dev); + wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_dev); } if (libinput_device_has_capability(libinput_dev, LIBINPUT_DEVICE_CAP_GESTURE)) { // TODO @@ -178,7 +179,6 @@ static void handle_device_removed(struct wlr_libinput_backend *backend, } struct wlr_input_device *dev, *tmp_dev; wl_list_for_each_safe(dev, tmp_dev, wlr_devices, link) { - wl_signal_emit(&backend->backend.events.input_remove, dev); wlr_input_device_destroy(dev); } for (size_t i = 0; i < backend->wlr_device_lists.length; i++) { diff --git a/backend/libinput/keyboard.c b/backend/libinput/keyboard.c index 065d8ead..b44bc892 100644 --- a/backend/libinput/keyboard.c +++ b/backend/libinput/keyboard.c @@ -1,9 +1,9 @@ -#include <stdlib.h> #include <assert.h> #include <libinput.h> +#include <stdlib.h> #include <wlr/backend/session.h> -#include <wlr/types/wlr_input_device.h> #include <wlr/interfaces/wlr_keyboard.h> +#include <wlr/types/wlr_input_device.h> #include <wlr/util/log.h> #include "backend/libinput.h" @@ -57,7 +57,7 @@ void handle_keyboard_key(struct libinput_event *event, wlr_event.time_msec = usec_to_msec(libinput_event_keyboard_get_time_usec(kbevent)); wlr_event.keycode = libinput_event_keyboard_get_key(kbevent); - enum libinput_key_state state = + enum libinput_key_state state = libinput_event_keyboard_get_key_state(kbevent); switch (state) { case LIBINPUT_KEY_STATE_RELEASED: diff --git a/backend/libinput/pointer.c b/backend/libinput/pointer.c index 13402ac2..8a31d312 100644 --- a/backend/libinput/pointer.c +++ b/backend/libinput/pointer.c @@ -1,11 +1,12 @@ -#include <stdlib.h> #include <assert.h> #include <libinput.h> +#include <stdlib.h> #include <wlr/backend/session.h> -#include <wlr/types/wlr_input_device.h> #include <wlr/interfaces/wlr_pointer.h> +#include <wlr/types/wlr_input_device.h> #include <wlr/util/log.h> #include "backend/libinput.h" +#include "util/signal.h" struct wlr_pointer *wlr_libinput_pointer_create( struct libinput_device *libinput_dev) { @@ -35,7 +36,7 @@ void handle_pointer_motion(struct libinput_event *event, usec_to_msec(libinput_event_pointer_get_time_usec(pevent)); wlr_event.delta_x = libinput_event_pointer_get_dx(pevent); wlr_event.delta_y = libinput_event_pointer_get_dy(pevent); - wl_signal_emit(&wlr_dev->pointer->events.motion, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->pointer->events.motion, &wlr_event); } void handle_pointer_motion_abs(struct libinput_event *event, @@ -55,7 +56,7 @@ void handle_pointer_motion_abs(struct libinput_event *event, wlr_event.x_mm = libinput_event_pointer_get_absolute_x(pevent); wlr_event.y_mm = libinput_event_pointer_get_absolute_y(pevent); libinput_device_get_size(libinput_dev, &wlr_event.width_mm, &wlr_event.height_mm); - wl_signal_emit(&wlr_dev->pointer->events.motion_absolute, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->pointer->events.motion_absolute, &wlr_event); } void handle_pointer_button(struct libinput_event *event, @@ -81,7 +82,7 @@ void handle_pointer_button(struct libinput_event *event, wlr_event.state = WLR_BUTTON_RELEASED; break; } - wl_signal_emit(&wlr_dev->pointer->events.button, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->pointer->events.button, &wlr_event); } void handle_pointer_axis(struct libinput_event *event, @@ -128,7 +129,7 @@ void handle_pointer_axis(struct libinput_event *event, } wlr_event.delta = libinput_event_pointer_get_axis_value( pevent, axies[i]); - wl_signal_emit(&wlr_dev->pointer->events.axis, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->pointer->events.axis, &wlr_event); } } } diff --git a/backend/libinput/tablet_pad.c b/backend/libinput/tablet_pad.c index 7dac3b7c..70e4c677 100644 --- a/backend/libinput/tablet_pad.c +++ b/backend/libinput/tablet_pad.c @@ -1,11 +1,12 @@ -#include <stdlib.h> #include <assert.h> #include <libinput.h> +#include <stdlib.h> #include <wlr/backend/session.h> -#include <wlr/types/wlr_input_device.h> #include <wlr/interfaces/wlr_tablet_pad.h> +#include <wlr/types/wlr_input_device.h> #include <wlr/util/log.h> #include "backend/libinput.h" +#include "util/signal.h" struct wlr_tablet_pad *wlr_libinput_tablet_pad_create( struct libinput_device *libinput_dev) { @@ -41,7 +42,7 @@ void handle_tablet_pad_button(struct libinput_event *event, wlr_event.state = WLR_BUTTON_RELEASED; break; } - wl_signal_emit(&wlr_dev->tablet_pad->events.button, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->tablet_pad->events.button, &wlr_event); } void handle_tablet_pad_ring(struct libinput_event *event, @@ -67,7 +68,7 @@ void handle_tablet_pad_ring(struct libinput_event *event, wlr_event.source = WLR_TABLET_PAD_RING_SOURCE_FINGER; break; } - wl_signal_emit(&wlr_dev->tablet_pad->events.ring, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->tablet_pad->events.ring, &wlr_event); } void handle_tablet_pad_strip(struct libinput_event *event, @@ -93,5 +94,5 @@ void handle_tablet_pad_strip(struct libinput_event *event, wlr_event.source = WLR_TABLET_PAD_STRIP_SOURCE_FINGER; break; } - wl_signal_emit(&wlr_dev->tablet_pad->events.strip, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->tablet_pad->events.strip, &wlr_event); } diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index 3d5fafc3..4e60367f 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -1,11 +1,12 @@ -#include <stdlib.h> #include <assert.h> #include <libinput.h> +#include <stdlib.h> #include <wlr/backend/session.h> -#include <wlr/types/wlr_input_device.h> #include <wlr/interfaces/wlr_tablet_tool.h> +#include <wlr/types/wlr_input_device.h> #include <wlr/util/log.h> #include "backend/libinput.h" +#include "util/signal.h" struct wlr_tablet_tool *wlr_libinput_tablet_tool_create( struct libinput_device *libinput_dev) { @@ -72,7 +73,7 @@ void handle_tablet_tool_axis(struct libinput_event *event, } wlr_log(L_DEBUG, "Tablet tool axis event %d @ %f,%f", wlr_event.updated_axes, wlr_event.x_mm, wlr_event.y_mm); - wl_signal_emit(&wlr_dev->tablet_tool->events.axis, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->tablet_tool->events.axis, &wlr_event); } void handle_tablet_tool_proximity(struct libinput_event *event, @@ -98,7 +99,7 @@ void handle_tablet_tool_proximity(struct libinput_event *event, handle_tablet_tool_axis(event, libinput_dev); break; } - wl_signal_emit(&wlr_dev->tablet_tool->events.proximity, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->tablet_tool->events.proximity, &wlr_event); } void handle_tablet_tool_tip(struct libinput_event *event, @@ -124,7 +125,7 @@ void handle_tablet_tool_tip(struct libinput_event *event, wlr_event.state = WLR_TABLET_TOOL_TIP_DOWN; break; } - wl_signal_emit(&wlr_dev->tablet_tool->events.tip, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->tablet_tool->events.tip, &wlr_event); } void handle_tablet_tool_button(struct libinput_event *event, @@ -151,5 +152,5 @@ void handle_tablet_tool_button(struct libinput_event *event, wlr_event.state = WLR_BUTTON_PRESSED; break; } - wl_signal_emit(&wlr_dev->tablet_tool->events.button, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->tablet_tool->events.button, &wlr_event); } diff --git a/backend/libinput/touch.c b/backend/libinput/touch.c index 0ba6ec86..2b87f9cd 100644 --- a/backend/libinput/touch.c +++ b/backend/libinput/touch.c @@ -1,11 +1,12 @@ -#include <stdlib.h> #include <assert.h> #include <libinput.h> +#include <stdlib.h> #include <wlr/backend/session.h> -#include <wlr/types/wlr_input_device.h> #include <wlr/interfaces/wlr_touch.h> +#include <wlr/types/wlr_input_device.h> #include <wlr/util/log.h> #include "backend/libinput.h" +#include "util/signal.h" struct wlr_touch *wlr_libinput_touch_create( struct libinput_device *libinput_dev) { @@ -37,7 +38,7 @@ void handle_touch_down(struct libinput_event *event, wlr_event.x_mm = libinput_event_touch_get_x(tevent); wlr_event.y_mm = libinput_event_touch_get_y(tevent); libinput_device_get_size(libinput_dev, &wlr_event.width_mm, &wlr_event.height_mm); - wl_signal_emit(&wlr_dev->touch->events.down, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->touch->events.down, &wlr_event); } void handle_touch_up(struct libinput_event *event, @@ -55,7 +56,7 @@ void handle_touch_up(struct libinput_event *event, wlr_event.time_msec = usec_to_msec(libinput_event_touch_get_time_usec(tevent)); wlr_event.touch_id = libinput_event_touch_get_slot(tevent); - wl_signal_emit(&wlr_dev->touch->events.up, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->touch->events.up, &wlr_event); } void handle_touch_motion(struct libinput_event *event, @@ -76,7 +77,7 @@ void handle_touch_motion(struct libinput_event *event, wlr_event.x_mm = libinput_event_touch_get_x(tevent); wlr_event.y_mm = libinput_event_touch_get_y(tevent); libinput_device_get_size(libinput_dev, &wlr_event.width_mm, &wlr_event.height_mm); - wl_signal_emit(&wlr_dev->touch->events.motion, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->touch->events.motion, &wlr_event); } void handle_touch_cancel(struct libinput_event *event, @@ -94,5 +95,5 @@ void handle_touch_cancel(struct libinput_event *event, wlr_event.time_msec = usec_to_msec(libinput_event_touch_get_time_usec(tevent)); wlr_event.touch_id = libinput_event_touch_get_slot(tevent); - wl_signal_emit(&wlr_dev->touch->events.cancel, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->touch->events.cancel, &wlr_event); } diff --git a/backend/meson.build b/backend/meson.build index beb3841c..bac43063 100644 --- a/backend/meson.build +++ b/backend/meson.build @@ -1,7 +1,5 @@ backend_files = files( 'backend.c', - 'session/direct-ipc.c', - 'session/session.c', 'drm/atomic.c', 'drm/backend.c', 'drm/drm.c', @@ -10,8 +8,8 @@ backend_files = files( 'drm/renderer.c', 'drm/util.c', 'headless/backend.c', - 'headless/output.c', 'headless/input_device.c', + 'headless/output.c', 'libinput/backend.c', 'libinput/events.c', 'libinput/keyboard.c', @@ -20,6 +18,8 @@ backend_files = files( 'libinput/tablet_tool.c', 'libinput/touch.c', 'multi/backend.c', + 'session/direct-ipc.c', + 'session/session.c', 'wayland/backend.c', 'wayland/output.c', 'wayland/registry.c', diff --git a/backend/multi/backend.c b/backend/multi/backend.c index 78f5c63b..5cb3fbc5 100644 --- a/backend/multi/backend.c +++ b/backend/multi/backend.c @@ -4,17 +4,16 @@ #include <wlr/backend/interface.h> #include <wlr/backend/session.h> #include <wlr/util/log.h> -#include "backend/multi.h" #include "backend/drm/drm.h" +#include "backend/multi.h" +#include "util/signal.h" struct subbackend_state { struct wlr_backend *backend; struct wlr_backend *container; - struct wl_listener input_add; - struct wl_listener input_remove; - struct wl_listener output_add; - struct wl_listener output_remove; - struct wl_listener backend_destroy; + struct wl_listener new_input; + struct wl_listener new_output; + struct wl_listener destroy; struct wl_list link; }; @@ -31,11 +30,9 @@ static bool multi_backend_start(struct wlr_backend *wlr_backend) { } static void subbackend_state_destroy(struct subbackend_state *sub) { - wl_list_remove(&sub->input_add.link); - wl_list_remove(&sub->input_remove.link); - wl_list_remove(&sub->output_add.link); - wl_list_remove(&sub->output_remove.link); - wl_list_remove(&sub->backend_destroy.link); + wl_list_remove(&sub->new_input.link); + wl_list_remove(&sub->new_output.link); + wl_list_remove(&sub->destroy.link); wl_list_remove(&sub->link); free(sub); } @@ -51,7 +48,7 @@ static void multi_backend_destroy(struct wlr_backend *wlr_backend) { } // Destroy this backend only after removing all sub-backends - wl_signal_emit(&wlr_backend->events.destroy, backend); + wlr_signal_emit_safe(&wlr_backend->events.destroy, backend); free(backend); } @@ -117,34 +114,21 @@ bool wlr_backend_is_multi(struct wlr_backend *b) { return b->impl == &backend_impl; } -static void input_add_reemit(struct wl_listener *listener, void *data) { - struct subbackend_state *state = wl_container_of(listener, - state, input_add); - wl_signal_emit(&state->container->events.input_add, data); -} - -static void input_remove_reemit(struct wl_listener *listener, void *data) { +static void new_input_reemit(struct wl_listener *listener, void *data) { struct subbackend_state *state = wl_container_of(listener, - state, input_remove); - wl_signal_emit(&state->container->events.input_remove, data); + state, new_input); + wlr_signal_emit_safe(&state->container->events.new_input, data); } -static void output_add_reemit(struct wl_listener *listener, void *data) { +static void new_output_reemit(struct wl_listener *listener, void *data) { struct subbackend_state *state = wl_container_of(listener, - state, output_add); - wl_signal_emit(&state->container->events.output_add, data); -} - -static void output_remove_reemit(struct wl_listener *listener, void *data) { - struct subbackend_state *state = wl_container_of(listener, - state, output_remove); - wl_signal_emit(&state->container->events.output_remove, data); + state, new_output); + wlr_signal_emit_safe(&state->container->events.new_output, data); } static void handle_subbackend_destroy(struct wl_listener *listener, void *data) { - struct subbackend_state *state = wl_container_of(listener, - state, backend_destroy); + struct subbackend_state *state = wl_container_of(listener, state, destroy); subbackend_state_destroy(state); } @@ -179,22 +163,16 @@ void wlr_multi_backend_add(struct wlr_backend *_multi, sub->backend = backend; sub->container = &multi->backend; - wl_signal_add(&backend->events.destroy, &sub->backend_destroy); - sub->backend_destroy.notify = handle_subbackend_destroy; - - wl_signal_add(&backend->events.input_add, &sub->input_add); - sub->input_add.notify = input_add_reemit; - - wl_signal_add(&backend->events.input_remove, &sub->input_remove); - sub->input_remove.notify = input_remove_reemit; + wl_signal_add(&backend->events.destroy, &sub->destroy); + sub->destroy.notify = handle_subbackend_destroy; - wl_signal_add(&backend->events.output_add, &sub->output_add); - sub->output_add.notify = output_add_reemit; + wl_signal_add(&backend->events.new_input, &sub->new_input); + sub->new_input.notify = new_input_reemit; - wl_signal_add(&backend->events.output_remove, &sub->output_remove); - sub->output_remove.notify = output_remove_reemit; + wl_signal_add(&backend->events.new_output, &sub->new_output); + sub->new_output.notify = new_output_reemit; - wl_signal_emit(&multi->events.backend_add, backend); + wlr_signal_emit_safe(&multi->events.backend_add, backend); } void wlr_multi_backend_remove(struct wlr_backend *_multi, @@ -206,7 +184,7 @@ void wlr_multi_backend_remove(struct wlr_backend *_multi, multi_backend_get_subbackend(multi, backend); if (sub) { - wl_signal_emit(&multi->events.backend_remove, backend); + wlr_signal_emit_safe(&multi->events.backend_remove, backend); subbackend_state_destroy(sub); } } diff --git a/backend/session/direct-freebsd.c b/backend/session/direct-freebsd.c index c0621416..6e23bf1b 100644 --- a/backend/session/direct-freebsd.c +++ b/backend/session/direct-freebsd.c @@ -1,21 +1,22 @@ +#include <dev/evdev/input.h> #include <errno.h> -#include <stdlib.h> -#include <stdio.h> -#include <stdbool.h> -#include <unistd.h> +#include <fcntl.h> #include <signal.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/consio.h> #include <sys/ioctl.h> +#include <sys/kbio.h> #include <sys/stat.h> -#include <termios.h> -#include <fcntl.h> #include <sys/types.h> -#include <dev/evdev/input.h> -#include <sys/kbio.h> -#include <sys/consio.h> +#include <termios.h> +#include <unistd.h> #include <wayland-server.h> #include <wlr/backend/session/interface.h> #include <wlr/util/log.h> #include "backend/session/direct-ipc.h" +#include "util/signal.h" const struct session_impl session_direct; @@ -95,12 +96,12 @@ static int vt_handler(int signo, void *data) { if (session->base.active) { session->base.active = false; - wl_signal_emit(&session->base.session_signal, session); + wlr_signal_emit_safe(&session->base.session_signal, session); ioctl(session->tty_fd, VT_RELDISP, 1); } else { ioctl(session->tty_fd, VT_RELDISP, VT_ACKACQ); session->base.active = true; - wl_signal_emit(&session->base.session_signal, session); + wlr_signal_emit_safe(&session->base.session_signal, session); } return 1; diff --git a/backend/session/direct-ipc.c b/backend/session/direct-ipc.c index e7a169fa..6c69b70a 100644 --- a/backend/session/direct-ipc.c +++ b/backend/session/direct-ipc.c @@ -4,22 +4,22 @@ #define INPUT_MAJOR 0 #endif #include <errno.h> +#include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> -#include <fcntl.h> -#include <unistd.h> #include <sys/socket.h> #include <sys/stat.h> #include <sys/types.h> #include <sys/wait.h> +#include <unistd.h> +#include <wlr/config.h> +#include <wlr/util/log.h> +#include <xf86drm.h> #ifdef __linux__ #include <sys/sysmacros.h> #include <linux/major.h> #endif -#include <xf86drm.h> -#include <wlr/config.h> -#include <wlr/util/log.h> #include "backend/session/direct-ipc.h" enum { DRM_MAJOR = 226 }; diff --git a/backend/session/direct.c b/backend/session/direct.c index 9d6cd36d..13a26d99 100644 --- a/backend/session/direct.c +++ b/backend/session/direct.c @@ -1,21 +1,22 @@ #define _POSIX_C_SOURCE 200809L #include <errno.h> -#include <stdlib.h> -#include <stdio.h> -#include <stdbool.h> -#include <unistd.h> +#include <linux/input.h> +#include <linux/kd.h> +#include <linux/major.h> +#include <linux/vt.h> #include <signal.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> #include <sys/ioctl.h> #include <sys/stat.h> #include <sys/sysmacros.h> -#include <linux/kd.h> -#include <linux/major.h> -#include <linux/input.h> -#include <linux/vt.h> +#include <unistd.h> #include <wayland-server.h> #include <wlr/backend/session/interface.h> #include <wlr/util/log.h> #include "backend/session/direct-ipc.h" +#include "util/signal.h" enum { DRM_MAJOR = 226 }; @@ -107,7 +108,7 @@ static int vt_handler(int signo, void *data) { if (session->base.active) { session->base.active = false; - wl_signal_emit(&session->base.session_signal, session); + wlr_signal_emit_safe(&session->base.session_signal, session); struct wlr_device *dev; wl_list_for_each(dev, &session->base.devices, link) { @@ -130,7 +131,7 @@ static int vt_handler(int signo, void *data) { } session->base.active = true; - wl_signal_emit(&session->base.session_signal, session); + wlr_signal_emit_safe(&session->base.session_signal, session); } return 1; diff --git a/backend/session/logind.c b/backend/session/logind.c index 1ece051f..f0ac1e93 100644 --- a/backend/session/logind.c +++ b/backend/session/logind.c @@ -1,25 +1,26 @@ #define _POSIX_C_SOURCE 200809L #include <assert.h> -#include <stdio.h> +#include <errno.h> +#include <fcntl.h> #include <stdbool.h> +#include <stdio.h> #include <stdlib.h> #include <string.h> -#include <errno.h> -#include <unistd.h> -#include <sys/sysmacros.h> #include <sys/stat.h> -#include <fcntl.h> +#include <sys/sysmacros.h> +#include <unistd.h> #include <wayland-server.h> -#include <wlr/config.h> #include <wlr/backend/session/interface.h> +#include <wlr/config.h> #include <wlr/util/log.h> +#include "util/signal.h" #ifdef WLR_HAS_SYSTEMD #include <systemd/sd-bus.h> #include <systemd/sd-login.h> #elif defined(WLR_HAS_ELOGIND) #include <elogind/sd-bus.h> - #include <elogind/sd-login.h> + #include <elogind/sd-login.h> #endif enum { DRM_MAJOR = 226 }; @@ -250,7 +251,7 @@ static int pause_device(sd_bus_message *msg, void *userdata, sd_bus_error *ret_e if (major == DRM_MAJOR) { session->base.active = false; - wl_signal_emit(&session->base.session_signal, session); + wlr_signal_emit_safe(&session->base.session_signal, session); } if (strcmp(type, "pause") == 0) { @@ -286,7 +287,7 @@ static int resume_device(sd_bus_message *msg, void *userdata, sd_bus_error *ret_ if (!session->base.active) { session->base.active = true; - wl_signal_emit(&session->base.session_signal, session); + wlr_signal_emit_safe(&session->base.session_signal, session); } } diff --git a/backend/session/session.c b/backend/session/session.c index 2bbbd4ef..2d5d9776 100644 --- a/backend/session/session.c +++ b/backend/session/session.c @@ -1,18 +1,19 @@ #define _POSIX_C_SOURCE 200809L #include <assert.h> +#include <libudev.h> #include <stddef.h> #include <stdlib.h> #include <string.h> #include <sys/stat.h> #include <sys/types.h> -#include <libudev.h> #include <wayland-server.h> -#include <xf86drm.h> -#include <xf86drmMode.h> -#include <wlr/config.h> #include <wlr/backend/session.h> #include <wlr/backend/session/interface.h> +#include <wlr/config.h> #include <wlr/util/log.h> +#include <xf86drm.h> +#include <xf86drmMode.h> +#include "util/signal.h" extern const struct session_impl session_logind; extern const struct session_impl session_direct; @@ -49,7 +50,7 @@ static int udev_event(int fd, uint32_t mask, void *data) { wl_list_for_each(dev, &session->devices, link) { if (dev->dev == devnum) { - wl_signal_emit(&dev->signal, session); + wlr_signal_emit_safe(&dev->signal, session); break; } } diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c index 458c9dd0..abb25df5 100644 --- a/backend/wayland/backend.c +++ b/backend/wayland/backend.c @@ -1,17 +1,18 @@ -#include <stdlib.h> -#include <stdint.h> #include <assert.h> -#include <limits.h> #include <EGL/egl.h> #include <EGL/eglext.h> +#include <limits.h> +#include <stdint.h> +#include <stdlib.h> #include <wayland-server.h> -#include <wlr/render/egl.h> -#include <wlr/render/gles2.h> #include <wlr/backend/interface.h> -#include <wlr/interfaces/wlr_output.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" static int dispatch_events(int fd, uint32_t mask, void *data) { @@ -80,7 +81,7 @@ static void wlr_wl_backend_destroy(struct wlr_backend *wlr_backend) { wlr_input_device_destroy(input_device); } - wl_signal_emit(&wlr_backend->events.destroy, wlr_backend); + wlr_signal_emit_safe(&wlr_backend->events.destroy, wlr_backend); wl_list_remove(&backend->local_display_destroy.link); diff --git a/backend/wayland/output.c b/backend/wayland/output.c index 0bbf6d42..fc40dea0 100644 --- a/backend/wayland/output.c +++ b/backend/wayland/output.c @@ -1,16 +1,17 @@ -#include <stdio.h> #include <assert.h> +#include <GLES2/gl2.h> #include <stdint.h> +#include <stdio.h> #include <stdlib.h> #include <string.h> -#include <unistd.h> -#include <sys/types.h> #include <sys/mman.h> +#include <sys/types.h> +#include <unistd.h> #include <wayland-client.h> -#include <GLES2/gl2.h> #include <wlr/interfaces/wlr_output.h> #include <wlr/util/log.h> #include "backend/wayland.h" +#include "util/signal.h" #include "xdg-shell-unstable-v6-client-protocol.h" int os_create_anonymous_file(off_t size); @@ -338,7 +339,7 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) { wl_list_insert(&backend->outputs, &output->link); wlr_output_update_enabled(wlr_output, true); - wl_signal_emit(&backend->backend.events.output_add, wlr_output); + wlr_signal_emit_safe(&backend->backend.events.new_output, wlr_output); return wlr_output; error: diff --git a/backend/wayland/registry.c b/backend/wayland/registry.c index 0dec0ec5..4aa39f09 100644 --- a/backend/wayland/registry.c +++ b/backend/wayland/registry.c @@ -6,7 +6,6 @@ #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); diff --git a/backend/wayland/wl_seat.c b/backend/wayland/wl_seat.c index 37489678..b1f7cff6 100644 --- a/backend/wayland/wl_seat.c +++ b/backend/wayland/wl_seat.c @@ -1,16 +1,17 @@ #define _XOPEN_SOURCE 500 #include <assert.h> -#include <stdlib.h> #include <stdint.h> +#include <stdlib.h> #include <string.h> #include <wayland-client.h> -#include <wlr/interfaces/wlr_output.h> #include <wlr/interfaces/wlr_input_device.h> -#include <wlr/interfaces/wlr_pointer.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" static void pointer_handle_enter(void *data, struct wl_pointer *wl_pointer, uint32_t serial, struct wl_surface *surface, wl_fixed_t surface_x, @@ -78,7 +79,7 @@ static void pointer_handle_motion(void *data, struct wl_pointer *wl_pointer, wlr_event.height_mm = layout_box.height; wlr_event.x_mm = transformed.x + wlr_output->lx - layout_box.x; wlr_event.y_mm = transformed.y + wlr_output->ly - layout_box.y; - wl_signal_emit(&dev->pointer->events.motion_absolute, &wlr_event); + wlr_signal_emit_safe(&dev->pointer->events.motion_absolute, &wlr_event); } static void pointer_handle_button(void *data, struct wl_pointer *wl_pointer, @@ -91,7 +92,7 @@ static void pointer_handle_button(void *data, struct wl_pointer *wl_pointer, wlr_event.button = button; wlr_event.state = state; wlr_event.time_msec = time; - wl_signal_emit(&dev->pointer->events.button, &wlr_event); + wlr_signal_emit_safe(&dev->pointer->events.button, &wlr_event); } static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer, @@ -106,7 +107,7 @@ static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer, wlr_event.orientation = axis; wlr_event.time_msec = time; wlr_event.source = wlr_wl_pointer->axis_source; - wl_signal_emit(&dev->pointer->events.axis, &wlr_event); + wlr_signal_emit_safe(&dev->pointer->events.axis, &wlr_event); } static void pointer_handle_frame(void *data, struct wl_pointer *wl_pointer) { @@ -192,9 +193,8 @@ static struct wl_keyboard_listener keyboard_listener = { .repeat_info = keyboard_handle_repeat_info }; -static void input_device_destroy(struct wlr_input_device *_dev) { - struct wlr_wl_input_device *dev = (struct wlr_wl_input_device *)_dev; - wl_signal_emit(&dev->backend->backend.events.input_remove, &dev->wlr_input_device); +static void input_device_destroy(struct wlr_input_device *wlr_dev) { + struct wlr_wl_input_device *dev = (struct wlr_wl_input_device *)wlr_dev; if (dev->resource) { wl_proxy_destroy(dev->resource); } @@ -256,7 +256,7 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat, wlr_device->pointer = &wlr_wl_pointer->wlr_pointer; wlr_pointer_init(wlr_device->pointer, NULL); wlr_wl_device->resource = wl_pointer; - wl_signal_emit(&backend->backend.events.input_add, wlr_device); + wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_device); backend->pointer = wl_pointer; } if ((caps & WL_SEAT_CAPABILITY_KEYBOARD)) { @@ -280,7 +280,7 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat, struct wl_keyboard *wl_keyboard = wl_seat_get_keyboard(wl_seat); wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, wlr_device); wlr_wl_device->resource = wl_keyboard; - wl_signal_emit(&backend->backend.events.input_add, wlr_device); + wlr_signal_emit_safe(&backend->backend.events.new_input, wlr_device); } } diff --git a/backend/x11/backend.c b/backend/x11/backend.c index 411d0ef6..28a4fcac 100644 --- a/backend/x11/backend.c +++ b/backend/x11/backend.c @@ -1,28 +1,29 @@ #define _POSIX_C_SOURCE 200112L +#include <EGL/egl.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <time.h> -#include <EGL/egl.h> #include <wayland-server.h> -#include <xcb/xcb.h> -#include <xcb/glx.h> -#include <X11/Xlib-xcb.h> -#ifdef __linux__ -#include <linux/input-event-codes.h> -#elif __FreeBSD__ -#include <dev/evdev/input-event-codes.h> -#endif #include <wlr/backend/interface.h> #include <wlr/backend/x11.h> -#include <wlr/render/egl.h> -#include <wlr/render/gles2.h> -#include <wlr/interfaces/wlr_output.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/render/egl.h> +#include <wlr/render/gles2.h> #include <wlr/util/log.h> +#include <X11/Xlib-xcb.h> +#include <xcb/glx.h> +#include <xcb/xcb.h> +#ifdef __linux__ +#include <linux/input-event-codes.h> +#elif __FreeBSD__ +#include <dev/evdev/input-event-codes.h> +#endif #include "backend/x11.h" +#include "util/signal.h" static struct wlr_backend_impl backend_impl; static struct wlr_output_impl output_impl; @@ -77,7 +78,7 @@ static bool handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *e .orientation = WLR_AXIS_ORIENTATION_VERTICAL, .delta = delta, }; - wl_signal_emit(&x11->pointer.events.axis, &axis); + wlr_signal_emit_safe(&x11->pointer.events.axis, &axis); x11->time = ev->time; break; } @@ -96,7 +97,7 @@ static bool handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *e WLR_BUTTON_PRESSED : WLR_BUTTON_RELEASED, }; - wl_signal_emit(&x11->pointer.events.button, &button); + wlr_signal_emit_safe(&x11->pointer.events.button, &button); } x11->time = ev->time; break; @@ -112,7 +113,7 @@ static bool handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *e .height_mm = output->wlr_output.height, }; - wl_signal_emit(&x11->pointer.events.motion_absolute, &abs); + wlr_signal_emit_safe(&x11->pointer.events.motion_absolute, &abs); x11->time = ev->time; break; } @@ -140,7 +141,7 @@ static bool handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *e .height_mm = output->wlr_output.height, }; - wl_signal_emit(&x11->pointer.events.motion_absolute, &abs); + wlr_signal_emit_safe(&x11->pointer.events.motion_absolute, &abs); break; } case XCB_GLX_DELETE_QUERIES_ARB: { @@ -229,9 +230,9 @@ static bool wlr_x11_backend_start(struct wlr_backend *backend) { xcb_flush(x11->xcb_conn); wlr_output_update_enabled(&output->wlr_output, true); - wl_signal_emit(&x11->backend.events.output_add, output); - wl_signal_emit(&x11->backend.events.input_add, &x11->keyboard_dev); - wl_signal_emit(&x11->backend.events.input_add, &x11->pointer_dev); + wlr_signal_emit_safe(&x11->backend.events.new_output, output); + wlr_signal_emit_safe(&x11->backend.events.new_input, &x11->keyboard_dev); + wlr_signal_emit_safe(&x11->backend.events.new_input, &x11->pointer_dev); wl_event_source_timer_update(x11->frame_timer, 16); @@ -248,8 +249,8 @@ static void wlr_x11_backend_destroy(struct wlr_backend *backend) { struct wlr_x11_output *output = &x11->output; wlr_output_destroy(&output->wlr_output); - wl_signal_emit(&backend->events.input_remove, &x11->pointer_dev); - wl_signal_emit(&backend->events.input_remove, &x11->keyboard_dev); + wlr_signal_emit_safe(&x11->pointer_dev.events.destroy, &x11->pointer_dev); + wlr_signal_emit_safe(&x11->keyboard_dev.events.destroy, &x11->keyboard_dev); // TODO probably need to use wlr_keyboard_destroy, but the devices need to // be malloced for that to work if (x11->keyboard_dev.keyboard->keymap) { @@ -259,7 +260,7 @@ static void wlr_x11_backend_destroy(struct wlr_backend *backend) { xkb_state_unref(x11->keyboard_dev.keyboard->xkb_state); } - wl_signal_emit(&backend->events.destroy, backend); + wlr_signal_emit_safe(&backend->events.destroy, backend); wl_list_remove(&x11->display_destroy.link); diff --git a/examples/support/shared.c b/examples/support/shared.c index 6cfaa6aa..c4f9288d 100644 --- a/examples/support/shared.c +++ b/examples/support/shared.c @@ -56,10 +56,24 @@ static void keyboard_key_notify(struct wl_listener *listener, void *data) { } } +static void keyboard_destroy_notify(struct wl_listener *listener, void *data) { + struct keyboard_state *kbstate = wl_container_of(listener, kbstate, destroy); + struct compositor_state *state = kbstate->compositor; + if (state->input_remove_cb) { + state->input_remove_cb(state, kbstate->device); + } + wl_list_remove(&kbstate->link); + wl_list_remove(&kbstate->destroy.link); + wl_list_remove(&kbstate->key.link); + free(kbstate); +} + static void keyboard_add(struct wlr_input_device *device, struct compositor_state *state) { struct keyboard_state *kbstate = calloc(sizeof(struct keyboard_state), 1); kbstate->device = device; kbstate->compositor = state; + kbstate->destroy.notify = keyboard_destroy_notify; + wl_signal_add(&device->events.destroy, &kbstate->destroy); kbstate->key.notify = keyboard_key_notify; wl_signal_add(&device->keyboard->events.key, &kbstate->key); wl_list_insert(&state->keyboards, &kbstate->link); @@ -117,17 +131,34 @@ static void pointer_axis_notify(struct wl_listener *listener, void *data) { } } +static void pointer_destroy_notify(struct wl_listener *listener, void *data) { + struct pointer_state *pstate = wl_container_of(listener, pstate, destroy); + struct compositor_state *state = pstate->compositor; + if (state->input_remove_cb) { + state->input_remove_cb(state, pstate->device); + } + wl_list_remove(&pstate->link); + wl_list_remove(&pstate->destroy.link); + wl_list_remove(&pstate->motion.link); + wl_list_remove(&pstate->motion_absolute.link); + wl_list_remove(&pstate->button.link); + wl_list_remove(&pstate->axis.link); + free(pstate); +} + static void pointer_add(struct wlr_input_device *device, struct compositor_state *state) { struct pointer_state *pstate = calloc(sizeof(struct pointer_state), 1); pstate->device = device; pstate->compositor = state; + pstate->destroy.notify = pointer_destroy_notify; + wl_signal_add(&device->events.destroy, &pstate->destroy); pstate->motion.notify = pointer_motion_notify; - pstate->motion_absolute.notify = pointer_motion_absolute_notify; - pstate->button.notify = pointer_button_notify; - pstate->axis.notify = pointer_axis_notify; wl_signal_add(&device->pointer->events.motion, &pstate->motion); + pstate->motion_absolute.notify = pointer_motion_absolute_notify; wl_signal_add(&device->pointer->events.motion_absolute, &pstate->motion_absolute); + pstate->button.notify = pointer_button_notify; wl_signal_add(&device->pointer->events.button, &pstate->button); + pstate->axis.notify = pointer_axis_notify; wl_signal_add(&device->pointer->events.axis, &pstate->axis); wl_list_insert(&state->pointers, &pstate->link); } @@ -166,17 +197,34 @@ static void touch_cancel_notify(struct wl_listener *listener, void *data) { } } +static void touch_destroy_notify(struct wl_listener *listener, void *data) { + struct touch_state *tstate = wl_container_of(listener, tstate, destroy); + struct compositor_state *state = tstate->compositor; + if (state->input_remove_cb) { + state->input_remove_cb(state, tstate->device); + } + wl_list_remove(&tstate->link); + wl_list_remove(&tstate->destroy.link); + wl_list_remove(&tstate->down.link); + wl_list_remove(&tstate->motion.link); + wl_list_remove(&tstate->up.link); + wl_list_remove(&tstate->cancel.link); + free(tstate); +} + static void touch_add(struct wlr_input_device *device, struct compositor_state *state) { struct touch_state *tstate = calloc(sizeof(struct touch_state), 1); tstate->device = device; tstate->compositor = state; + tstate->destroy.notify = touch_destroy_notify; + wl_signal_add(&device->events.destroy, &tstate->destroy); tstate->down.notify = touch_down_notify; - tstate->motion.notify = touch_motion_notify; - tstate->up.notify = touch_up_notify; - tstate->cancel.notify = touch_cancel_notify; wl_signal_add(&device->touch->events.down, &tstate->down); + tstate->motion.notify = touch_motion_notify; wl_signal_add(&device->touch->events.motion, &tstate->motion); + tstate->up.notify = touch_up_notify; wl_signal_add(&device->touch->events.up, &tstate->up); + tstate->cancel.notify = touch_cancel_notify; wl_signal_add(&device->touch->events.cancel, &tstate->cancel); wl_list_insert(&state->touch, &tstate->link); } @@ -205,18 +253,35 @@ static void tablet_tool_button_notify(struct wl_listener *listener, void *data) } } +static void tablet_tool_destroy_notify(struct wl_listener *listener, void *data) { + struct tablet_tool_state *tstate = wl_container_of(listener, tstate, destroy); + struct compositor_state *state = tstate->compositor; + if (state->input_remove_cb) { + state->input_remove_cb(state, tstate->device); + } + wl_list_remove(&tstate->link); + wl_list_remove(&tstate->destroy.link); + wl_list_remove(&tstate->axis.link); + wl_list_remove(&tstate->proximity.link); + //wl_list_remove(&tstate->tip.link); + wl_list_remove(&tstate->button.link); + free(tstate); +} + static void tablet_tool_add(struct wlr_input_device *device, struct compositor_state *state) { struct tablet_tool_state *tstate = calloc(sizeof(struct tablet_tool_state), 1); tstate->device = device; tstate->compositor = state; + tstate->destroy.notify = tablet_tool_destroy_notify; + wl_signal_add(&device->events.destroy, &tstate->destroy); tstate->axis.notify = tablet_tool_axis_notify; - tstate->proximity.notify = tablet_tool_proximity_notify; - //tstate->tip.notify = tablet_tool_tip_notify; - tstate->button.notify = tablet_tool_button_notify; wl_signal_add(&device->tablet_tool->events.axis, &tstate->axis); + tstate->proximity.notify = tablet_tool_proximity_notify; wl_signal_add(&device->tablet_tool->events.proximity, &tstate->proximity); + //tstate->tip.notify = tablet_tool_tip_notify; //wl_signal_add(&device->tablet_tool->events.tip, &tstate->tip); + tstate->button.notify = tablet_tool_button_notify; wl_signal_add(&device->tablet_tool->events.button, &tstate->button); wl_list_insert(&state->tablet_tools, &tstate->link); } @@ -229,19 +294,33 @@ static void tablet_pad_button_notify(struct wl_listener *listener, void *data) { } } +static void tablet_pad_destroy_notify(struct wl_listener *listener, void *data) { + struct tablet_pad_state *pstate = wl_container_of(listener, pstate, destroy); + struct compositor_state *state = pstate->compositor; + if (state->input_remove_cb) { + state->input_remove_cb(state, pstate->device); + } + wl_list_remove(&pstate->link); + wl_list_remove(&pstate->destroy.link); + wl_list_remove(&pstate->button.link); + free(pstate); +} + static void tablet_pad_add(struct wlr_input_device *device, struct compositor_state *state) { struct tablet_pad_state *pstate = calloc(sizeof(struct tablet_pad_state), 1); pstate->device = device; pstate->compositor = state; + pstate->destroy.notify = tablet_pad_destroy_notify; + wl_signal_add(&device->events.destroy, &pstate->destroy); pstate->button.notify = tablet_pad_button_notify; wl_signal_add(&device->tablet_pad->events.button, &pstate->button); wl_list_insert(&state->tablet_pads, &pstate->link); } -static void input_add_notify(struct wl_listener *listener, void *data) { +static void new_input_notify(struct wl_listener *listener, void *data) { struct wlr_input_device *device = data; - struct compositor_state *state = wl_container_of(listener, state, input_add); + struct compositor_state *state = wl_container_of(listener, state, new_input); switch (device->type) { case WLR_INPUT_DEVICE_KEYBOARD: keyboard_add(device, state); @@ -267,123 +346,6 @@ static void input_add_notify(struct wl_listener *listener, void *data) { } } -static void keyboard_remove(struct wlr_input_device *device, struct compositor_state *state) { - struct keyboard_state *kbstate = NULL, *_kbstate; - wl_list_for_each(_kbstate, &state->keyboards, link) { - if (_kbstate->device == device) { - kbstate = _kbstate; - break; - } - } - if (!kbstate) { - return; - } - wl_list_remove(&kbstate->link); - wl_list_remove(&kbstate->key.link); - free(kbstate); -} - -static void pointer_remove(struct wlr_input_device *device, struct compositor_state *state) { - struct pointer_state *pstate = NULL, *_pstate; - wl_list_for_each(_pstate, &state->pointers, link) { - if (_pstate->device == device) { - pstate = _pstate; - break; - } - } - if (!pstate) { - return; - } - wl_list_remove(&pstate->link); - wl_list_remove(&pstate->motion.link); - wl_list_remove(&pstate->motion_absolute.link); - wl_list_remove(&pstate->button.link); - wl_list_remove(&pstate->axis.link); - free(pstate); -} - -static void touch_remove(struct wlr_input_device *device, struct compositor_state *state) { - struct touch_state *tstate = NULL, *_tstate; - wl_list_for_each(_tstate, &state->touch, link) { - if (_tstate->device == device) { - tstate = _tstate; - break; - } - } - if (!tstate) { - return; - } - wl_list_remove(&tstate->link); - wl_list_remove(&tstate->down.link); - wl_list_remove(&tstate->motion.link); - wl_list_remove(&tstate->up.link); - wl_list_remove(&tstate->cancel.link); - free(tstate); -} - -static void tablet_tool_remove(struct wlr_input_device *device, struct compositor_state *state) { - struct tablet_tool_state *tstate = NULL, *_tstate; - wl_list_for_each(_tstate, &state->tablet_tools, link) { - if (_tstate->device == device) { - tstate = _tstate; - break; - } - } - if (!tstate) { - return; - } - wl_list_remove(&tstate->link); - wl_list_remove(&tstate->axis.link); - wl_list_remove(&tstate->proximity.link); - //wl_list_remove(&tstate->tip.link); - wl_list_remove(&tstate->button.link); - free(tstate); -} - -static void tablet_pad_remove(struct wlr_input_device *device, struct compositor_state *state) { - struct tablet_pad_state *pstate = NULL, *_pstate; - wl_list_for_each(_pstate, &state->tablet_pads, link) { - if (_pstate->device ==device) { - pstate = _pstate; - break; - } - } - if (!pstate) { - return; - } - wl_list_remove(&pstate->button.link); - free(pstate); -} - -static void input_remove_notify(struct wl_listener *listener, void *data) { - struct wlr_input_device *device = data; - struct compositor_state *state = wl_container_of(listener, state, input_remove); - - if (state->input_remove_cb) { - state->input_remove_cb(state, device); - } - - switch (device->type) { - case WLR_INPUT_DEVICE_KEYBOARD: - keyboard_remove(device, state); - break; - case WLR_INPUT_DEVICE_POINTER: - pointer_remove(device, state); - break; - case WLR_INPUT_DEVICE_TOUCH: - touch_remove(device, state); - break; - case WLR_INPUT_DEVICE_TABLET_TOOL: - tablet_tool_remove(device, state); - break; - case WLR_INPUT_DEVICE_TABLET_PAD: - tablet_pad_remove(device, state); - break; - default: - break; - } -} - static void output_frame_notify(struct wl_listener *listener, void *data) { struct output_state *output = wl_container_of(listener, output, frame); struct compositor_state *compositor = output->compositor; @@ -407,9 +369,21 @@ static void output_resolution_notify(struct wl_listener *listener, void *data) { } } -static void output_add_notify(struct wl_listener *listener, void *data) { +static void output_destroy_notify(struct wl_listener *listener, void *data) { + struct output_state *ostate = wl_container_of(listener, ostate, destroy); + struct compositor_state *state = ostate->compositor; + if (state->output_remove_cb) { + state->output_remove_cb(ostate); + } + wl_list_remove(&ostate->link); + wl_list_remove(&ostate->frame.link); + wl_list_remove(&ostate->resolution.link); + free(ostate); +} + +static void new_output_notify(struct wl_listener *listener, void *data) { struct wlr_output *output = data; - struct compositor_state *state = wl_container_of(listener, state, output_add); + struct compositor_state *state = wl_container_of(listener, state, new_output); wlr_log(L_DEBUG, "Output '%s' added", output->name); wlr_log(L_DEBUG, "%s %s %"PRId32"mm x %"PRId32"mm", output->make, output->model, output->phys_width, output->phys_height); @@ -422,9 +396,11 @@ static void output_add_notify(struct wl_listener *listener, void *data) { clock_gettime(CLOCK_MONOTONIC, &ostate->last_frame); ostate->output = output; ostate->compositor = state; + ostate->destroy.notify = output_destroy_notify; + wl_signal_add(&output->events.destroy, &ostate->destroy); ostate->frame.notify = output_frame_notify; - ostate->resolution.notify = output_resolution_notify; wl_signal_add(&output->events.frame, &ostate->frame); + ostate->resolution.notify = output_resolution_notify; wl_signal_add(&output->events.mode, &ostate->resolution); wl_list_insert(&state->outputs, &ostate->link); if (state->output_add_cb) { @@ -432,28 +408,6 @@ static void output_add_notify(struct wl_listener *listener, void *data) { } } -static void output_remove_notify(struct wl_listener *listener, void *data) { - struct wlr_output *output = data; - struct compositor_state *state = wl_container_of(listener, state, output_remove); - struct output_state *ostate = NULL, *_ostate; - wl_list_for_each(_ostate, &state->outputs, link) { - if (_ostate->output == output) { - ostate = _ostate; - break; - } - } - if (!ostate) { - return; // We are unfamiliar with this output - } - if (state->output_remove_cb) { - state->output_remove_cb(ostate); - } - wl_list_remove(&ostate->link); - wl_list_remove(&ostate->frame.link); - wl_list_remove(&ostate->resolution.link); - free(ostate); -} - void compositor_init(struct compositor_state *state) { state->display = wl_display_create(); state->event_loop = wl_display_get_event_loop(state->display); @@ -463,23 +417,19 @@ void compositor_init(struct compositor_state *state) { wl_list_init(&state->touch); wl_list_init(&state->tablet_tools); wl_list_init(&state->tablet_pads); - state->input_add.notify = input_add_notify; - state->input_remove.notify = input_remove_notify; - wl_list_init(&state->outputs); - state->output_add.notify = output_add_notify; - state->output_remove.notify = output_remove_notify; struct wlr_backend *wlr = wlr_backend_autocreate(state->display); if (!wlr) { exit(1); } - wl_signal_add(&wlr->events.input_add, &state->input_add); - wl_signal_add(&wlr->events.input_remove, &state->input_remove); - wl_signal_add(&wlr->events.output_add, &state->output_add); - wl_signal_add(&wlr->events.output_remove, &state->output_remove); state->backend = wlr; + wl_signal_add(&wlr->events.new_input, &state->new_input); + state->new_input.notify = new_input_notify; + wl_signal_add(&wlr->events.new_output, &state->new_output); + state->new_output.notify = new_output_notify; + clock_gettime(CLOCK_MONOTONIC, &state->last_frame); const char *socket = wl_display_add_socket_auto(state->display); diff --git a/examples/support/shared.h b/examples/support/shared.h index 014b709e..8cdea301 100644 --- a/examples/support/shared.h +++ b/examples/support/shared.h @@ -15,6 +15,7 @@ struct output_state { struct compositor_state *compositor; struct wlr_output *output; + struct wl_listener destroy; struct wl_listener frame; struct wl_listener resolution; struct timespec last_frame; @@ -25,6 +26,7 @@ struct output_state { struct keyboard_state { struct compositor_state *compositor; struct wlr_input_device *device; + struct wl_listener destroy; struct wl_listener key; struct wl_list link; void *data; @@ -33,6 +35,7 @@ struct keyboard_state { struct pointer_state { struct compositor_state *compositor; struct wlr_input_device *device; + struct wl_listener destroy; struct wl_listener motion; struct wl_listener motion_absolute; struct wl_listener button; @@ -44,6 +47,7 @@ struct pointer_state { struct touch_state { struct compositor_state *compositor; struct wlr_input_device *device; + struct wl_listener destroy; struct wl_listener down; struct wl_listener up; struct wl_listener motion; @@ -55,6 +59,7 @@ struct touch_state { struct tablet_tool_state { struct compositor_state *compositor; struct wlr_input_device *device; + struct wl_listener destroy; struct wl_listener axis; struct wl_listener proximity; struct wl_listener tip; @@ -66,6 +71,7 @@ struct tablet_tool_state { struct tablet_pad_state { struct compositor_state *compositor; struct wlr_input_device *device; + struct wl_listener destroy; struct wl_listener button; struct wl_list link; void *data; @@ -122,12 +128,10 @@ struct compositor_state { struct wl_list touch; struct wl_list tablet_tools; struct wl_list tablet_pads; - struct wl_listener input_add; - struct wl_listener input_remove; + struct wl_listener new_input; struct timespec last_frame; - struct wl_listener output_add; - struct wl_listener output_remove; + struct wl_listener new_output; struct wl_list outputs; void *data; diff --git a/include/backend/drm/drm.h b/include/backend/drm/drm.h index 12530da6..65db04ef 100644 --- a/include/backend/drm/drm.h +++ b/include/backend/drm/drm.h @@ -1,19 +1,17 @@ #ifndef BACKEND_DRM_DRM_H #define BACKEND_DRM_DRM_H +#include <EGL/egl.h> +#include <gbm.h> #include <stdbool.h> #include <stddef.h> #include <stdint.h> #include <wayland-server.h> -#include <xf86drmMode.h> -#include <EGL/egl.h> -#include <gbm.h> #include <wayland-util.h> - -#include <wlr/backend/session.h> #include <wlr/backend/drm.h> +#include <wlr/backend/session.h> #include <wlr/render/egl.h> - +#include <xf86drmMode.h> #include "iface.h" #include "properties.h" #include "renderer.h" diff --git a/include/backend/drm/iface.h b/include/backend/drm/iface.h index 15cdf1ab..ef0e7bf8 100644 --- a/include/backend/drm/iface.h +++ b/include/backend/drm/iface.h @@ -1,10 +1,9 @@ #ifndef BACKEND_DRM_IFACE_H #define BACKEND_DRM_IFACE_H +#include <gbm.h> #include <stdbool.h> #include <stdint.h> - -#include <gbm.h> #include <xf86drm.h> #include <xf86drmMode.h> diff --git a/include/backend/drm/renderer.h b/include/backend/drm/renderer.h index bf0165bc..a56a8673 100644 --- a/include/backend/drm/renderer.h +++ b/include/backend/drm/renderer.h @@ -1,12 +1,10 @@ #ifndef BACKEND_DRM_RENDERER_H #define BACKEND_DRM_RENDERER_H -#include <stdbool.h> -#include <stdint.h> - #include <EGL/egl.h> #include <gbm.h> - +#include <stdbool.h> +#include <stdint.h> #include <wlr/render.h> struct wlr_drm_backend; diff --git a/include/backend/drm/util.h b/include/backend/drm/util.h index 6818b4db..25da858f 100644 --- a/include/backend/drm/util.h +++ b/include/backend/drm/util.h @@ -2,9 +2,9 @@ #define BACKEND_DRM_UTIL_H #include <stdint.h> +#include <wlr/types/wlr_output.h> #include <xf86drm.h> #include <xf86drmMode.h> -#include <wlr/types/wlr_output.h> // Calculates a more accurate refresh rate (mHz) than what mode itself provides int32_t calculate_refresh_rate(drmModeModeInfo *mode); diff --git a/include/backend/headless.h b/include/backend/headless.h index f9805bcc..e130bae1 100644 --- a/include/backend/headless.h +++ b/include/backend/headless.h @@ -1,8 +1,8 @@ #ifndef BACKEND_HEADLESS_H #define BACKEND_HEADLESS_H -#include <wlr/backend/interface.h> #include <wlr/backend/headless.h> +#include <wlr/backend/interface.h> struct wlr_headless_backend { struct wlr_backend backend; diff --git a/include/backend/libinput.h b/include/backend/libinput.h index 6ec718c6..f828c310 100644 --- a/include/backend/libinput.h +++ b/include/backend/libinput.h @@ -1,10 +1,11 @@ #ifndef BACKEND_LIBINPUT_H #define BACKEND_LIBINPUT_H + #include <libinput.h> #include <wayland-server-core.h> -#include <wlr/types/wlr_input_device.h> #include <wlr/backend/interface.h> #include <wlr/interfaces/wlr_input_device.h> +#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_list.h> struct wlr_libinput_backend { diff --git a/include/backend/multi.h b/include/backend/multi.h index 3363c608..c57c48f3 100644 --- a/include/backend/multi.h +++ b/include/backend/multi.h @@ -1,10 +1,10 @@ #ifndef BACKEND_MULTI_H #define BACKEND_MULTI_H +#include <wayland-util.h> #include <wlr/backend/interface.h> #include <wlr/backend/multi.h> #include <wlr/backend/session.h> -#include <wayland-util.h> struct wlr_multi_backend { struct wlr_backend backend; diff --git a/include/backend/wayland.h b/include/backend/wayland.h index 78a88f29..16c8e13b 100644 --- a/include/backend/wayland.h +++ b/include/backend/wayland.h @@ -3,13 +3,13 @@ #include <stdbool.h> #include <wayland-client.h> -#include <wayland-server.h> #include <wayland-egl.h> -#include <wlr/render/egl.h> -#include <wlr/render.h> +#include <wayland-server.h> +#include <wayland-util.h> #include <wlr/backend/wayland.h> +#include <wlr/render.h> +#include <wlr/render/egl.h> #include <wlr/types/wlr_box.h> -#include <wayland-util.h> struct wlr_wl_backend { struct wlr_backend backend; diff --git a/include/backend/x11.h b/include/backend/x11.h index fee39eac..c5f258c0 100644 --- a/include/backend/x11.h +++ b/include/backend/x11.h @@ -1,11 +1,11 @@ -#ifndef WLR_X11_H -#define WLR_X11_H +#ifndef BACKEND_X11_H +#define BACKEND_X11_H #include <stdbool.h> -#include <xcb/xcb.h> -#include <X11/Xlib-xcb.h> #include <wayland-server.h> #include <wlr/render/egl.h> +#include <X11/Xlib-xcb.h> +#include <xcb/xcb.h> struct wlr_x11_backend; diff --git a/include/render/gles2.h b/include/render/gles2.h index 0b7032cc..797c5293 100644 --- a/include/render/gles2.h +++ b/include/render/gles2.h @@ -1,13 +1,13 @@ #ifndef RENDER_GLES2_H #define RENDER_GLES2_H -#include <stdint.h> -#include <string.h> -#include <stdbool.h> -#include <GLES2/gl2.h> -#include <GLES2/gl2ext.h> #include <EGL/egl.h> #include <EGL/eglext.h> +#include <GLES2/gl2.h> +#include <GLES2/gl2ext.h> +#include <stdbool.h> +#include <stdint.h> +#include <string.h> #include <wlr/backend.h> #include <wlr/render.h> #include <wlr/render/egl.h> diff --git a/include/rootston/config.h b/include/rootston/config.h index 05f23b75..9926d9c2 100644 --- a/include/rootston/config.h +++ b/include/rootston/config.h @@ -1,7 +1,8 @@ -#ifndef _ROOTSTON_CONFIG_H -#define _ROOTSTON_CONFIG_H -#include <wlr/types/wlr_output_layout.h> +#ifndef ROOTSTON_CONFIG_H +#define ROOTSTON_CONFIG_H + #include <wlr/types/wlr_input_device.h> +#include <wlr/types/wlr_output_layout.h> #define ROOTS_CONFIG_DEFAULT_SEAT_NAME "seat0" diff --git a/include/rootston/cursor.h b/include/rootston/cursor.h index 90d54c12..a1a466c2 100644 --- a/include/rootston/cursor.h +++ b/include/rootston/cursor.h @@ -1,5 +1,5 @@ -#ifndef _ROOTSTON_CURSOR_H -#define _ROOTSTON_CURSOR_H +#ifndef ROOTSTON_CURSOR_H +#define ROOTSTON_CURSOR_H #include "rootston/seat.h" diff --git a/include/rootston/desktop.h b/include/rootston/desktop.h index 1232121a..6572b242 100644 --- a/include/rootston/desktop.h +++ b/include/rootston/desktop.h @@ -1,22 +1,23 @@ -#ifndef _ROOTSTON_DESKTOP_H -#define _ROOTSTON_DESKTOP_H +#ifndef ROOTSTON_DESKTOP_H +#define ROOTSTON_DESKTOP_H + #include <time.h> #include <wayland-server.h> #include <wlr/config.h> -#include <wlr/types/wlr_output.h> -#include <wlr/types/wlr_output_layout.h> #include <wlr/types/wlr_compositor.h> -#include <wlr/types/wlr_wl_shell.h> -#include <wlr/types/wlr_xdg_shell_v6.h> -#include <wlr/types/wlr_xcursor_manager.h> #include <wlr/types/wlr_gamma_control.h> +#include <wlr/types/wlr_idle.h> +#include <wlr/types/wlr_list.h> +#include <wlr/types/wlr_output_layout.h> +#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_primary_selection.h> #include <wlr/types/wlr_screenshooter.h> -#include <wlr/types/wlr_list.h> -#include <wlr/types/wlr_idle.h> -#include "rootston/view.h" +#include <wlr/types/wlr_wl_shell.h> +#include <wlr/types/wlr_xcursor_manager.h> +#include <wlr/types/wlr_xdg_shell_v6.h> #include "rootston/config.h" #include "rootston/output.h" +#include "rootston/view.h" struct roots_desktop { struct wl_list views; // roots_view::link @@ -39,8 +40,7 @@ struct roots_desktop { struct wlr_primary_selection_device_manager *primary_selection_device_manager; struct wlr_idle *idle; - struct wl_listener output_add; - struct wl_listener output_remove; + struct wl_listener new_output; struct wl_listener layout_change; struct wl_listener xdg_shell_v6_surface; struct wl_listener wl_shell_surface; diff --git a/include/rootston/input.h b/include/rootston/input.h index 726dda24..4395a0f7 100644 --- a/include/rootston/input.h +++ b/include/rootston/input.h @@ -1,20 +1,20 @@ -#ifndef _ROOTSTON_INPUT_H -#define _ROOTSTON_INPUT_H +#ifndef ROOTSTON_INPUT_H +#define ROOTSTON_INPUT_H + #include <wayland-server.h> -#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_cursor.h> +#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_seat.h> -#include "rootston/cursor.h" #include "rootston/config.h" -#include "rootston/view.h" +#include "rootston/cursor.h" #include "rootston/server.h" +#include "rootston/view.h" struct roots_input { struct roots_config *config; struct roots_server *server; - struct wl_listener input_add; - struct wl_listener input_remove; + struct wl_listener new_input; struct wl_list seats; }; diff --git a/include/rootston/keyboard.h b/include/rootston/keyboard.h index 39650d7c..0140389a 100644 --- a/include/rootston/keyboard.h +++ b/include/rootston/keyboard.h @@ -1,5 +1,5 @@ -#ifndef _ROOTSTON_KEYBOARD_H -#define _ROOTSTON_KEYBOARD_H +#ifndef ROOTSTON_KEYBOARD_H +#define ROOTSTON_KEYBOARD_H #include <xkbcommon/xkbcommon.h> #include "rootston/input.h" @@ -13,6 +13,7 @@ struct roots_keyboard { struct roots_keyboard_config *config; struct wl_list link; + struct wl_listener device_destroy; struct wl_listener keyboard_key; struct wl_listener keyboard_modifiers; diff --git a/include/rootston/output.h b/include/rootston/output.h index 7f42904f..9682e4f5 100644 --- a/include/rootston/output.h +++ b/include/rootston/output.h @@ -1,8 +1,8 @@ -#ifndef _ROOTSTON_OUTPUT_H -#define _ROOTSTON_OUTPUT_H +#ifndef ROOTSTON_OUTPUT_H +#define ROOTSTON_OUTPUT_H -#include <time.h> #include <pixman.h> +#include <time.h> #include <wayland-server.h> #include <wlr/types/wlr_output_damage.h> @@ -18,11 +18,11 @@ struct roots_output { struct timespec last_frame; struct wlr_output_damage *damage; + struct wl_listener destroy; struct wl_listener frame; }; -void output_add_notify(struct wl_listener *listener, void *data); -void output_remove_notify(struct wl_listener *listener, void *data); +void handle_new_output(struct wl_listener *listener, void *data); struct roots_view; struct roots_drag_icon; diff --git a/include/rootston/seat.h b/include/rootston/seat.h index 0047522c..cc0293b5 100644 --- a/include/rootston/seat.h +++ b/include/rootston/seat.h @@ -1,5 +1,6 @@ -#ifndef _ROOTSTON_SEAT_H -#define _ROOTSTON_SEAT_H +#ifndef ROOTSTON_SEAT_H +#define ROOTSTON_SEAT_H + #include <wayland-server.h> #include "rootston/input.h" #include "rootston/keyboard.h" @@ -56,18 +57,21 @@ struct roots_drag_icon { struct roots_pointer { struct roots_seat *seat; struct wlr_input_device *device; + struct wl_listener device_destroy; struct wl_list link; }; struct roots_touch { struct roots_seat *seat; struct wlr_input_device *device; + struct wl_listener device_destroy; struct wl_list link; }; struct roots_tablet_tool { struct roots_seat *seat; struct wlr_input_device *device; + struct wl_listener device_destroy; struct wl_listener axis; struct wl_listener proximity; struct wl_listener tip; diff --git a/include/rootston/server.h b/include/rootston/server.h index 0c26ea92..5f35dd90 100644 --- a/include/rootston/server.h +++ b/include/rootston/server.h @@ -1,11 +1,12 @@ #ifndef _ROOTSTON_SERVER_H #define _ROOTSTON_SERVER_H + #include <wayland-server.h> -#include <wlr/config.h> #include <wlr/backend.h> #include <wlr/backend/session.h> -#include <wlr/types/wlr_data_device.h> +#include <wlr/config.h> #include <wlr/render.h> +#include <wlr/types/wlr_data_device.h> #ifdef WLR_HAS_XWAYLAND #include <wlr/xwayland.h> #endif diff --git a/include/rootston/view.h b/include/rootston/view.h index f6968c7a..b61ac330 100644 --- a/include/rootston/view.h +++ b/include/rootston/view.h @@ -1,5 +1,5 @@ -#ifndef _ROOTSTON_VIEW_H -#define _ROOTSTON_VIEW_H +#ifndef ROOTSTON_VIEW_H +#define ROOTSTON_VIEW_H #include <stdbool.h> #include <wlr/config.h> diff --git a/include/rootston/xcursor.h b/include/rootston/xcursor.h index a7d2b960..f78489a4 100644 --- a/include/rootston/xcursor.h +++ b/include/rootston/xcursor.h @@ -1,5 +1,5 @@ -#ifndef _ROOTSTON_XCURSOR_H -#define _ROOTSTON_XCURSOR_H +#ifndef ROOTSTON_XCURSOR_H +#define ROOTSTON_XCURSOR_H #include <stdint.h> diff --git a/include/util/os-compatibility.h b/include/util/os-compatibility.h index b2ec2db9..2038025e 100644 --- a/include/util/os-compatibility.h +++ b/include/util/os-compatibility.h @@ -1,12 +1,9 @@ -#ifndef _WLR_UTIL_OS_COMPATIBILITY_H -#define _WLR_UTIL_OS_COMPATIBILITY_H +#ifndef UTIL_OS_COMPATIBILITY_H +#define UTIL_OS_COMPATIBILITY_H int os_fd_set_cloexec(int fd); - int set_cloexec_or_close(int fd); - int create_tmpfile_cloexec(char *tmpname); - int os_create_anonymous_file(off_t size); #endif diff --git a/include/util/signal.h b/include/util/signal.h new file mode 100644 index 00000000..cc6cb525 --- /dev/null +++ b/include/util/signal.h @@ -0,0 +1,8 @@ +#ifndef UTIL_SIGNAL_H +#define UTIL_SIGNAL_H + +#include <wayland-server.h> + +void wlr_signal_emit_safe(struct wl_signal *signal, void *data); + +#endif diff --git a/include/wlr/backend.h b/include/wlr/backend.h index d4b1f773..00dc9fdc 100644 --- a/include/wlr/backend.h +++ b/include/wlr/backend.h @@ -12,10 +12,8 @@ struct wlr_backend { struct { struct wl_signal destroy; - struct wl_signal input_add; - struct wl_signal input_remove; - struct wl_signal output_add; - struct wl_signal output_remove; + struct wl_signal new_input; + struct wl_signal new_output; } events; }; diff --git a/include/wlr/backend/drm.h b/include/wlr/backend/drm.h index 133e4f69..90460647 100644 --- a/include/wlr/backend/drm.h +++ b/include/wlr/backend/drm.h @@ -2,8 +2,8 @@ #define WLR_BACKEND_DRM_H #include <wayland-server.h> -#include <wlr/backend/session.h> #include <wlr/backend.h> +#include <wlr/backend/session.h> #include <wlr/types/wlr_output.h> struct wlr_backend *wlr_drm_backend_create(struct wl_display *display, diff --git a/include/wlr/backend/libinput.h b/include/wlr/backend/libinput.h index af873628..c7cfe894 100644 --- a/include/wlr/backend/libinput.h +++ b/include/wlr/backend/libinput.h @@ -3,8 +3,8 @@ #include <libinput.h> #include <wayland-server.h> -#include <wlr/backend/session.h> #include <wlr/backend.h> +#include <wlr/backend/session.h> #include <wlr/types/wlr_input_device.h> struct wlr_backend *wlr_libinput_backend_create(struct wl_display *display, diff --git a/include/wlr/backend/multi.h b/include/wlr/backend/multi.h index d9914efc..2dee7403 100644 --- a/include/wlr/backend/multi.h +++ b/include/wlr/backend/multi.h @@ -5,17 +5,12 @@ #include <wlr/backend/session.h> struct wlr_backend *wlr_multi_backend_create(struct wl_display *display); - void wlr_multi_backend_add(struct wlr_backend *multi, struct wlr_backend *backend); - void wlr_multi_backend_remove(struct wlr_backend *multi, struct wlr_backend *backend); - 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); #endif diff --git a/include/wlr/backend/session.h b/include/wlr/backend/session.h index 3242a13f..7ff9691f 100644 --- a/include/wlr/backend/session.h +++ b/include/wlr/backend/session.h @@ -1,10 +1,10 @@ #ifndef WLR_BACKEND_SESSION_H #define WLR_BACKEND_SESSION_H -#include <stdbool.h> -#include <wayland-server.h> #include <libudev.h> +#include <stdbool.h> #include <sys/types.h> +#include <wayland-server.h> struct session_impl; diff --git a/include/wlr/backend/wayland.h b/include/wlr/backend/wayland.h index f89a6383..e28ffff5 100644 --- a/include/wlr/backend/wayland.h +++ b/include/wlr/backend/wayland.h @@ -1,12 +1,12 @@ #ifndef WLR_BACKEND_WAYLAND_H #define WLR_BACKEND_WAYLAND_H +#include <stdbool.h> #include <wayland-client.h> #include <wayland-server.h> #include <wlr/backend.h> #include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_output.h> -#include <stdbool.h> /** * Creates a new wlr_wl_backend. This backend will be created with no outputs; diff --git a/include/wlr/interfaces/wlr_keyboard.h b/include/wlr/interfaces/wlr_keyboard.h index 570f5721..6960ea87 100644 --- a/include/wlr/interfaces/wlr_keyboard.h +++ b/include/wlr/interfaces/wlr_keyboard.h @@ -1,8 +1,8 @@ #ifndef WLR_INTERFACES_WLR_KEYBOARD_H #define WLR_INTERFACES_WLR_KEYBOARD_H -#include <wlr/types/wlr_keyboard.h> #include <stdint.h> +#include <wlr/types/wlr_keyboard.h> struct wlr_keyboard_impl { void (*destroy)(struct wlr_keyboard *keyboard); diff --git a/include/wlr/interfaces/wlr_output.h b/include/wlr/interfaces/wlr_output.h index a01f8901..5edd1ae1 100644 --- a/include/wlr/interfaces/wlr_output.h +++ b/include/wlr/interfaces/wlr_output.h @@ -2,9 +2,9 @@ #define WLR_INTERFACES_WLR_OUTPUT_H #include <stdbool.h> +#include <wlr/backend.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_output.h> -#include <wlr/backend.h> struct wlr_output_impl { void (*enable)(struct wlr_output *output, bool enable); diff --git a/include/wlr/render.h b/include/wlr/render.h index ccc66d36..3743482b 100644 --- a/include/wlr/render.h +++ b/include/wlr/render.h @@ -1,9 +1,9 @@ #ifndef WLR_RENDER_H #define WLR_RENDER_H -#include <stdint.h> #include <EGL/egl.h> #include <EGL/eglext.h> +#include <stdint.h> #include <wayland-server-protocol.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_output.h> diff --git a/include/wlr/render/egl.h b/include/wlr/render/egl.h index 1facc6b8..97a28016 100644 --- a/include/wlr/render/egl.h +++ b/include/wlr/render/egl.h @@ -1,10 +1,10 @@ -#ifndef WLR_EGL_H -#define WLR_EGL_H +#ifndef WLR_RENDER_EGL_H +#define WLR_RENDER_EGL_H -#include <stdbool.h> #include <EGL/egl.h> #include <EGL/eglext.h> #include <pixman.h> +#include <stdbool.h> #include <wayland-server.h> struct wlr_egl { diff --git a/include/wlr/render/gles2.h b/include/wlr/render/gles2.h index 25e760d5..a924a065 100644 --- a/include/wlr/render/gles2.h +++ b/include/wlr/render/gles2.h @@ -1,8 +1,8 @@ #ifndef WLR_RENDER_GLES2_H #define WLR_RENDER_GLES2_H -#include <wlr/render.h> #include <wlr/backend.h> +#include <wlr/render.h> struct wlr_egl; struct wlr_renderer *wlr_gles2_renderer_create(struct wlr_backend *backend); diff --git a/include/wlr/render/interface.h b/include/wlr/render/interface.h index b8e99898..b989e399 100644 --- a/include/wlr/render/interface.h +++ b/include/wlr/render/interface.h @@ -1,10 +1,10 @@ #ifndef WLR_RENDER_INTERFACE_H #define WLR_RENDER_INTERFACE_H -#include <wayland-server-protocol.h> #include <EGL/egl.h> #include <EGL/eglext.h> #include <stdbool.h> +#include <wayland-server-protocol.h> #include <wlr/render.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_output.h> diff --git a/include/wlr/types/wlr_cursor.h b/include/wlr/types/wlr_cursor.h index e072ca05..da010972 100644 --- a/include/wlr/types/wlr_cursor.h +++ b/include/wlr/types/wlr_cursor.h @@ -2,10 +2,10 @@ #define WLR_TYPES_WLR_CURSOR_H #include <wayland-server.h> -#include <wlr/types/wlr_output.h> -#include <wlr/types/wlr_output_layout.h> -#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_box.h> +#include <wlr/types/wlr_input_device.h> +#include <wlr/types/wlr_output_layout.h> +#include <wlr/types/wlr_output.h> struct wlr_cursor_state; diff --git a/include/wlr/types/wlr_keyboard.h b/include/wlr/types/wlr_keyboard.h index c67cc4c2..ed0427e8 100644 --- a/include/wlr/types/wlr_keyboard.h +++ b/include/wlr/types/wlr_keyboard.h @@ -1,9 +1,9 @@ #ifndef WLR_TYPES_WLR_KEYBOARD_H #define WLR_TYPES_WLR_KEYBOARD_H -#include <wayland-server.h> -#include <stdint.h> #include <stdbool.h> +#include <stdint.h> +#include <wayland-server.h> #include <wayland-server.h> #include <xkbcommon/xkbcommon.h> diff --git a/include/wlr/types/wlr_list.h b/include/wlr/types/wlr_list.h index 78a30995..23bf53b7 100644 --- a/include/wlr/types/wlr_list.h +++ b/include/wlr/types/wlr_list.h @@ -1,8 +1,8 @@ -#ifndef WLR_UTIL_LIST_H -#define WLR_UTIL_LIST_H +#ifndef WLR_TYPES_WLR_LIST_H +#define WLR_TYPES_WLR_LIST_H -#include <stddef.h> #include <stdbool.h> +#include <stddef.h> struct wlr_list { size_t capacity; diff --git a/include/wlr/types/wlr_output.h b/include/wlr/types/wlr_output.h index 8eed06fe..5c2ffee0 100644 --- a/include/wlr/types/wlr_output.h +++ b/include/wlr/types/wlr_output.h @@ -1,11 +1,11 @@ #ifndef WLR_TYPES_WLR_OUTPUT_H #define WLR_TYPES_WLR_OUTPUT_H +#include <pixman.h> #include <stdbool.h> #include <time.h> -#include <pixman.h> -#include <wayland-util.h> #include <wayland-server.h> +#include <wayland-util.h> struct wlr_output_mode { uint32_t flags; // enum wl_output_mode diff --git a/include/wlr/types/wlr_output_damage.h b/include/wlr/types/wlr_output_damage.h index 52cbce78..6682f942 100644 --- a/include/wlr/types/wlr_output_damage.h +++ b/include/wlr/types/wlr_output_damage.h @@ -1,8 +1,8 @@ #ifndef WLR_TYPES_WLR_OUTPUT_DAMAGE_H #define WLR_TYPES_WLR_OUTPUT_DAMAGE_H -#include <time.h> #include <pixman.h> +#include <time.h> #include <wlr/types/wlr_output.h> /** diff --git a/include/wlr/types/wlr_output_layout.h b/include/wlr/types/wlr_output_layout.h index 9187b377..7dd2b16a 100644 --- a/include/wlr/types/wlr_output_layout.h +++ b/include/wlr/types/wlr_output_layout.h @@ -1,10 +1,10 @@ #ifndef WLR_TYPES_WLR_OUTPUT_LAYOUT_H #define WLR_TYPES_WLR_OUTPUT_LAYOUT_H +#include <stdbool.h> +#include <wayland-util.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_output.h> -#include <wayland-util.h> -#include <stdbool.h> struct wlr_output_layout_state; diff --git a/include/wlr/types/wlr_pointer.h b/include/wlr/types/wlr_pointer.h index 3a6d2175..e7ac9b46 100644 --- a/include/wlr/types/wlr_pointer.h +++ b/include/wlr/types/wlr_pointer.h @@ -1,9 +1,9 @@ #ifndef WLR_TYPES_WLR_POINTER_H #define WLR_TYPES_WLR_POINTER_H -#include <wlr/types/wlr_input_device.h> -#include <wayland-server.h> #include <stdint.h> +#include <wayland-server.h> +#include <wlr/types/wlr_input_device.h> struct wlr_pointer_impl; diff --git a/include/wlr/types/wlr_primary_selection.h b/include/wlr/types/wlr_primary_selection.h index da3c096a..78f23ad6 100644 --- a/include/wlr/types/wlr_primary_selection.h +++ b/include/wlr/types/wlr_primary_selection.h @@ -1,8 +1,8 @@ #ifndef WLR_TYPES_WLR_PRIMARY_SELECTION_H #define WLR_TYPES_WLR_PRIMARY_SELECTION_H -#include <wlr/types/wlr_seat.h> #include <wayland-server.h> +#include <wlr/types/wlr_seat.h> struct wlr_primary_selection_device_manager { struct wl_global *global; diff --git a/include/wlr/types/wlr_screenshooter.h b/include/wlr/types/wlr_screenshooter.h index cfe7742d..680d86f0 100644 --- a/include/wlr/types/wlr_screenshooter.h +++ b/include/wlr/types/wlr_screenshooter.h @@ -1,5 +1,6 @@ -#ifndef _WLR_SCREENSHOOTER_H -#define _WLR_SCREENSHOOTER_H +#ifndef WLR_TYPES_WLR_SCREENSHOOTER_H +#define WLR_TYPES_WLR_SCREENSHOOTER_H + #include <wayland-server.h> struct wlr_screenshooter { diff --git a/include/wlr/types/wlr_seat.h b/include/wlr/types/wlr_seat.h index ffdabd98..b03cab6e 100644 --- a/include/wlr/types/wlr_seat.h +++ b/include/wlr/types/wlr_seat.h @@ -1,10 +1,11 @@ #ifndef WLR_TYPES_WLR_SEAT_H #define WLR_TYPES_WLR_SEAT_H + #include <time.h> -#include <wlr/types/wlr_surface.h> +#include <wayland-server.h> #include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_keyboard.h> -#include <wayland-server.h> +#include <wlr/types/wlr_surface.h> /** * Contains state for a single client's bound wl_seat resource and can be used diff --git a/include/wlr/types/wlr_surface.h b/include/wlr/types/wlr_surface.h index 50316abc..998b5ae5 100644 --- a/include/wlr/types/wlr_surface.h +++ b/include/wlr/types/wlr_surface.h @@ -1,9 +1,10 @@ #ifndef WLR_TYPES_WLR_SURFACE_H #define WLR_TYPES_WLR_SURFACE_H -#include <stdint.h> + +#include <pixman.h> #include <stdbool.h> +#include <stdint.h> #include <time.h> -#include <pixman.h> #include <wayland-server.h> #include <wlr/types/wlr_output.h> diff --git a/include/wlr/types/wlr_tablet_pad.h b/include/wlr/types/wlr_tablet_pad.h index 51a65dd1..e70db516 100644 --- a/include/wlr/types/wlr_tablet_pad.h +++ b/include/wlr/types/wlr_tablet_pad.h @@ -1,9 +1,9 @@ #ifndef WLR_TYPES_WLR_TABLET_PAD_H #define WLR_TYPES_WLR_TABLET_PAD_H -#include <wlr/types/wlr_input_device.h> -#include <wayland-server.h> #include <stdint.h> +#include <wayland-server.h> +#include <wlr/types/wlr_input_device.h> /* * NOTE: the wlr tablet pad implementation does not currently support tablets diff --git a/include/wlr/types/wlr_tablet_tool.h b/include/wlr/types/wlr_tablet_tool.h index c6984d4d..59e49ef8 100644 --- a/include/wlr/types/wlr_tablet_tool.h +++ b/include/wlr/types/wlr_tablet_tool.h @@ -1,9 +1,9 @@ #ifndef WLR_TYPES_TABLET_TOOL_H #define WLR_TYPES_TABLET_TOOL_H -#include <wlr/types/wlr_input_device.h> -#include <wayland-server.h> #include <stdint.h> +#include <wayland-server.h> +#include <wlr/types/wlr_input_device.h> struct wlr_tablet_tool_impl; diff --git a/include/wlr/types/wlr_touch.h b/include/wlr/types/wlr_touch.h index 2925fd01..8ea293eb 100644 --- a/include/wlr/types/wlr_touch.h +++ b/include/wlr/types/wlr_touch.h @@ -1,8 +1,8 @@ #ifndef WLR_TYPES_WLR_TOUCH_H #define WLR_TYPES_WLR_TOUCH_H -#include <wayland-server.h> #include <stdint.h> +#include <wayland-server.h> struct wlr_touch_impl; diff --git a/include/wlr/types/wlr_xdg_shell_v6.h b/include/wlr/types/wlr_xdg_shell_v6.h index c7b1a24b..7dc746ce 100644 --- a/include/wlr/types/wlr_xdg_shell_v6.h +++ b/include/wlr/types/wlr_xdg_shell_v6.h @@ -1,9 +1,9 @@ #ifndef WLR_TYPES_WLR_XDG_SHELL_V6_H #define WLR_TYPES_WLR_XDG_SHELL_V6_H +#include <wayland-server.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_seat.h> -#include <wayland-server.h> struct wlr_xdg_shell_v6 { struct wl_global *wl_global; diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h index c0135943..ad7ceb83 100644 --- a/include/wlr/xwayland.h +++ b/include/wlr/xwayland.h @@ -1,8 +1,8 @@ #ifndef WLR_XWAYLAND_H #define WLR_XWAYLAND_H -#include <time.h> #include <stdbool.h> +#include <time.h> #include <wlr/config.h> #include <wlr/types/wlr_compositor.h> #include <wlr/types/wlr_seat.h> diff --git a/include/wlr/xwm.h b/include/wlr/xwm.h index 35c43b18..242ff9cc 100644 --- a/include/wlr/xwm.h +++ b/include/wlr/xwm.h @@ -1,9 +1,9 @@ -#ifndef XWAYLAND_INTERNALS_H -#define XWAYLAND_INTERNALS_H +#ifndef WLR_XWM_H +#define WLR_XWM_H -#include <xcb/render.h> #include <wayland-server-core.h> #include <wlr/xwayland.h> +#include <xcb/render.h> enum atom_name { WL_SURFACE_ID, diff --git a/meson.build b/meson.build index 6c8a3a8b..1cf7781a 100644 --- a/meson.build +++ b/meson.build @@ -157,16 +157,16 @@ wlroots = declare_dependency( summary = [ - '', - '----------------', - 'wlroots @0@'.format(meson.project_version()), - '', - ' libcap: @0@'.format(conf_data.get('WLR_HAS_LIBCAP', false)), - ' systemd: @0@'.format(conf_data.get('WLR_HAS_SYSTEMD', false)), - ' elogind: @0@'.format(conf_data.get('WLR_HAS_ELOGIND', false)), - ' xwayland: @0@'.format(conf_data.get('WLR_HAS_XWAYLAND', false)), - '----------------', - '' + '', + '----------------', + 'wlroots @0@'.format(meson.project_version()), + '', + ' libcap: @0@'.format(conf_data.get('WLR_HAS_LIBCAP', false)), + ' systemd: @0@'.format(conf_data.get('WLR_HAS_SYSTEMD', false)), + ' elogind: @0@'.format(conf_data.get('WLR_HAS_ELOGIND', false)), + ' xwayland: @0@'.format(conf_data.get('WLR_HAS_XWAYLAND', false)), + '----------------', + '' ] message('\n'.join(summary)) @@ -195,18 +195,18 @@ if git.found() etags = find_program('etags', required: false) if etags.found() and all_files.length() > 0 custom_target('etags', - build_by_default: true, - input: all_files, - output: 'TAGS', - command: [etags.path(), '-o', 'TAGS'] + all_files) + build_by_default: true, + input: all_files, + output: 'TAGS', + command: [etags.path(), '-o', 'TAGS'] + all_files) endif ctags = find_program('ctags', required: false) if ctags.found() and all_files.length() > 0 custom_target('ctags', - build_by_default: true, - input: all_files, - output: 'tags', - command: [ctags.path(), '-o', 'tags'] + all_files) + build_by_default: true, + input: all_files, + output: 'tags', + command: [ctags.path(), '-o', 'tags'] + all_files) endif endif diff --git a/protocol/meson.build b/protocol/meson.build index 6e9f4125..0db7c03c 100644 --- a/protocol/meson.build +++ b/protocol/meson.build @@ -24,18 +24,18 @@ protocols = [ [wl_protocol_dir, 'unstable/xdg-shell/xdg-shell-unstable-v6.xml'], 'gamma-control.xml', 'gtk-primary-selection.xml', + 'idle.xml', 'screenshooter.xml', 'server-decoration.xml', - 'idle.xml', ] client_protocols = [ [wl_protocol_dir, 'unstable/xdg-shell/xdg-shell-unstable-v6.xml'], 'gamma-control.xml', 'gtk-primary-selection.xml', + 'idle.xml', 'screenshooter.xml', 'server-decoration.xml', - 'idle.xml', ] wl_protos_src = [] diff --git a/render/egl.c b/render/egl.c index 328726ba..f1208a72 100644 --- a/render/egl.c +++ b/render/egl.c @@ -1,10 +1,10 @@ #include <assert.h> -#include <stdlib.h> #include <EGL/egl.h> #include <EGL/eglext.h> #include <GLES2/gl2.h> -#include <wlr/util/log.h> +#include <stdlib.h> #include <wlr/render/egl.h> +#include <wlr/util/log.h> #include "glapi.h" // Extension documentation diff --git a/render/gles2/renderer.c b/render/gles2/renderer.c index f57e9dae..81a932e6 100644 --- a/render/gles2/renderer.c +++ b/render/gles2/renderer.c @@ -1,10 +1,10 @@ -#include <stdint.h> -#include <stdlib.h> #include <assert.h> #include <GLES2/gl2.h> #include <GLES2/gl2ext.h> -#include <wayland-util.h> +#include <stdint.h> +#include <stdlib.h> #include <wayland-server-protocol.h> +#include <wayland-util.h> #include <wlr/backend.h> #include <wlr/render.h> #include <wlr/render/egl.h> diff --git a/render/gles2/shaders.c b/render/gles2/shaders.c index ff6fba9c..46a10248 100644 --- a/render/gles2/shaders.c +++ b/render/gles2/shaders.c @@ -1,5 +1,5 @@ -#include "render/gles2.h" #include <GLES2/gl2.h> +#include "render/gles2.h" // Colored quads const GLchar quad_vertex_src[] = diff --git a/render/gles2/texture.c b/render/gles2/texture.c index ff71cb08..688a51d8 100644 --- a/render/gles2/texture.c +++ b/render/gles2/texture.c @@ -1,16 +1,17 @@ -#include <stdint.h> -#include <stdlib.h> #include <assert.h> #include <GLES2/gl2.h> #include <GLES2/gl2ext.h> -#include <wayland-util.h> +#include <stdint.h> +#include <stdlib.h> #include <wayland-server-protocol.h> +#include <wayland-util.h> #include <wlr/render.h> #include <wlr/render/egl.h> #include <wlr/render/interface.h> #include <wlr/render/matrix.h> #include <wlr/util/log.h> #include "render/gles2.h" +#include "util/signal.h" static struct pixel_format external_pixel_format = { .wl_format = 0, @@ -271,7 +272,7 @@ static void gles2_texture_bind(struct wlr_texture *_texture) { static void gles2_texture_destroy(struct wlr_texture *_texture) { struct wlr_gles2_texture *texture = (struct wlr_gles2_texture *)_texture; - wl_signal_emit(&texture->wlr_texture.destroy_signal, &texture->wlr_texture); + wlr_signal_emit_safe(&texture->wlr_texture.destroy_signal, &texture->wlr_texture); if (texture->tex_id) { GL_CALL(glDeleteTextures(1, &texture->tex_id)); } diff --git a/render/gles2/util.c b/render/gles2/util.c index 9498a1cd..c291f533 100644 --- a/render/gles2/util.c +++ b/render/gles2/util.c @@ -1,6 +1,6 @@ -#include <stdlib.h> -#include <stdbool.h> #include <GLES2/gl2.h> +#include <stdbool.h> +#include <stdlib.h> #include <wlr/util/log.h> #include "render/gles2.h" diff --git a/render/matrix.c b/render/matrix.c index fa45dd04..d5d7f49d 100644 --- a/render/matrix.c +++ b/render/matrix.c @@ -1,9 +1,9 @@ -#include <string.h> #include <math.h> +#include <string.h> #include <wayland-server-protocol.h> +#include <wlr/render/matrix.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_output.h> -#include <wlr/render/matrix.h> /* Obtains the index for the given row/column */ static inline int mind(int row, int col) { diff --git a/render/meson.build b/render/meson.build index 309e83cd..1a5a85b8 100644 --- a/render/meson.build +++ b/render/meson.build @@ -10,12 +10,12 @@ lib_wlr_render = static_library( 'wlr_render', files( 'egl.c', - 'matrix.c', 'gles2/pixel_format.c', 'gles2/renderer.c', 'gles2/shaders.c', 'gles2/texture.c', 'gles2/util.c', + 'matrix.c', 'wlr_renderer.c', 'wlr_texture.c', ), diff --git a/render/wlr_renderer.c b/render/wlr_renderer.c index c8f06a64..fa6c6fc3 100644 --- a/render/wlr_renderer.c +++ b/render/wlr_renderer.c @@ -1,5 +1,5 @@ -#include <stdlib.h> #include <stdbool.h> +#include <stdlib.h> #include <wlr/render/interface.h> void wlr_renderer_init(struct wlr_renderer *renderer, diff --git a/render/wlr_texture.c b/render/wlr_texture.c index 4ce86bdd..a82a16b2 100644 --- a/render/wlr_texture.c +++ b/render/wlr_texture.c @@ -1,5 +1,5 @@ -#include <stdlib.h> #include <stdbool.h> +#include <stdlib.h> #include <wlr/render/interface.h> void wlr_texture_init(struct wlr_texture *texture, diff --git a/rootston/config.c b/rootston/config.c index 26cbd12d..e63efc0b 100644 --- a/rootston/config.c +++ b/rootston/config.c @@ -2,20 +2,20 @@ #define _POSIX_C_SOURCE 200809L #endif #include <assert.h> -#include <stdlib.h> -#include <limits.h> #include <getopt.h> +#include <limits.h> +#include <stdlib.h> #include <string.h> #include <strings.h> -#include <unistd.h> #include <sys/param.h> +#include <unistd.h> #include <wlr/config.h> -#include <wlr/util/log.h> #include <wlr/types/wlr_box.h> +#include <wlr/util/log.h> #include "rootston/config.h" +#include "rootston/ini.h" #include "rootston/input.h" #include "rootston/keyboard.h" -#include "rootston/ini.h" static void usage(const char *name, int ret) { fprintf(stderr, diff --git a/rootston/cursor.c b/rootston/cursor.c index ab32a5de..aa94daeb 100644 --- a/rootston/cursor.c +++ b/rootston/cursor.c @@ -1,16 +1,16 @@ #define _XOPEN_SOURCE 700 -#include <stdlib.h> #include <math.h> +#include <stdlib.h> +#include <wlr/types/wlr_xcursor_manager.h> +#include <wlr/util/edges.h> +#include <wlr/util/log.h> #ifdef __linux__ #include <linux/input-event-codes.h> #elif __FreeBSD__ #include <dev/evdev/input-event-codes.h> #endif -#include <wlr/types/wlr_xcursor_manager.h> -#include <wlr/util/log.h> -#include <wlr/util/edges.h> -#include "rootston/xcursor.h" #include "rootston/cursor.h" +#include "rootston/xcursor.h" struct roots_cursor *roots_cursor_create(struct roots_seat *seat) { struct roots_cursor *cursor = calloc(1, sizeof(struct roots_cursor)); diff --git a/rootston/desktop.c b/rootston/desktop.c index 91661c05..80ccbc25 100644 --- a/rootston/desktop.c +++ b/rootston/desktop.c @@ -1,25 +1,25 @@ #define _POSIX_C_SOURCE 199309L #include <assert.h> -#include <time.h> -#include <stdlib.h> #include <math.h> +#include <stdlib.h> +#include <time.h> #include <wlr/config.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_compositor.h> #include <wlr/types/wlr_cursor.h> #include <wlr/types/wlr_gamma_control.h> #include <wlr/types/wlr_idle.h> +#include <wlr/types/wlr_output_layout.h> #include <wlr/types/wlr_primary_selection.h> #include <wlr/types/wlr_server_decoration.h> -#include <wlr/types/wlr_output_layout.h> #include <wlr/types/wlr_wl_shell.h> #include <wlr/types/wlr_xcursor_manager.h> #include <wlr/types/wlr_xdg_shell_v6.h> #include <wlr/util/log.h> -#include "rootston/server.h" #include "rootston/seat.h" -#include "rootston/xcursor.h" +#include "rootston/server.h" #include "rootston/view.h" +#include "rootston/xcursor.h" void view_get_box(const struct roots_view *view, struct wlr_box *box) { box->x = view->x; @@ -621,11 +621,8 @@ struct roots_desktop *desktop_create(struct roots_server *server, wl_list_init(&desktop->views); wl_list_init(&desktop->outputs); - desktop->output_add.notify = output_add_notify; - wl_signal_add(&server->backend->events.output_add, &desktop->output_add); - desktop->output_remove.notify = output_remove_notify; - wl_signal_add(&server->backend->events.output_remove, - &desktop->output_remove); + desktop->new_output.notify = handle_new_output; + wl_signal_add(&server->backend->events.new_output, &desktop->new_output); desktop->server = server; desktop->config = config; diff --git a/rootston/input.c b/rootston/input.c index 74ce59d0..657b0946 100644 --- a/rootston/input.c +++ b/rootston/input.c @@ -1,16 +1,16 @@ #include <assert.h> #include <stdlib.h> #include <wayland-server.h> +#include <wlr/backend/libinput.h> #include <wlr/types/wlr_cursor.h> #include <wlr/util/log.h> #include <wlr/xcursor.h> #include <wlr/xwayland.h> -#include <wlr/backend/libinput.h> -#include "rootston/server.h" #include "rootston/config.h" #include "rootston/input.h" #include "rootston/keyboard.h" #include "rootston/seat.h" +#include "rootston/server.h" static const char *device_type(enum wlr_input_device_type type) { switch (type) { @@ -40,9 +40,9 @@ struct roots_seat *input_get_seat(struct roots_input *input, char *name) { return seat; } -static void input_add_notify(struct wl_listener *listener, void *data) { +static void handle_new_input(struct wl_listener *listener, void *data) { struct wlr_input_device *device = data; - struct roots_input *input = wl_container_of(listener, input, input_add); + struct roots_input *input = wl_container_of(listener, input, new_input); char *seat_name = ROOTS_CONFIG_DEFAULT_SEAT_NAME; struct roots_device_config *dc = @@ -74,16 +74,6 @@ static void input_add_notify(struct wl_listener *listener, void *data) { } } -static void input_remove_notify(struct wl_listener *listener, void *data) { - struct wlr_input_device *device = data; - struct roots_input *input = wl_container_of(listener, input, input_remove); - - struct roots_seat *seat; - wl_list_for_each(seat, &input->seats, link) { - roots_seat_remove_device(seat, device); - } -} - struct roots_input *input_create(struct roots_server *server, struct roots_config *config) { wlr_log(L_DEBUG, "Initializing roots input"); @@ -99,10 +89,8 @@ struct roots_input *input_create(struct roots_server *server, wl_list_init(&input->seats); - input->input_add.notify = input_add_notify; - wl_signal_add(&server->backend->events.input_add, &input->input_add); - input->input_remove.notify = input_remove_notify; - wl_signal_add(&server->backend->events.input_remove, &input->input_remove); + input->new_input.notify = handle_new_input; + wl_signal_add(&server->backend->events.new_input, &input->new_input); return input; } diff --git a/rootston/keyboard.c b/rootston/keyboard.c index ddf541b4..6ec90c31 100644 --- a/rootston/keyboard.c +++ b/rootston/keyboard.c @@ -1,18 +1,18 @@ #include <assert.h> +#include <stdbool.h> #include <stdint.h> #include <stdlib.h> #include <unistd.h> -#include <stdbool.h> #include <wayland-server.h> -#include <wlr/types/wlr_input_device.h> -#include <wlr/types/wlr_pointer.h> #include <wlr/backend/multi.h> #include <wlr/backend/session.h> +#include <wlr/types/wlr_input_device.h> +#include <wlr/types/wlr_pointer.h> #include <wlr/util/log.h> #include <xkbcommon/xkbcommon.h> #include "rootston/input.h" -#include "rootston/seat.h" #include "rootston/keyboard.h" +#include "rootston/seat.h" static ssize_t pressed_keysyms_index(xkb_keysym_t *pressed_keysyms, xkb_keysym_t keysym) { diff --git a/rootston/main.c b/rootston/main.c index 3273c53f..5450ade2 100644 --- a/rootston/main.c +++ b/rootston/main.c @@ -3,10 +3,10 @@ #include <stdlib.h> #include <unistd.h> #include <wayland-server.h> -#include <wlr/config.h> #include <wlr/backend.h> #include <wlr/backend/headless.h> #include <wlr/backend/multi.h> +#include <wlr/config.h> #include <wlr/render.h> #include <wlr/util/log.h> #include "rootston/config.h" diff --git a/rootston/meson.build b/rootston/meson.build index 973f93a4..a53812e3 100644 --- a/rootston/meson.build +++ b/rootston/meson.build @@ -8,8 +8,8 @@ sources = [ 'main.c', 'output.c', 'seat.c', - 'xdg_shell_v6.c', 'wl_shell.c', + 'xdg_shell_v6.c', ] if get_option('enable_xwayland') sources += ['xwayland.c'] diff --git a/rootston/output.c b/rootston/output.c index fce875da..1ea4412e 100644 --- a/rootston/output.c +++ b/rootston/output.c @@ -1,18 +1,18 @@ #define _POSIX_C_SOURCE 200809L -#include <time.h> -#include <stdlib.h> -#include <stdbool.h> #include <assert.h> -#include <wlr/types/wlr_output_layout.h> +#include <stdbool.h> +#include <stdlib.h> +#include <time.h> +#include <wlr/render/matrix.h> #include <wlr/types/wlr_compositor.h> +#include <wlr/types/wlr_output_layout.h> #include <wlr/types/wlr_wl_shell.h> #include <wlr/types/wlr_xdg_shell_v6.h> -#include <wlr/render/matrix.h> #include <wlr/util/log.h> #include <wlr/util/region.h> -#include "rootston/server.h" -#include "rootston/output.h" #include "rootston/config.h" +#include "rootston/output.h" +#include "rootston/server.h" typedef void (*surface_iterator_func_t)(struct wlr_surface *surface, double lx, double ly, float rotation, void *data); @@ -644,9 +644,22 @@ static void set_mode(struct wlr_output *output, } } -void output_add_notify(struct wl_listener *listener, void *data) { +static void output_handle_destroy(struct wl_listener *listener, void *data) { + struct roots_output *output = wl_container_of(listener, output, destroy); + + // TODO: cursor + //example_config_configure_cursor(sample->config, sample->cursor, + // sample->compositor); + + wl_list_remove(&output->link); + wl_list_remove(&output->destroy.link); + wl_list_remove(&output->frame.link); + free(output); +} + +void handle_new_output(struct wl_listener *listener, void *data) { struct roots_desktop *desktop = wl_container_of(listener, desktop, - output_add); + new_output); struct wlr_output *wlr_output = data; struct roots_input *input = desktop->server->input; struct roots_config *config = desktop->config; @@ -670,6 +683,8 @@ void output_add_notify(struct wl_listener *listener, void *data) { output->damage = wlr_output_damage_create(wlr_output); + output->destroy.notify = output_handle_destroy; + wl_signal_add(&wlr_output->events.destroy, &output->destroy); output->frame.notify = output_damage_handle_frame; wl_signal_add(&output->damage->events.frame, &output->frame); @@ -699,31 +714,3 @@ void output_add_notify(struct wl_listener *listener, void *data) { output_damage_whole(output); } - -void output_remove_notify(struct wl_listener *listener, void *data) { - struct wlr_output *wlr_output = data; - struct roots_desktop *desktop = - wl_container_of(listener, desktop, output_remove); - - struct roots_output *output = NULL, *_output; - wl_list_for_each(_output, &desktop->outputs, link) { - if (_output->wlr_output == wlr_output) { - output = _output; - break; - } - } - if (!output) { - return; // We are unfamiliar with this output - } - - wlr_output_layout_remove(desktop->layout, output->wlr_output); - - // TODO: cursor - //example_config_configure_cursor(sample->config, sample->cursor, - // sample->compositor); - - wl_list_remove(&output->link); - wl_list_remove(&output->frame.link); - wlr_output_damage_destroy(output->damage); - free(output); -} diff --git a/rootston/seat.c b/rootston/seat.c index 45e42d7d..38c26628 100644 --- a/rootston/seat.c +++ b/rootston/seat.c @@ -3,14 +3,14 @@ #include <string.h> #include <wayland-server.h> #include <wlr/config.h> +#include <wlr/types/wlr_idle.h> #include <wlr/types/wlr_xcursor_manager.h> #include <wlr/util/log.h> -#include <wlr/types/wlr_idle.h> -#include "rootston/xcursor.h" +#include "rootston/cursor.h" #include "rootston/input.h" -#include "rootston/seat.h" #include "rootston/keyboard.h" -#include "rootston/cursor.h" +#include "rootston/seat.h" +#include "rootston/xcursor.h" static void handle_keyboard_key(struct wl_listener *listener, void *data) { struct roots_keyboard *keyboard = @@ -404,6 +404,17 @@ static void seat_update_capabilities(struct roots_seat *seat) { } } +static void handle_keyboard_destroy(struct wl_listener *listener, void *data) { + struct roots_keyboard *keyboard = + wl_container_of(listener, keyboard, device_destroy); + struct roots_seat *seat = keyboard->seat; + roots_keyboard_destroy(keyboard); + wl_list_remove(&keyboard->device_destroy.link); + wl_list_remove(&keyboard->keyboard_key.link); + wl_list_remove(&keyboard->keyboard_modifiers.link); + seat_update_capabilities(seat); +} + static void seat_add_keyboard(struct roots_seat *seat, struct wlr_input_device *device) { assert(device->type == WLR_INPUT_DEVICE_KEYBOARD); @@ -418,10 +429,11 @@ static void seat_add_keyboard(struct roots_seat *seat, wl_list_insert(&seat->keyboards, &keyboard->link); + keyboard->device_destroy.notify = handle_keyboard_destroy; + wl_signal_add(&keyboard->device->events.destroy, &keyboard->device_destroy); keyboard->keyboard_key.notify = handle_keyboard_key; wl_signal_add(&keyboard->device->keyboard->events.key, &keyboard->keyboard_key); - keyboard->keyboard_modifiers.notify = handle_keyboard_modifiers; wl_signal_add(&keyboard->device->keyboard->events.modifiers, &keyboard->keyboard_modifiers); @@ -429,6 +441,19 @@ static void seat_add_keyboard(struct roots_seat *seat, wlr_seat_set_keyboard(seat->seat, device); } +static void handle_pointer_destroy(struct wl_listener *listener, void *data) { + struct roots_pointer *pointer = + wl_container_of(listener, pointer, device_destroy); + struct roots_seat *seat = pointer->seat; + + wl_list_remove(&pointer->link); + wlr_cursor_detach_input_device(seat->cursor->cursor, pointer->device); + wl_list_remove(&pointer->device_destroy.link); + free(pointer); + + seat_update_capabilities(seat); +} + static void seat_add_pointer(struct roots_seat *seat, struct wlr_input_device *device) { struct roots_pointer *pointer = calloc(sizeof(struct roots_pointer), 1); @@ -441,10 +466,27 @@ static void seat_add_pointer(struct roots_seat *seat, pointer->device = device; pointer->seat = seat; wl_list_insert(&seat->pointers, &pointer->link); + + pointer->device_destroy.notify = handle_pointer_destroy; + wl_signal_add(&pointer->device->events.destroy, &pointer->device_destroy); + wlr_cursor_attach_input_device(seat->cursor->cursor, device); roots_seat_configure_cursor(seat); } +static void handle_touch_destroy(struct wl_listener *listener, void *data) { + struct roots_pointer *touch = + wl_container_of(listener, touch, device_destroy); + struct roots_seat *seat = touch->seat; + + wl_list_remove(&touch->link); + wlr_cursor_detach_input_device(seat->cursor->cursor, touch->device); + wl_list_remove(&touch->device_destroy.link); + free(touch); + + seat_update_capabilities(seat); +} + static void seat_add_touch(struct roots_seat *seat, struct wlr_input_device *device) { struct roots_touch *touch = calloc(sizeof(struct roots_touch), 1); @@ -457,6 +499,10 @@ static void seat_add_touch(struct roots_seat *seat, touch->device = device; touch->seat = seat; wl_list_insert(&seat->touch, &touch->link); + + touch->device_destroy.notify = handle_touch_destroy; + wl_signal_add(&touch->device->events.destroy, &touch->device_destroy); + wlr_cursor_attach_input_device(seat->cursor->cursor, device); roots_seat_configure_cursor(seat); } @@ -466,6 +512,20 @@ static void seat_add_tablet_pad(struct roots_seat *seat, // TODO } +static void handle_tablet_tool_destroy(struct wl_listener *listener, + void *data) { + struct roots_pointer *tablet_tool = + wl_container_of(listener, tablet_tool, device_destroy); + struct roots_seat *seat = tablet_tool->seat; + + wl_list_remove(&tablet_tool->link); + wlr_cursor_detach_input_device(seat->cursor->cursor, tablet_tool->device); + wl_list_remove(&tablet_tool->device_destroy.link); + free(tablet_tool); + + seat_update_capabilities(seat); +} + static void seat_add_tablet_tool(struct roots_seat *seat, struct wlr_input_device *device) { struct roots_tablet_tool *tablet_tool = @@ -479,6 +539,11 @@ static void seat_add_tablet_tool(struct roots_seat *seat, tablet_tool->device = device; tablet_tool->seat = seat; wl_list_insert(&seat->tablet_tools, &tablet_tool->link); + + tablet_tool->device_destroy.notify = handle_tablet_tool_destroy; + wl_signal_add(&tablet_tool->device->events.destroy, + &tablet_tool->device_destroy); + wlr_cursor_attach_input_device(seat->cursor->cursor, device); roots_seat_configure_cursor(seat); } @@ -506,84 +571,6 @@ void roots_seat_add_device(struct roots_seat *seat, seat_update_capabilities(seat); } -static void seat_remove_keyboard(struct roots_seat *seat, - struct wlr_input_device *device) { - struct roots_keyboard *keyboard; - wl_list_for_each(keyboard, &seat->keyboards, link) { - if (keyboard->device == device) { - roots_keyboard_destroy(keyboard); - return; - } - } -} - -static void seat_remove_pointer(struct roots_seat *seat, - struct wlr_input_device *device) { - struct roots_pointer *pointer; - wl_list_for_each(pointer, &seat->pointers, link) { - if (pointer->device == device) { - wl_list_remove(&pointer->link); - wlr_cursor_detach_input_device(seat->cursor->cursor, device); - free(pointer); - return; - } - } -} - -static void seat_remove_touch(struct roots_seat *seat, - struct wlr_input_device *device) { - struct roots_touch *touch; - wl_list_for_each(touch, &seat->touch, link) { - if (touch->device == device) { - wl_list_remove(&touch->link); - wlr_cursor_detach_input_device(seat->cursor->cursor, device); - free(touch); - return; - } - } -} - -static void seat_remove_tablet_pad(struct roots_seat *seat, - struct wlr_input_device *device) { - // TODO -} - -static void seat_remove_tablet_tool(struct roots_seat *seat, - struct wlr_input_device *device) { - struct roots_tablet_tool *tablet_tool; - wl_list_for_each(tablet_tool, &seat->tablet_tools, link) { - if (tablet_tool->device == device) { - wl_list_remove(&tablet_tool->link); - wlr_cursor_detach_input_device(seat->cursor->cursor, device); - free(tablet_tool); - return; - } - } -} - -void roots_seat_remove_device(struct roots_seat *seat, - struct wlr_input_device *device) { - switch (device->type) { - case WLR_INPUT_DEVICE_KEYBOARD: - seat_remove_keyboard(seat, device); - break; - case WLR_INPUT_DEVICE_POINTER: - seat_remove_pointer(seat, device); - break; - case WLR_INPUT_DEVICE_TOUCH: - seat_remove_touch(seat, device); - break; - case WLR_INPUT_DEVICE_TABLET_PAD: - seat_remove_tablet_pad(seat, device); - break; - case WLR_INPUT_DEVICE_TABLET_TOOL: - seat_remove_tablet_tool(seat, device); - break; - } - - seat_update_capabilities(seat); -} - void roots_seat_configure_xcursor(struct roots_seat *seat) { const char *cursor_theme = NULL; struct roots_cursor_config *cc = diff --git a/rootston/wl_shell.c b/rootston/wl_shell.c index 267e2cf5..44a65cf5 100644 --- a/rootston/wl_shell.c +++ b/rootston/wl_shell.c @@ -1,14 +1,14 @@ #include <assert.h> -#include <stdlib.h> #include <stdbool.h> +#include <stdlib.h> #include <wayland-server.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_surface.h> #include <wlr/types/wlr_wl_shell.h> #include <wlr/util/log.h> #include "rootston/desktop.h" -#include "rootston/server.h" #include "rootston/input.h" +#include "rootston/server.h" static void popup_destroy(struct roots_view_child *child) { assert(child->destroy == popup_destroy); diff --git a/rootston/xdg_shell_v6.c b/rootston/xdg_shell_v6.c index 9bd6f76a..8e6674ab 100644 --- a/rootston/xdg_shell_v6.c +++ b/rootston/xdg_shell_v6.c @@ -1,14 +1,14 @@ #include <assert.h> -#include <stdlib.h> #include <stdbool.h> +#include <stdlib.h> #include <wayland-server.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_surface.h> #include <wlr/types/wlr_xdg_shell_v6.h> #include <wlr/util/log.h> #include "rootston/desktop.h" -#include "rootston/server.h" #include "rootston/input.h" +#include "rootston/server.h" static void popup_destroy(struct roots_view_child *child) { assert(child->destroy == popup_destroy); diff --git a/rootston/xwayland.c b/rootston/xwayland.c index 36be9793..e9e0d5e0 100644 --- a/rootston/xwayland.c +++ b/rootston/xwayland.c @@ -1,12 +1,12 @@ #include <assert.h> -#include <stdlib.h> #include <stdbool.h> +#include <stdlib.h> #include <wayland-server.h> #include <wlr/config.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_surface.h> -#include <wlr/xwayland.h> #include <wlr/util/log.h> +#include <wlr/xwayland.h> #include "rootston/server.h" #include "rootston/server.h" diff --git a/types/meson.build b/types/meson.build index 9f37cc86..2731f9bc 100644 --- a/types/meson.build +++ b/types/meson.build @@ -1,18 +1,18 @@ lib_wlr_types = static_library( 'wlr_types', files( - 'wlr_data_device.c', 'wlr_box.c', 'wlr_compositor.c', 'wlr_cursor.c', + 'wlr_data_device.c', 'wlr_gamma_control.c', 'wlr_idle.c', 'wlr_input_device.c', 'wlr_keyboard.c', 'wlr_list.c', - 'wlr_output.c', 'wlr_output_damage.c', 'wlr_output_layout.c', + 'wlr_output.c', 'wlr_pointer.c', 'wlr_primary_selection.c', 'wlr_region.c', diff --git a/types/wlr_box.c b/types/wlr_box.c index 33031858..2ea743d0 100644 --- a/types/wlr_box.c +++ b/types/wlr_box.c @@ -1,7 +1,7 @@ #include <limits.h> -#include <stdlib.h> #include <math.h> #include <stdbool.h> +#include <stdlib.h> #include <wayland-server-protocol.h> #include <wlr/types/wlr_box.h> #include <wlr/util/log.h> diff --git a/types/wlr_compositor.c b/types/wlr_compositor.c index a4bd7a16..925e0019 100644 --- a/types/wlr_compositor.c +++ b/types/wlr_compositor.c @@ -1,10 +1,11 @@ #include <assert.h> #include <stdlib.h> #include <wayland-server.h> -#include <wlr/util/log.h> -#include <wlr/types/wlr_surface.h> -#include <wlr/types/wlr_region.h> #include <wlr/types/wlr_compositor.h> +#include <wlr/types/wlr_region.h> +#include <wlr/types/wlr_surface.h> +#include <wlr/util/log.h> +#include "util/signal.h" static void destroy_surface_listener(struct wl_listener *listener, void *data) { wl_list_remove(wl_resource_get_link(data)); @@ -35,7 +36,7 @@ static void wl_compositor_create_surface(struct wl_client *client, wl_list_insert(&compositor->surfaces, wl_resource_get_link(surface_resource)); - wl_signal_emit(&compositor->events.new_surface, surface); + wlr_signal_emit_safe(&compositor->events.new_surface, surface); } static void wl_compositor_create_region(struct wl_client *client, diff --git a/types/wlr_cursor.c b/types/wlr_cursor.c index fd48c1b6..20acebf1 100644 --- a/types/wlr_cursor.c +++ b/types/wlr_cursor.c @@ -1,12 +1,13 @@ -#include <wlr/types/wlr_cursor.h> -#include <stdlib.h> #include <assert.h> #include <limits.h> -#include <wlr/util/log.h> +#include <stdlib.h> #include <wayland-server.h> -#include <wlr/types/wlr_output.h> -#include <wlr/types/wlr_output_layout.h> +#include <wlr/types/wlr_cursor.h> #include <wlr/types/wlr_input_device.h> +#include <wlr/types/wlr_output_layout.h> +#include <wlr/types/wlr_output.h> +#include <wlr/util/log.h> +#include "util/signal.h" struct wlr_cursor_device { struct wlr_cursor *cursor; @@ -325,7 +326,7 @@ static void handle_pointer_motion(struct wl_listener *listener, void *data) { struct wlr_event_pointer_motion *event = data; struct wlr_cursor_device *device = wl_container_of(listener, device, motion); - wl_signal_emit(&device->cursor->events.motion, event); + wlr_signal_emit_safe(&device->cursor->events.motion, event); } static void handle_pointer_motion_absolute(struct wl_listener *listener, @@ -333,62 +334,62 @@ static void handle_pointer_motion_absolute(struct wl_listener *listener, struct wlr_event_pointer_motion_absolute *event = data; struct wlr_cursor_device *device = wl_container_of(listener, device, motion_absolute); - wl_signal_emit(&device->cursor->events.motion_absolute, event); + wlr_signal_emit_safe(&device->cursor->events.motion_absolute, event); } static void handle_pointer_button(struct wl_listener *listener, void *data) { struct wlr_event_pointer_button *event = data; struct wlr_cursor_device *device = wl_container_of(listener, device, button); - wl_signal_emit(&device->cursor->events.button, event); + wlr_signal_emit_safe(&device->cursor->events.button, event); } static void handle_pointer_axis(struct wl_listener *listener, void *data) { struct wlr_event_pointer_axis *event = data; struct wlr_cursor_device *device = wl_container_of(listener, device, axis); - wl_signal_emit(&device->cursor->events.axis, event); + wlr_signal_emit_safe(&device->cursor->events.axis, event); } static void handle_touch_up(struct wl_listener *listener, void *data) { struct wlr_event_touch_up *event = data; struct wlr_cursor_device *device; device = wl_container_of(listener, device, touch_up); - wl_signal_emit(&device->cursor->events.touch_up, event); + wlr_signal_emit_safe(&device->cursor->events.touch_up, event); } static void handle_touch_down(struct wl_listener *listener, void *data) { struct wlr_event_touch_down *event = data; struct wlr_cursor_device *device; device = wl_container_of(listener, device, touch_down); - wl_signal_emit(&device->cursor->events.touch_down, event); + wlr_signal_emit_safe(&device->cursor->events.touch_down, event); } static void handle_touch_motion(struct wl_listener *listener, void *data) { struct wlr_event_touch_motion *event = data; struct wlr_cursor_device *device; device = wl_container_of(listener, device, touch_motion); - wl_signal_emit(&device->cursor->events.touch_motion, event); + wlr_signal_emit_safe(&device->cursor->events.touch_motion, event); } static void handle_touch_cancel(struct wl_listener *listener, void *data) { struct wlr_event_touch_cancel *event = data; struct wlr_cursor_device *device; device = wl_container_of(listener, device, touch_cancel); - wl_signal_emit(&device->cursor->events.touch_cancel, event); + wlr_signal_emit_safe(&device->cursor->events.touch_cancel, event); } static void handle_tablet_tool_tip(struct wl_listener *listener, void *data) { struct wlr_event_tablet_tool_tip *event = data; struct wlr_cursor_device *device; device = wl_container_of(listener, device, tablet_tool_tip); - wl_signal_emit(&device->cursor->events.tablet_tool_tip, event); + wlr_signal_emit_safe(&device->cursor->events.tablet_tool_tip, event); } static void handle_tablet_tool_axis(struct wl_listener *listener, void *data) { struct wlr_event_tablet_tool_axis *event = data; struct wlr_cursor_device *device; device = wl_container_of(listener, device, tablet_tool_axis); - wl_signal_emit(&device->cursor->events.tablet_tool_axis, event); + wlr_signal_emit_safe(&device->cursor->events.tablet_tool_axis, event); } static void handle_tablet_tool_button(struct wl_listener *listener, @@ -396,7 +397,7 @@ static void handle_tablet_tool_button(struct wl_listener *listener, struct wlr_event_tablet_tool_button *event = data; struct wlr_cursor_device *device; device = wl_container_of(listener, device, tablet_tool_button); - wl_signal_emit(&device->cursor->events.tablet_tool_button, event); + wlr_signal_emit_safe(&device->cursor->events.tablet_tool_button, event); } static void handle_tablet_tool_proximity(struct wl_listener *listener, @@ -404,7 +405,7 @@ static void handle_tablet_tool_proximity(struct wl_listener *listener, struct wlr_event_tablet_tool_proximity *event = data; struct wlr_cursor_device *device; device = wl_container_of(listener, device, tablet_tool_proximity); - wl_signal_emit(&device->cursor->events.tablet_tool_proximity, event); + wlr_signal_emit_safe(&device->cursor->events.tablet_tool_proximity, event); } static void handle_device_destroy(struct wl_listener *listener, void *data) { diff --git a/types/wlr_data_device.c b/types/wlr_data_device.c index d7e4aa14..b8ef820b 100644 --- a/types/wlr_data_device.c +++ b/types/wlr_data_device.c @@ -1,13 +1,14 @@ #define _XOPEN_SOURCE 700 +#include <assert.h> #include <stdlib.h> #include <string.h> #include <strings.h> -#include <assert.h> #include <unistd.h> #include <wayland-server.h> -#include <wlr/util/log.h> -#include <wlr/types/wlr_seat.h> #include <wlr/types/wlr_data_device.h> +#include <wlr/types/wlr_seat.h> +#include <wlr/util/log.h> +#include "util/signal.h" #define ALL_ACTIONS (WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY | \ WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE | \ @@ -290,7 +291,7 @@ static void seat_client_selection_data_source_destroy( seat->selection_data_source = NULL; - wl_signal_emit(&seat->events.selection, seat); + wlr_signal_emit_safe(&seat->events.selection, seat); } void wlr_seat_set_selection(struct wlr_seat *seat, @@ -321,7 +322,7 @@ void wlr_seat_set_selection(struct wlr_seat *seat, wlr_seat_client_send_selection(focused_client); } - wl_signal_emit(&seat->events.selection, seat); + wlr_signal_emit_safe(&seat->events.selection, seat); if (source) { seat->selection_data_source_destroy.notify = @@ -457,7 +458,7 @@ static void wlr_drag_end(struct wlr_drag *drag) { if (drag->icon) { drag->icon->mapped = false; wl_list_remove(&drag->icon_destroy.link); - wl_signal_emit(&drag->icon->events.map, drag->icon); + wlr_signal_emit_safe(&drag->icon->events.map, drag->icon); } free(drag); @@ -634,7 +635,7 @@ static void wlr_drag_icon_destroy(struct wlr_drag_icon *icon) { if (!icon) { return; } - wl_signal_emit(&icon->events.destroy, icon); + wlr_signal_emit_safe(&icon->events.destroy, icon); wlr_surface_set_role_committed(icon->surface, NULL, NULL); wl_list_remove(&icon->surface_destroy.link); wl_list_remove(&icon->seat_client_destroy.link); @@ -691,7 +692,7 @@ static struct wlr_drag_icon *wlr_drag_icon_create( icon->seat_client_destroy.notify = handle_drag_icon_seat_client_destroy; wl_list_insert(&client->seat->drag_icons, &icon->link); - wl_signal_emit(&client->seat->events.new_drag_icon, icon); + wlr_signal_emit_safe(&client->seat->events.new_drag_icon, icon); return icon; } @@ -941,7 +942,7 @@ void wlr_data_source_finish(struct wlr_data_source *source) { return; } - wl_signal_emit(&source->events.destroy, source); + wlr_signal_emit_safe(&source->events.destroy, source); char **p; wl_array_for_each(p, &source->mime_types) { diff --git a/types/wlr_gamma_control.c b/types/wlr_gamma_control.c index eb154b6b..861427bd 100644 --- a/types/wlr_gamma_control.c +++ b/types/wlr_gamma_control.c @@ -5,6 +5,7 @@ #include <wlr/types/wlr_output.h> #include <wlr/util/log.h> #include "gamma-control-protocol.h" +#include "util/signal.h" static void resource_destroy(struct wl_client *client, struct wl_resource *resource) { @@ -15,7 +16,7 @@ static void gamma_control_destroy(struct wlr_gamma_control *gamma_control) { if (gamma_control == NULL) { return; } - wl_signal_emit(&gamma_control->events.destroy, gamma_control); + wlr_signal_emit_safe(&gamma_control->events.destroy, gamma_control); wl_list_remove(&gamma_control->output_destroy_listener.link); wl_resource_set_user_data(gamma_control->resource, NULL); wl_list_remove(&gamma_control->link); diff --git a/types/wlr_idle.c b/types/wlr_idle.c index f2cad42b..9eddc42b 100644 --- a/types/wlr_idle.c +++ b/types/wlr_idle.c @@ -5,6 +5,7 @@ #include <wlr/types/wlr_idle.h> #include <wlr/util/log.h> #include "idle-protocol.h" +#include "util/signal.h" static void idle_timeout_destroy(struct wlr_idle_timeout *timer) { wl_list_remove(&timer->input_listener.link); @@ -186,5 +187,5 @@ struct wlr_idle *wlr_idle_create(struct wl_display *display) { } void wlr_idle_notify_activity(struct wlr_idle *idle, struct wlr_seat *seat) { - wl_signal_emit(&idle->activity_notify, seat); + wlr_signal_emit_safe(&idle->activity_notify, seat); } diff --git a/types/wlr_input_device.c b/types/wlr_input_device.c index 7015dcba..65d4b1d6 100644 --- a/types/wlr_input_device.c +++ b/types/wlr_input_device.c @@ -2,14 +2,15 @@ #include <stdlib.h> #include <string.h> #include <wayland-server.h> -#include <wlr/types/wlr_input_device.h> #include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_keyboard.h> #include <wlr/interfaces/wlr_pointer.h> -#include <wlr/interfaces/wlr_touch.h> -#include <wlr/interfaces/wlr_tablet_tool.h> #include <wlr/interfaces/wlr_tablet_pad.h> +#include <wlr/interfaces/wlr_tablet_tool.h> +#include <wlr/interfaces/wlr_touch.h> +#include <wlr/types/wlr_input_device.h> #include <wlr/util/log.h> +#include "util/signal.h" void wlr_input_device_init(struct wlr_input_device *dev, enum wlr_input_device_type type, @@ -29,7 +30,7 @@ void wlr_input_device_destroy(struct wlr_input_device *dev) { return; } - wl_signal_emit(&dev->events.destroy, dev); + wlr_signal_emit_safe(&dev->events.destroy, dev); if (dev->_device) { switch (dev->type) { @@ -58,7 +59,6 @@ void wlr_input_device_destroy(struct wlr_input_device *dev) { if (dev->impl && dev->impl->destroy) { dev->impl->destroy(dev); } else { - wl_list_remove(&dev->events.destroy.listener_list); free(dev); } } diff --git a/types/wlr_keyboard.c b/types/wlr_keyboard.c index 29552eb4..5c0699ff 100644 --- a/types/wlr_keyboard.c +++ b/types/wlr_keyboard.c @@ -1,12 +1,13 @@ +#include <assert.h> #include <stdlib.h> #include <string.h> #include <sys/mman.h> #include <unistd.h> -#include <assert.h> #include <wayland-server.h> -#include <wlr/types/wlr_keyboard.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); @@ -110,7 +111,7 @@ void wlr_keyboard_notify_modifiers(struct wlr_keyboard *keyboard, bool updated = keyboard_modifier_update(keyboard); if (updated) { - wl_signal_emit(&keyboard->events.modifiers, keyboard); + wlr_signal_emit_safe(&keyboard->events.modifiers, keyboard); } } @@ -128,11 +129,11 @@ void wlr_keyboard_notify_key(struct wlr_keyboard *keyboard, bool updated = keyboard_modifier_update(keyboard); if (updated) { - wl_signal_emit(&keyboard->events.modifiers, keyboard); + wlr_signal_emit_safe(&keyboard->events.modifiers, keyboard); } keyboard_key_update(keyboard, event); - wl_signal_emit(&keyboard->events.key, event); + wlr_signal_emit_safe(&keyboard->events.key, event); } void wlr_keyboard_init(struct wlr_keyboard *kb, @@ -234,7 +235,7 @@ void wlr_keyboard_set_keymap(struct wlr_keyboard *kb, keyboard_modifier_update(kb); - wl_signal_emit(&kb->events.keymap, kb); + wlr_signal_emit_safe(&kb->events.keymap, kb); return; err: @@ -253,7 +254,7 @@ void wlr_keyboard_set_repeat_info(struct wlr_keyboard *kb, int32_t rate, } kb->repeat_info.rate = rate; kb->repeat_info.delay = delay; - wl_signal_emit(&kb->events.repeat_info, kb); + wlr_signal_emit_safe(&kb->events.repeat_info, kb); } uint32_t wlr_keyboard_get_modifiers(struct wlr_keyboard *kb) { diff --git a/types/wlr_list.c b/types/wlr_list.c index 565a155b..2be0912a 100644 --- a/types/wlr_list.c +++ b/types/wlr_list.c @@ -1,8 +1,8 @@ +#include <stdbool.h> +#include <stddef.h> #include <stdio.h> #include <stdlib.h> -#include <stdbool.h> #include <string.h> -#include <stddef.h> #include <sys/types.h> #include <wlr/types/wlr_list.h> diff --git a/types/wlr_output.c b/types/wlr_output.c index 5f7dca28..504d0209 100644 --- a/types/wlr_output.c +++ b/types/wlr_output.c @@ -5,14 +5,15 @@ #include <tgmath.h> #include <time.h> #include <wayland-server.h> +#include <wlr/interfaces/wlr_output.h> +#include <wlr/render.h> +#include <wlr/render/matrix.h> #include <wlr/types/wlr_box.h> #include <wlr/types/wlr_output.h> #include <wlr/types/wlr_surface.h> -#include <wlr/interfaces/wlr_output.h> #include <wlr/util/log.h> -#include <wlr/render/matrix.h> -#include <wlr/render.h> #include <wlr/util/region.h> +#include "util/signal.h" static void wl_output_send_to_resource(struct wl_resource *resource) { assert(resource); @@ -139,7 +140,7 @@ void wlr_output_update_enabled(struct wlr_output *output, bool enabled) { } output->enabled = enabled; - wl_signal_emit(&output->events.enable, output); + wlr_signal_emit_safe(&output->events.enable, output); } static void wlr_output_update_matrix(struct wlr_output *output) { @@ -193,7 +194,7 @@ void wlr_output_update_custom_mode(struct wlr_output *output, int32_t width, wlr_output_send_current_mode_to_resource(resource); } - wl_signal_emit(&output->events.mode, output); + wlr_signal_emit_safe(&output->events.mode, output); } void wlr_output_set_transform(struct wlr_output *output, @@ -207,7 +208,7 @@ void wlr_output_set_transform(struct wlr_output *output, wl_output_send_to_resource(resource); } - wl_signal_emit(&output->events.transform, output); + wlr_signal_emit_safe(&output->events.transform, output); } void wlr_output_set_position(struct wlr_output *output, int32_t lx, @@ -239,7 +240,7 @@ void wlr_output_set_scale(struct wlr_output *output, float scale) { wl_output_send_to_resource(resource); } - wl_signal_emit(&output->events.scale, output); + wlr_signal_emit_safe(&output->events.scale, output); } static void handle_display_destroy(struct wl_listener *listener, void *data) { @@ -284,8 +285,7 @@ void wlr_output_destroy(struct wlr_output *output) { wlr_output_destroy_global(output); wlr_output_set_fullscreen_surface(output, NULL); - wl_signal_emit(&output->backend->events.output_remove, output); - wl_signal_emit(&output->events.destroy, output); + wlr_signal_emit_safe(&output->events.destroy, output); struct wlr_output_mode *mode, *tmp_mode; wl_list_for_each_safe(mode, tmp_mode, &output->modes, link) { @@ -471,7 +471,7 @@ bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when, output->idle_frame = NULL; } - wl_signal_emit(&output->events.swap_buffers, damage); + wlr_signal_emit_safe(&output->events.swap_buffers, damage); int width, height; wlr_output_transformed_resolution(output, &width, &height); @@ -528,7 +528,7 @@ bool wlr_output_swap_buffers(struct wlr_output *output, struct timespec *when, void wlr_output_send_frame(struct wlr_output *output) { output->frame_pending = false; - wl_signal_emit(&output->events.frame, output); + wlr_signal_emit_safe(&output->events.frame, output); } static void schedule_frame_handle_idle_timer(void *data) { @@ -566,7 +566,7 @@ uint32_t wlr_output_get_gamma_size(struct wlr_output *output) { void wlr_output_update_needs_swap(struct wlr_output *output) { output->needs_swap = true; - wl_signal_emit(&output->events.needs_swap, output); + wlr_signal_emit_safe(&output->events.needs_swap, output); } static void output_damage_whole(struct wlr_output *output) { @@ -883,7 +883,7 @@ void wlr_output_cursor_destroy(struct wlr_output_cursor *cursor) { return; } output_cursor_reset(cursor); - wl_signal_emit(&cursor->events.destroy, cursor); + wlr_signal_emit_safe(&cursor->events.destroy, cursor); if (cursor->output->hardware_cursor == cursor) { // If this cursor was the hardware cursor, disable it if (cursor->output->impl->set_cursor) { diff --git a/types/wlr_output_damage.c b/types/wlr_output_damage.c index 354314b6..b3636c37 100644 --- a/types/wlr_output_damage.c +++ b/types/wlr_output_damage.c @@ -1,10 +1,11 @@ -#include <stdlib.h> #include <stddef.h> +#include <stdlib.h> #include <time.h> #include <wayland-server.h> #include <wlr/types/wlr_box.h> -#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output_damage.h> +#include <wlr/types/wlr_output.h> +#include "util/signal.h" static void output_handle_destroy(struct wl_listener *listener, void *data) { struct wlr_output_damage *output_damage = @@ -46,7 +47,7 @@ static void output_handle_frame(struct wl_listener *listener, void *data) { return; } - wl_signal_emit(&output_damage->events.frame, output_damage); + wlr_signal_emit_safe(&output_damage->events.frame, output_damage); } struct wlr_output_damage *wlr_output_damage_create(struct wlr_output *output) { @@ -85,7 +86,7 @@ void wlr_output_damage_destroy(struct wlr_output_damage *output_damage) { if (output_damage == NULL) { return; } - wl_signal_emit(&output_damage->events.destroy, output_damage); + wlr_signal_emit_safe(&output_damage->events.destroy, output_damage); wl_list_remove(&output_damage->output_destroy.link); wl_list_remove(&output_damage->output_mode.link); wl_list_remove(&output_damage->output_transform.link); diff --git a/types/wlr_output_layout.c b/types/wlr_output_layout.c index 46b0bd2a..db0389bd 100644 --- a/types/wlr_output_layout.c +++ b/types/wlr_output_layout.c @@ -1,11 +1,12 @@ -#include <wlr/util/log.h> -#include <wlr/types/wlr_output.h> -#include <wlr/types/wlr_output_layout.h> -#include <wlr/types/wlr_box.h> -#include <limits.h> +#include <assert.h> #include <float.h> +#include <limits.h> #include <stdlib.h> -#include <assert.h> +#include <wlr/types/wlr_box.h> +#include <wlr/types/wlr_output_layout.h> +#include <wlr/types/wlr_output.h> +#include <wlr/util/log.h> +#include "util/signal.h" struct wlr_output_layout_state { struct wlr_box _box; // should never be read directly, use the getter @@ -46,7 +47,7 @@ struct wlr_output_layout *wlr_output_layout_create() { static void wlr_output_layout_output_destroy( struct wlr_output_layout_output *l_output) { - wl_signal_emit(&l_output->events.destroy, l_output); + wlr_signal_emit_safe(&l_output->events.destroy, l_output); wl_list_remove(&l_output->state->mode.link); wl_list_remove(&l_output->state->scale.link); wl_list_remove(&l_output->state->transform.link); @@ -61,7 +62,7 @@ void wlr_output_layout_destroy(struct wlr_output_layout *layout) { return; } - wl_signal_emit(&layout->events.destroy, layout); + wlr_signal_emit_safe(&layout->events.destroy, layout); struct wlr_output_layout_output *l_output, *temp = NULL; wl_list_for_each_safe(l_output, temp, &layout->outputs, link) { @@ -129,7 +130,7 @@ static void wlr_output_layout_reconfigure(struct wlr_output_layout *layout) { wlr_output_set_position(l_output->output, l_output->x, l_output->y); } - wl_signal_emit(&layout->events.change, layout); + wlr_signal_emit_safe(&layout->events.change, layout); } static void handle_output_mode(struct wl_listener *listener, void *data) { @@ -204,7 +205,7 @@ void wlr_output_layout_add(struct wlr_output_layout *layout, l_output->state->auto_configured = false; wlr_output_layout_reconfigure(layout); wlr_output_create_global(output); - wl_signal_emit(&layout->events.add, l_output); + wlr_signal_emit_safe(&layout->events.add, l_output); } struct wlr_output_layout_output *wlr_output_layout_get( @@ -401,7 +402,7 @@ void wlr_output_layout_add_auto(struct wlr_output_layout *layout, l_output->state->auto_configured = true; wlr_output_layout_reconfigure(layout); wlr_output_create_global(output); - wl_signal_emit(&layout->events.add, l_output); + wlr_signal_emit_safe(&layout->events.add, l_output); } struct wlr_output *wlr_output_layout_get_center_output( diff --git a/types/wlr_pointer.c b/types/wlr_pointer.c index 04100e56..bc9efd8c 100644 --- a/types/wlr_pointer.c +++ b/types/wlr_pointer.c @@ -1,8 +1,8 @@ #include <stdlib.h> #include <string.h> #include <wayland-server.h> -#include <wlr/types/wlr_pointer.h> #include <wlr/interfaces/wlr_pointer.h> +#include <wlr/types/wlr_pointer.h> void wlr_pointer_init(struct wlr_pointer *pointer, struct wlr_pointer_impl *impl) { diff --git a/types/wlr_primary_selection.c b/types/wlr_primary_selection.c index fafde669..28fe63c1 100644 --- a/types/wlr_primary_selection.c +++ b/types/wlr_primary_selection.c @@ -1,12 +1,13 @@ #define _XOPEN_SOURCE 700 -#include <stdlib.h> -#include <unistd.h> -#include <string.h> #include <assert.h> #include <gtk-primary-selection-protocol.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> #include <wlr/types/wlr_primary_selection.h> #include <wlr/types/wlr_seat.h> #include <wlr/util/log.h> +#include "util/signal.h" static void offer_handle_receive(struct wl_client *client, struct wl_resource *resource, const char *mime_type, int32_t fd) { @@ -195,7 +196,7 @@ static void seat_client_primary_selection_source_destroy( seat->primary_selection_source = NULL; - wl_signal_emit(&seat->events.primary_selection, seat); + wlr_signal_emit_safe(&seat->events.primary_selection, seat); } void wlr_seat_set_primary_selection(struct wlr_seat *seat, @@ -225,7 +226,7 @@ void wlr_seat_set_primary_selection(struct wlr_seat *seat, wlr_seat_client_send_primary_selection(focused_client); } - wl_signal_emit(&seat->events.primary_selection, seat); + wlr_signal_emit_safe(&seat->events.primary_selection, seat); if (source) { seat->primary_selection_source_destroy.notify = @@ -278,7 +279,7 @@ void wlr_primary_selection_source_finish( return; } - wl_signal_emit(&source->events.destroy, source); + wlr_signal_emit_safe(&source->events.destroy, source); char **p; wl_array_for_each(p, &source->mime_types) { diff --git a/types/wlr_region.c b/types/wlr_region.c index fdf23ad2..322088b5 100644 --- a/types/wlr_region.c +++ b/types/wlr_region.c @@ -1,8 +1,8 @@ -#include <stdlib.h> -#include <stdio.h> #include <assert.h> -#include <wayland-server.h> #include <pixman.h> +#include <stdio.h> +#include <stdlib.h> +#include <wayland-server.h> static void region_add(struct wl_client *client, struct wl_resource *resource, int32_t x, int32_t y, int32_t width, int32_t height) { diff --git a/types/wlr_screenshooter.c b/types/wlr_screenshooter.c index 74f9f602..04757fb6 100644 --- a/types/wlr_screenshooter.c +++ b/types/wlr_screenshooter.c @@ -2,10 +2,10 @@ #include <stdlib.h> #include <string.h> #include <wayland-server.h> -#include <wlr/render.h> #include <wlr/backend.h> -#include <wlr/types/wlr_screenshooter.h> +#include <wlr/render.h> #include <wlr/types/wlr_output.h> +#include <wlr/types/wlr_screenshooter.h> #include <wlr/util/log.h> #include "screenshooter-protocol.h" diff --git a/types/wlr_seat.c b/types/wlr_seat.c index 79c4f6f6..d60e0e0d 100644 --- a/types/wlr_seat.c +++ b/types/wlr_seat.c @@ -4,11 +4,12 @@ #include <string.h> #include <time.h> #include <wayland-server.h> -#include <wlr/types/wlr_seat.h> -#include <wlr/types/wlr_input_device.h> -#include <wlr/util/log.h> #include <wlr/types/wlr_data_device.h> +#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_primary_selection.h> +#include <wlr/types/wlr_seat.h> +#include <wlr/util/log.h> +#include "util/signal.h" static void resource_destroy(struct wl_client *client, struct wl_resource *resource) { @@ -49,7 +50,7 @@ static void wl_pointer_set_cursor(struct wl_client *client, event->hotspot_x = hotspot_x; event->hotspot_y = hotspot_y; - wl_signal_emit(&seat_client->seat->events.request_set_cursor, event); + wlr_signal_emit_safe(&seat_client->seat->events.request_set_cursor, event); free(event); } @@ -177,7 +178,7 @@ static void wl_seat_get_touch(struct wl_client *client, static void wlr_seat_client_resource_destroy(struct wl_resource *seat_resource) { struct wlr_seat_client *client = wl_resource_get_user_data(seat_resource); - wl_signal_emit(&client->events.destroy, client); + wlr_signal_emit_safe(&client->events.destroy, client); if (client == client->seat->pointer_state.focused_client) { client->seat->pointer_state.focused_client = NULL; @@ -350,7 +351,7 @@ void wlr_seat_destroy(struct wlr_seat *seat) { return; } - wl_signal_emit(&seat->events.destroy, seat); + wlr_signal_emit_safe(&seat->events.destroy, seat); wl_list_remove(&seat->display_destroy.link); @@ -656,14 +657,14 @@ void wlr_seat_pointer_start_grab(struct wlr_seat *wlr_seat, assert(grab->seat); wlr_seat->pointer_state.grab = grab; - wl_signal_emit(&wlr_seat->events.pointer_grab_begin, grab); + wlr_signal_emit_safe(&wlr_seat->events.pointer_grab_begin, grab); } void wlr_seat_pointer_end_grab(struct wlr_seat *wlr_seat) { struct wlr_seat_pointer_grab *grab = wlr_seat->pointer_state.grab; if (grab != wlr_seat->pointer_state.default_grab) { wlr_seat->pointer_state.grab = wlr_seat->pointer_state.default_grab; - wl_signal_emit(&wlr_seat->events.pointer_grab_end, grab); + wlr_signal_emit_safe(&wlr_seat->events.pointer_grab_end, grab); if (grab->interface->cancel) { grab->interface->cancel(grab); } @@ -812,7 +813,7 @@ void wlr_seat_keyboard_start_grab(struct wlr_seat *wlr_seat, grab->seat = wlr_seat; wlr_seat->keyboard_state.grab = grab; - wl_signal_emit(&wlr_seat->events.keyboard_grab_begin, grab); + wlr_signal_emit_safe(&wlr_seat->events.keyboard_grab_begin, grab); } void wlr_seat_keyboard_end_grab(struct wlr_seat *wlr_seat) { @@ -820,7 +821,7 @@ void wlr_seat_keyboard_end_grab(struct wlr_seat *wlr_seat) { if (grab != wlr_seat->keyboard_state.default_grab) { wlr_seat->keyboard_state.grab = wlr_seat->keyboard_state.default_grab; - wl_signal_emit(&wlr_seat->events.keyboard_grab_end, grab); + wlr_signal_emit_safe(&wlr_seat->events.keyboard_grab_end, grab); if (grab->interface->cancel) { grab->interface->cancel(grab); } @@ -979,7 +980,7 @@ void wlr_seat_touch_start_grab(struct wlr_seat *wlr_seat, grab->seat = wlr_seat; wlr_seat->touch_state.grab = grab; - wl_signal_emit(&wlr_seat->events.touch_grab_begin, grab); + wlr_signal_emit_safe(&wlr_seat->events.touch_grab_begin, grab); } void wlr_seat_touch_end_grab(struct wlr_seat *wlr_seat) { @@ -987,7 +988,7 @@ void wlr_seat_touch_end_grab(struct wlr_seat *wlr_seat) { if (grab != wlr_seat->touch_state.default_grab) { wlr_seat->touch_state.grab = wlr_seat->touch_state.default_grab; - wl_signal_emit(&wlr_seat->events.touch_grab_end, grab); + wlr_signal_emit_safe(&wlr_seat->events.touch_grab_end, grab); if (grab->interface->cancel) { grab->interface->cancel(grab); } @@ -1003,7 +1004,7 @@ static void touch_point_clear_focus(struct wlr_touch_point *point) { } static void touch_point_destroy(struct wlr_touch_point *point) { - wl_signal_emit(&point->events.destroy, point); + wlr_signal_emit_safe(&point->events.destroy, point); touch_point_clear_focus(point); wl_list_remove(&point->surface_destroy.link); diff --git a/types/wlr_server_decoration.c b/types/wlr_server_decoration.c index 09909bb6..556193e2 100644 --- a/types/wlr_server_decoration.c +++ b/types/wlr_server_decoration.c @@ -1,9 +1,10 @@ #include <assert.h> -#include <stdlib.h> #include <server-decoration-protocol.h> -#include <wlr/types/wlr_surface.h> +#include <stdlib.h> #include <wlr/types/wlr_server_decoration.h> +#include <wlr/types/wlr_surface.h> #include <wlr/util/log.h> +#include "util/signal.h" static void server_decoration_handle_release(struct wl_client *client, struct wl_resource *resource) { @@ -18,14 +19,14 @@ static void server_decoration_handle_request_mode(struct wl_client *client, return; } decoration->mode = mode; - wl_signal_emit(&decoration->events.mode, decoration); + wlr_signal_emit_safe(&decoration->events.mode, decoration); org_kde_kwin_server_decoration_send_mode(decoration->resource, decoration->mode); } static void server_decoration_destroy( struct wlr_server_decoration *decoration) { - wl_signal_emit(&decoration->events.destroy, decoration); + wlr_signal_emit_safe(&decoration->events.destroy, decoration); wl_list_remove(&decoration->surface_destroy_listener.link); wl_resource_set_user_data(decoration->resource, NULL); wl_list_remove(&decoration->link); @@ -97,7 +98,7 @@ static void server_decoration_manager_handle_create(struct wl_client *client, org_kde_kwin_server_decoration_send_mode(decoration->resource, decoration->mode); - wl_signal_emit(&manager->events.new_decoration, decoration); + wlr_signal_emit_safe(&manager->events.new_decoration, decoration); } static const struct org_kde_kwin_server_decoration_manager_interface diff --git a/types/wlr_surface.c b/types/wlr_surface.c index 045e3670..c47565c4 100644 --- a/types/wlr_surface.c +++ b/types/wlr_surface.c @@ -1,12 +1,13 @@ #include <assert.h> #include <stdlib.h> #include <wayland-server.h> -#include <wlr/util/log.h> -#include <wlr/util/region.h> -#include <wlr/render/interface.h> -#include <wlr/types/wlr_surface.h> #include <wlr/render/egl.h> +#include <wlr/render/interface.h> #include <wlr/render/matrix.h> +#include <wlr/types/wlr_surface.h> +#include <wlr/util/log.h> +#include <wlr/util/region.h> +#include "util/signal.h" static void wlr_surface_state_reset_buffer(struct wlr_surface_state *state) { if (state->buffer) { @@ -395,7 +396,7 @@ static void wlr_surface_commit_pending(struct wlr_surface *surface) { } // TODO: add the invalid bitfield to this callback - wl_signal_emit(&surface->events.commit, surface); + wlr_signal_emit_safe(&surface->events.commit, surface); pixman_region32_clear(&surface->current->surface_damage); pixman_region32_clear(&surface->current->buffer_damage); @@ -559,7 +560,7 @@ static void wlr_surface_state_destroy(struct wlr_surface_state *state) { } void wlr_subsurface_destroy(struct wlr_subsurface *subsurface) { - wl_signal_emit(&subsurface->events.destroy, subsurface); + wlr_signal_emit_safe(&subsurface->events.destroy, subsurface); wlr_surface_state_destroy(subsurface->cached); @@ -578,7 +579,7 @@ void wlr_subsurface_destroy(struct wlr_subsurface *subsurface) { static void destroy_surface(struct wl_resource *resource) { struct wlr_surface *surface = wl_resource_get_user_data(resource); - wl_signal_emit(&surface->events.destroy, surface); + wlr_signal_emit_safe(&surface->events.destroy, surface); if (surface->subsurface) { wlr_subsurface_destroy(surface->subsurface); @@ -831,7 +832,7 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface, surface->subsurface = subsurface; - wl_signal_emit(&parent->events.new_subsurface, subsurface); + wlr_signal_emit_safe(&parent->events.new_subsurface, subsurface); } diff --git a/types/wlr_tablet_pad.c b/types/wlr_tablet_pad.c index 07f9da10..3d25d685 100644 --- a/types/wlr_tablet_pad.c +++ b/types/wlr_tablet_pad.c @@ -1,8 +1,8 @@ #include <stdlib.h> #include <string.h> #include <wayland-server.h> -#include <wlr/types/wlr_tablet_pad.h> #include <wlr/interfaces/wlr_tablet_pad.h> +#include <wlr/types/wlr_tablet_pad.h> void wlr_tablet_pad_init(struct wlr_tablet_pad *pad, struct wlr_tablet_pad_impl *impl) { diff --git a/types/wlr_tablet_tool.c b/types/wlr_tablet_tool.c index a396bb02..f46a5434 100644 --- a/types/wlr_tablet_tool.c +++ b/types/wlr_tablet_tool.c @@ -1,8 +1,8 @@ #include <stdlib.h> #include <string.h> #include <wayland-server.h> -#include <wlr/types/wlr_tablet_tool.h> #include <wlr/interfaces/wlr_tablet_tool.h> +#include <wlr/types/wlr_tablet_tool.h> void wlr_tablet_tool_init(struct wlr_tablet_tool *tool, struct wlr_tablet_tool_impl *impl) { diff --git a/types/wlr_touch.c b/types/wlr_touch.c index 5db653e7..ba7ffac7 100644 --- a/types/wlr_touch.c +++ b/types/wlr_touch.c @@ -1,8 +1,8 @@ #include <stdlib.h> #include <string.h> #include <wayland-server.h> -#include <wlr/types/wlr_touch.h> #include <wlr/interfaces/wlr_touch.h> +#include <wlr/types/wlr_touch.h> void wlr_touch_init(struct wlr_touch *touch, struct wlr_touch_impl *impl) { diff --git a/types/wlr_wl_shell.c b/types/wlr_wl_shell.c index dd6514df..85749ddd 100644 --- a/types/wlr_wl_shell.c +++ b/types/wlr_wl_shell.c @@ -2,12 +2,13 @@ #define _POSIX_C_SOURCE 200809L #endif #include <assert.h> +#include <stdlib.h> +#include <wayland-server-protocol.h> #include <wayland-server.h> -#include <wlr/util/log.h> #include <wlr/types/wlr_surface.h> #include <wlr/types/wlr_wl_shell.h> -#include <stdlib.h> -#include <wayland-server-protocol.h> +#include <wlr/util/log.h> +#include "util/signal.h" static const char *wlr_wl_shell_surface_role = "wl-shell-surface"; @@ -123,7 +124,7 @@ static void shell_surface_protocol_move(struct wl_client *client, .serial = serial, }; - wl_signal_emit(&surface->events.request_move, &event); + wlr_signal_emit_safe(&surface->events.request_move, &event); } static struct wlr_wl_shell_popup_grab *shell_popup_grab_from_seat( @@ -187,7 +188,7 @@ static void shell_surface_protocol_resize(struct wl_client *client, .edges = edges, }; - wl_signal_emit(&surface->events.request_resize, &event); + wlr_signal_emit_safe(&surface->events.request_resize, &event); } static void shell_surface_set_state(struct wlr_wl_shell_surface *surface, @@ -200,7 +201,7 @@ static void shell_surface_set_state(struct wlr_wl_shell_surface *surface, shell_surface_destroy_popup_state(surface); surface->popup_state = popup_state; - wl_signal_emit(&surface->events.set_state, surface); + wlr_signal_emit_safe(&surface->events.set_state, surface); } static void shell_surface_protocol_set_toplevel(struct wl_client *client, @@ -221,7 +222,7 @@ static void shell_surface_popup_set_parent(struct wlr_wl_shell_surface *surface, if (parent) { wl_list_remove(&surface->popup_link); wl_list_insert(&parent->popups, &surface->popup_link); - wl_signal_emit(&parent->events.new_popup, surface); + wlr_signal_emit_safe(&parent->events.new_popup, surface); } } @@ -290,7 +291,7 @@ static void shell_surface_protocol_set_fullscreen(struct wl_client *client, .output = output, }; - wl_signal_emit(&surface->events.request_fullscreen, &event); + wlr_signal_emit_safe(&surface->events.request_fullscreen, &event); } static void shell_surface_protocol_set_popup(struct wl_client *client, @@ -368,7 +369,7 @@ static void shell_surface_protocol_set_maximized(struct wl_client *client, .output = output, }; - wl_signal_emit(&surface->events.request_maximize, &event); + wlr_signal_emit_safe(&surface->events.request_maximize, &event); } static void shell_surface_protocol_set_title(struct wl_client *client, @@ -384,7 +385,7 @@ static void shell_surface_protocol_set_title(struct wl_client *client, free(surface->title); surface->title = tmp; - wl_signal_emit(&surface->events.set_title, surface); + wlr_signal_emit_safe(&surface->events.set_title, surface); } static void shell_surface_protocol_set_class(struct wl_client *client, @@ -400,7 +401,7 @@ static void shell_surface_protocol_set_class(struct wl_client *client, free(surface->class); surface->class = tmp; - wl_signal_emit(&surface->events.set_class, surface); + wlr_signal_emit_safe(&surface->events.set_class, surface); } static const struct wl_shell_surface_interface shell_surface_impl = { @@ -417,7 +418,7 @@ static const struct wl_shell_surface_interface shell_surface_impl = { }; static void shell_surface_destroy(struct wlr_wl_shell_surface *surface) { - wl_signal_emit(&surface->events.destroy, surface); + wlr_signal_emit_safe(&surface->events.destroy, surface); shell_surface_destroy_popup_state(surface); wl_resource_set_user_data(surface->resource, NULL); @@ -457,7 +458,7 @@ static void handle_wlr_surface_committed(struct wlr_surface *wlr_surface, wlr_surface_has_buffer(surface->surface) && surface->state != WLR_WL_SHELL_SURFACE_STATE_NONE) { surface->configured = true; - wl_signal_emit(&surface->shell->events.new_surface, surface); + wlr_signal_emit_safe(&surface->shell->events.new_surface, surface); } if (surface->popup_mapped && @@ -473,7 +474,7 @@ static void handle_wlr_surface_committed(struct wlr_surface *wlr_surface, static int shell_surface_ping_timeout(void *user_data) { struct wlr_wl_shell_surface *surface = user_data; - wl_signal_emit(&surface->events.ping_timeout, surface); + wlr_signal_emit_safe(&surface->events.ping_timeout, surface); surface->ping_serial = 0; return 1; diff --git a/types/wlr_xdg_shell_v6.c b/types/wlr_xdg_shell_v6.c index 5c820edc..eb18f022 100644 --- a/types/wlr_xdg_shell_v6.c +++ b/types/wlr_xdg_shell_v6.c @@ -6,10 +6,11 @@ #include <string.h> #include <wayland-server.h> #include <wlr/config.h> -#include <wlr/types/wlr_xdg_shell_v6.h> -#include <wlr/types/wlr_surface.h> #include <wlr/types/wlr_seat.h> +#include <wlr/types/wlr_surface.h> +#include <wlr/types/wlr_xdg_shell_v6.h> #include <wlr/util/log.h> +#include "util/signal.h" #include "xdg-shell-unstable-v6-protocol.h" static const char *wlr_desktop_xdg_toplevel_role = "xdg_toplevel"; @@ -160,7 +161,7 @@ static struct wlr_xdg_popup_grab_v6 *xdg_shell_popup_grab_from_seat( static void xdg_surface_destroy(struct wlr_xdg_surface_v6 *surface) { // TODO: probably need to ungrab before this event - wl_signal_emit(&surface->events.destroy, surface); + wlr_signal_emit_safe(&surface->events.destroy, surface); if (surface->configure_idle) { wl_event_source_remove(surface->configure_idle); @@ -511,7 +512,7 @@ static void xdg_surface_get_popup(struct wl_client *client, &zxdg_popup_v6_implementation, surface, xdg_popup_resource_destroy); - wl_signal_emit(&parent->events.new_popup, surface->popup_state); + wlr_signal_emit_safe(&parent->events.new_popup, surface->popup_state); } @@ -582,7 +583,7 @@ static void xdg_toplevel_protocol_show_window_menu(struct wl_client *client, .y = y, }; - wl_signal_emit(&surface->events.request_show_window_menu, &event); + wlr_signal_emit_safe(&surface->events.request_show_window_menu, &event); } static void xdg_toplevel_protocol_move(struct wl_client *client, @@ -610,7 +611,7 @@ static void xdg_toplevel_protocol_move(struct wl_client *client, .serial = serial, }; - wl_signal_emit(&surface->events.request_move, &event); + wlr_signal_emit_safe(&surface->events.request_move, &event); } static void xdg_toplevel_protocol_resize(struct wl_client *client, @@ -639,7 +640,7 @@ static void xdg_toplevel_protocol_resize(struct wl_client *client, .edges = edges, }; - wl_signal_emit(&surface->events.request_resize, &event); + wlr_signal_emit_safe(&surface->events.request_resize, &event); } static void xdg_toplevel_protocol_set_max_size(struct wl_client *client, @@ -660,14 +661,14 @@ static void xdg_toplevel_protocol_set_maximized(struct wl_client *client, struct wl_resource *resource) { struct wlr_xdg_surface_v6 *surface = wl_resource_get_user_data(resource); surface->toplevel_state->next.maximized = true; - wl_signal_emit(&surface->events.request_maximize, surface); + wlr_signal_emit_safe(&surface->events.request_maximize, surface); } static void xdg_toplevel_protocol_unset_maximized(struct wl_client *client, struct wl_resource *resource) { struct wlr_xdg_surface_v6 *surface = wl_resource_get_user_data(resource); surface->toplevel_state->next.maximized = false; - wl_signal_emit(&surface->events.request_maximize, surface); + wlr_signal_emit_safe(&surface->events.request_maximize, surface); } static void xdg_toplevel_protocol_set_fullscreen(struct wl_client *client, @@ -687,7 +688,7 @@ static void xdg_toplevel_protocol_set_fullscreen(struct wl_client *client, .output = output, }; - wl_signal_emit(&surface->events.request_fullscreen, &event); + wlr_signal_emit_safe(&surface->events.request_fullscreen, &event); } static void xdg_toplevel_protocol_unset_fullscreen(struct wl_client *client, @@ -702,13 +703,13 @@ static void xdg_toplevel_protocol_unset_fullscreen(struct wl_client *client, .output = NULL, }; - wl_signal_emit(&surface->events.request_fullscreen, &event); + wlr_signal_emit_safe(&surface->events.request_fullscreen, &event); } static void xdg_toplevel_protocol_set_minimized(struct wl_client *client, struct wl_resource *resource) { struct wlr_xdg_surface_v6 *surface = wl_resource_get_user_data(resource); - wl_signal_emit(&surface->events.request_minimize, surface); + wlr_signal_emit_safe(&surface->events.request_minimize, surface); } static const struct zxdg_toplevel_v6_interface zxdg_toplevel_v6_implementation = @@ -1123,7 +1124,7 @@ static void handle_wlr_surface_committed(struct wlr_surface *wlr_surface, if (surface->configured && !surface->added) { surface->added = true; - wl_signal_emit(&surface->client->shell->events.new_surface, surface); + wlr_signal_emit_safe(&surface->client->shell->events.new_surface, surface); } } @@ -1243,7 +1244,7 @@ static int wlr_xdg_client_v6_ping_timeout(void *user_data) { struct wlr_xdg_surface_v6 *surface; wl_list_for_each(surface, &client->surfaces, link) { - wl_signal_emit(&surface->events.ping_timeout, surface); + wlr_signal_emit_safe(&surface->events.ping_timeout, surface); } client->ping_serial = 0; @@ -3,9 +3,9 @@ #include <stdarg.h> #include <stdio.h> #include <stdlib.h> -#include <unistd.h> #include <string.h> #include <time.h> +#include <unistd.h> #include <wlr/util/log.h> static bool colored = true; diff --git a/util/meson.build b/util/meson.build index 34aa428b..adc52a53 100644 --- a/util/meson.build +++ b/util/meson.build @@ -4,6 +4,7 @@ lib_wlr_util = static_library( 'log.c', 'os-compatibility.c', 'region.c', + 'signal.c', ), include_directories: wlr_inc, dependencies: [wayland_server, pixman], diff --git a/util/os-compatibility.c b/util/os-compatibility.c index 98aeab3d..bd3067d2 100644 --- a/util/os-compatibility.c +++ b/util/os-compatibility.c @@ -24,13 +24,13 @@ */ #define _XOPEN_SOURCE 700 -#include <sys/types.h> -#include <sys/socket.h> -#include <unistd.h> -#include <fcntl.h> #include <errno.h> -#include <string.h> +#include <fcntl.h> #include <stdlib.h> +#include <string.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <unistd.h> #include "util/os-compatibility.h" int os_fd_set_cloexec(int fd) { diff --git a/util/region.c b/util/region.c index 1bde0cb8..88e38fd2 100644 --- a/util/region.c +++ b/util/region.c @@ -1,5 +1,5 @@ -#include <stdlib.h> #include <math.h> +#include <stdlib.h> #include <wlr/util/region.h> void wlr_region_scale(pixman_region32_t *dst, pixman_region32_t *src, diff --git a/util/signal.c b/util/signal.c new file mode 100644 index 00000000..39618465 --- /dev/null +++ b/util/signal.c @@ -0,0 +1,34 @@ +#include "util/signal.h" + +static void handle_noop(struct wl_listener *listener, void *data) { + // Do nothing +} + +void wlr_signal_emit_safe(struct wl_signal *signal, void *data) { + struct wl_listener cursor; + struct wl_listener end; + + /* Add two special markers: one cursor and one end marker. This way, we know + * that we've already called listeners on the left of the cursor and that we + * don't want to call listeners on the right of the end marker. The 'it' + * function can remove any element it wants from the list without troubles. + * wl_list_for_each_safe tries to be safe but it fails: it works fine + * if the current item is removed, but not if the next one is. */ + wl_list_insert(&signal->listener_list, &cursor.link); + cursor.notify = handle_noop; + wl_list_insert(signal->listener_list.prev, &end.link); + end.notify = handle_noop; + + while (cursor.link.next != &end.link) { + struct wl_list *pos = cursor.link.next; + struct wl_listener *l = wl_container_of(pos, l, link); + + wl_list_remove(&cursor.link); + wl_list_insert(pos, &cursor.link); + + l->notify(l, data); + } + + wl_list_remove(&cursor.link); + wl_list_remove(&end.link); +} diff --git a/xcursor/meson.build b/xcursor/meson.build index afaab915..31040a92 100644 --- a/xcursor/meson.build +++ b/xcursor/meson.build @@ -1,8 +1,8 @@ lib_wlr_xcursor = static_library( 'wlr_xcursor', files( - 'xcursor.c', 'wlr_xcursor.c', + 'xcursor.c', ), include_directories: wlr_inc, dependencies: [egl] # header required via include/wlr/render.h diff --git a/xcursor/wlr_xcursor.c b/xcursor/wlr_xcursor.c index 2d1a38b5..7fcdbb6f 100644 --- a/xcursor/wlr_xcursor.c +++ b/xcursor/wlr_xcursor.c @@ -24,12 +24,12 @@ */ #define _XOPEN_SOURCE 500 -#include <wlr/xcursor.h> -#include <wlr/util/log.h> +#include <stdint.h> #include <stdio.h> #include <stdlib.h> -#include <stdint.h> #include <string.h> +#include <wlr/util/log.h> +#include <wlr/xcursor.h> #include "xcursor/xcursor.h" static void wlr_xcursor_destroy(struct wlr_xcursor *cursor) { diff --git a/xcursor/xcursor.c b/xcursor/xcursor.c index 8dc35a7c..32711105 100644 --- a/xcursor/xcursor.c +++ b/xcursor/xcursor.c @@ -24,11 +24,11 @@ */ #define _DEFAULT_SOURCE -#include "xcursor/xcursor.h" +#include <dirent.h> #include <stdio.h> #include <stdlib.h> #include <string.h> -#include <dirent.h> +#include "xcursor/xcursor.h" /* * From libXcursor/include/X11/extensions/Xcursor.h diff --git a/xwayland/selection.c b/xwayland/selection.c index 060c0baf..ffcde4d0 100644 --- a/xwayland/selection.c +++ b/xwayland/selection.c @@ -1,14 +1,14 @@ #define _XOPEN_SOURCE 700 +#include <assert.h> +#include <fcntl.h> #include <stdlib.h> -#include <unistd.h> #include <string.h> -#include <assert.h> +#include <unistd.h> +#include <wlr/types/wlr_data_device.h> +#include <wlr/types/wlr_primary_selection.h> +#include <wlr/util/log.h> +#include <wlr/xwm.h> #include <xcb/xfixes.h> -#include <fcntl.h> -#include "wlr/util/log.h" -#include "wlr/types/wlr_data_device.h" -#include "wlr/types/wlr_primary_selection.h" -#include "wlr/xwm.h" static const size_t incr_chunk_size = 64 * 1024; diff --git a/xwayland/sockets.c b/xwayland/sockets.c index 2119056d..1e943b1d 100644 --- a/xwayland/sockets.c +++ b/xwayland/sockets.c @@ -3,19 +3,19 @@ // for SOCK_CLOEXEC #define __BSD_VISIBLE 1 #endif -#include <stdlib.h> +#include <errno.h> +#include <fcntl.h> +#include <signal.h> #include <stddef.h> #include <stdint.h> #include <stdio.h> -#include <sys/types.h> -#include <sys/stat.h> -#include <fcntl.h> -#include <signal.h> -#include <unistd.h> +#include <stdlib.h> #include <sys/socket.h> +#include <sys/stat.h> +#include <sys/types.h> #include <sys/un.h> -#include <errno.h> -#include "wlr/util/log.h" +#include <unistd.h> +#include <wlr/util/log.h> #include "sockets.h" static const char *lock_fmt = "/tmp/.X%d-lock"; diff --git a/xwayland/xwayland.c b/xwayland/xwayland.c index 6c700cc5..1d935180 100644 --- a/xwayland/xwayland.c +++ b/xwayland/xwayland.c @@ -4,22 +4,23 @@ // for SOCK_CLOEXEC #define __BSD_VISIBLE 1 #endif -#include <stdlib.h> -#include <stdio.h> -#include <unistd.h> +#include <errno.h> #include <fcntl.h> #include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdlib.h> #include <sys/socket.h> #include <sys/types.h> #include <sys/wait.h> #include <time.h> -#include <stdlib.h> -#include <errno.h> +#include <unistd.h> #include <wayland-server.h> -#include "wlr/util/log.h" -#include "wlr/xwayland.h" +#include <wlr/util/log.h> +#include <wlr/xwayland.h> +#include <wlr/xwm.h> #include "sockets.h" -#include "wlr/xwm.h" +#include "util/signal.h" #ifdef __FreeBSD__ static inline int clearenv(void) { @@ -237,7 +238,7 @@ static int xserver_handle_ready(int signal_number, void *data) { snprintf(display_name, sizeof(display_name), ":%d", wlr_xwayland->display); setenv("DISPLAY", display_name, true); - wl_signal_emit(&wlr_xwayland->events.ready, wlr_xwayland); + wlr_signal_emit_safe(&wlr_xwayland->events.ready, wlr_xwayland); /* ready is a one-shot signal, fire and forget */ wl_signal_init(&wlr_xwayland->events.ready); diff --git a/xwayland/xwm.c b/xwayland/xwm.c index e59c6e66..10bc2e30 100644 --- a/xwayland/xwm.c +++ b/xwayland/xwm.c @@ -3,17 +3,18 @@ #endif #include <stdlib.h> #include <unistd.h> +#include <wlr/config.h> +#include <wlr/types/wlr_surface.h> +#include <wlr/util/edges.h> +#include <wlr/util/log.h> +#include <wlr/xcursor.h> +#include <wlr/xwayland.h> +#include <wlr/xwm.h> #include <xcb/composite.h> -#include <xcb/xfixes.h> -#include <xcb/xcb_image.h> #include <xcb/render.h> -#include <wlr/config.h> -#include "wlr/util/log.h" -#include "wlr/util/edges.h" -#include "wlr/types/wlr_surface.h" -#include "wlr/xwayland.h" -#include "wlr/xcursor.h" -#include "wlr/xwm.h" +#include <xcb/xcb_image.h> +#include <xcb/xfixes.h> +#include "util/signal.h" #ifdef WLR_HAS_XCB_ICCCM #include <xcb/xcb_icccm.h> @@ -210,7 +211,7 @@ static void xsurface_set_net_wm_state(struct wlr_xwayland_surface *xsurface) { static void wlr_xwayland_surface_destroy( struct wlr_xwayland_surface *xsurface) { - wl_signal_emit(&xsurface->events.destroy, xsurface); + wlr_signal_emit_safe(&xsurface->events.destroy, xsurface); if (xsurface == xsurface->xwm->focus_surface) { xwm_surface_activate(xsurface->xwm, NULL); @@ -266,7 +267,7 @@ static void read_surface_class(struct wlr_xwm *xwm, wlr_log(L_DEBUG, "XCB_ATOM_WM_CLASS: %s %s", surface->instance, surface->class); - wl_signal_emit(&surface->events.set_class, surface); + wlr_signal_emit_safe(&surface->events.set_class, surface); } static void read_surface_title(struct wlr_xwm *xwm, @@ -291,7 +292,7 @@ static void read_surface_title(struct wlr_xwm *xwm, } wlr_log(L_DEBUG, "XCB_ATOM_WM_NAME: %s", xsurface->title); - wl_signal_emit(&xsurface->events.set_title, xsurface); + wlr_signal_emit_safe(&xsurface->events.set_title, xsurface); } static void read_surface_parent(struct wlr_xwm *xwm, @@ -316,7 +317,7 @@ static void read_surface_parent(struct wlr_xwm *xwm, } wlr_log(L_DEBUG, "XCB_ATOM_WM_TRANSIENT_FOR: %p", xsurface->parent); - wl_signal_emit(&xsurface->events.set_parent, xsurface); + wlr_signal_emit_safe(&xsurface->events.set_parent, xsurface); } static void read_surface_pid(struct wlr_xwm *xwm, @@ -329,7 +330,7 @@ static void read_surface_pid(struct wlr_xwm *xwm, pid_t *pid = xcb_get_property_value(reply); xsurface->pid = *pid; wlr_log(L_DEBUG, "NET_WM_PID %d", xsurface->pid); - wl_signal_emit(&xsurface->events.set_pid, xsurface); + wlr_signal_emit_safe(&xsurface->events.set_pid, xsurface); } static void read_surface_window_type(struct wlr_xwm *xwm, @@ -352,7 +353,7 @@ static void read_surface_window_type(struct wlr_xwm *xwm, xsurface->window_type_len = atoms_len; wlr_log(L_DEBUG, "NET_WM_WINDOW_TYPE (%zu)", atoms_len); - wl_signal_emit(&xsurface->events.set_window_type, xsurface); + wlr_signal_emit_safe(&xsurface->events.set_window_type, xsurface); } static void read_surface_protocols(struct wlr_xwm *xwm, @@ -535,7 +536,7 @@ static void handle_surface_commit(struct wlr_surface *wlr_surface, if (!xsurface->added && wlr_surface_has_buffer(xsurface->surface) && xsurface->mapped) { - wl_signal_emit(&xsurface->xwm->xwayland->events.new_surface, xsurface); + wlr_signal_emit_safe(&xsurface->xwm->xwayland->events.new_surface, xsurface); xsurface->added = true; } } @@ -578,7 +579,7 @@ static void xwm_map_shell_surface(struct wlr_xwm *xwm, wl_signal_add(&surface->events.destroy, &xsurface->surface_destroy); xsurface->mapped = true; - wl_signal_emit(&xsurface->events.map_notify, xsurface); + wlr_signal_emit_safe(&xsurface->events.map_notify, xsurface); } static void xwm_handle_create_notify(struct wlr_xwm *xwm, @@ -626,7 +627,7 @@ static void xwm_handle_configure_request(struct wlr_xwm *xwm, wlr_event->width = ev->width; wlr_event->height = ev->height; - wl_signal_emit(&xsurface->events.request_configure, wlr_event); + wlr_signal_emit_safe(&xsurface->events.request_configure, wlr_event); free(wlr_event); } @@ -710,7 +711,7 @@ static void xwm_handle_unmap_notify(struct wlr_xwm *xwm, if (xsurface->mapped) { xsurface->mapped = false; - wl_signal_emit(&xsurface->events.unmap_notify, xsurface); + wlr_signal_emit_safe(&xsurface->events.unmap_notify, xsurface); } xsurface_set_wm_state(xsurface, ICCCM_WITHDRAWN_STATE); @@ -814,7 +815,7 @@ static void xwm_handle_net_wm_moveresize_message(struct wlr_xwm *xwm, switch (detail) { case _NET_WM_MOVERESIZE_MOVE: move_event.surface = xsurface; - wl_signal_emit(&xsurface->events.request_move, &move_event); + wlr_signal_emit_safe(&xsurface->events.request_move, &move_event); break; case _NET_WM_MOVERESIZE_SIZE_TOPLEFT: case _NET_WM_MOVERESIZE_SIZE_TOP: @@ -826,7 +827,7 @@ static void xwm_handle_net_wm_moveresize_message(struct wlr_xwm *xwm, case _NET_WM_MOVERESIZE_SIZE_LEFT: resize_event.surface = xsurface; resize_event.edges = net_wm_edges_to_wlr(detail); - wl_signal_emit(&xsurface->events.request_resize, &resize_event); + wlr_signal_emit_safe(&xsurface->events.request_resize, &resize_event); break; case _NET_WM_MOVERESIZE_CANCEL: // handled by the compositor @@ -904,7 +905,7 @@ static void xwm_handle_net_wm_state_message(struct wlr_xwm *xwm, xsurface->saved_height = xsurface->height; } - wl_signal_emit(&xsurface->events.request_fullscreen, xsurface); + wlr_signal_emit_safe(&xsurface->events.request_fullscreen, xsurface); } if (maximized != xsurface_is_maximized(xsurface)) { @@ -913,7 +914,7 @@ static void xwm_handle_net_wm_state_message(struct wlr_xwm *xwm, xsurface->saved_height = xsurface->height; } - wl_signal_emit(&xsurface->events.request_maximize, xsurface); + wlr_signal_emit_safe(&xsurface->events.request_maximize, xsurface); } } |