diff options
50 files changed, 2783 insertions, 222 deletions
diff --git a/backend/headless/input_device.c b/backend/headless/input_device.c index e0411c27..a2474aeb 100644 --- a/backend/headless/input_device.c +++ b/backend/headless/input_device.c @@ -60,12 +60,12 @@ struct wlr_input_device *wlr_headless_add_input_device( wlr_touch_init(wlr_device->touch, NULL); break; case WLR_INPUT_DEVICE_TABLET_TOOL: - wlr_device->tablet_tool = calloc(1, sizeof(struct wlr_tablet_tool)); - if (wlr_device->tablet_tool == NULL) { - wlr_log(WLR_ERROR, "Unable to allocate wlr_tablet_tool"); + wlr_device->tablet = calloc(1, sizeof(struct wlr_tablet)); + if (wlr_device->tablet == NULL) { + wlr_log(WLR_ERROR, "Unable to allocate wlr_tablet"); goto error; } - wlr_tablet_tool_init(wlr_device->tablet_tool, NULL); + wlr_tablet_init(wlr_device->tablet, NULL); break; case WLR_INPUT_DEVICE_TABLET_PAD: wlr_device->tablet_pad = calloc(1, sizeof(struct wlr_tablet_pad)); diff --git a/backend/libinput/events.c b/backend/libinput/events.c index 93664af2..0548e502 100644 --- a/backend/libinput/events.c +++ b/backend/libinput/events.c @@ -130,8 +130,8 @@ static void handle_device_added(struct wlr_libinput_backend *backend, if (!wlr_dev) { goto fail; } - wlr_dev->tablet_tool = create_libinput_tablet_tool(libinput_dev); - if (!wlr_dev->tablet_tool) { + wlr_dev->tablet = create_libinput_tablet(libinput_dev); + if (!wlr_dev->tablet) { free(wlr_dev); goto fail; } diff --git a/backend/libinput/tablet_pad.c b/backend/libinput/tablet_pad.c index 626c2219..579a11cf 100644 --- a/backend/libinput/tablet_pad.c +++ b/backend/libinput/tablet_pad.c @@ -1,4 +1,8 @@ +#ifndef _POSIX_C_SOURCE +#define _POSIX_C_SOURCE 200809L +#endif #include <assert.h> +#include <string.h> #include <libinput.h> #include <stdlib.h> #include <wlr/backend/session.h> @@ -8,6 +12,60 @@ #include "backend/libinput.h" #include "util/signal.h" +// FIXME: Decide on how to alloc/count here +static void add_pad_group_from_libinput(struct wlr_tablet_pad *pad, + struct libinput_device *device, unsigned int index) { + struct libinput_tablet_pad_mode_group *li_group = + libinput_device_tablet_pad_get_mode_group(device, index); + struct wlr_tablet_pad_group *group = + calloc(1, sizeof(struct wlr_tablet_pad_group)); + if (!group) { + return; + } + + for (size_t i = 0; i < pad->ring_count; ++i) { + if (libinput_tablet_pad_mode_group_has_ring(li_group, i)) { + ++group->ring_count; + } + } + group->rings = calloc(sizeof(int), group->ring_count); + size_t ring = 0; + for (size_t i = 0; i < pad->ring_count; ++i) { + if (libinput_tablet_pad_mode_group_has_ring(li_group, i)) { + group->rings[ring++] = i; + } + } + + for (size_t i = 0; i < pad->strip_count; ++i) { + if (libinput_tablet_pad_mode_group_has_strip(li_group, i)) { + ++group->strip_count; + } + } + group->strips = calloc(sizeof(int), group->strip_count); + size_t strip = 0; + for (size_t i = 0; i < pad->strip_count; ++i) { + if (libinput_tablet_pad_mode_group_has_strip(li_group, i)) { + group->strips[strip++] = i; + } + } + + for (size_t i = 0; i < pad->button_count; ++i) { + if (libinput_tablet_pad_mode_group_has_button(li_group, i)) { + ++group->button_count; + } + } + group->buttons = calloc(sizeof(int), group->button_count); + size_t button = 0; + for (size_t i = 0; i < pad->button_count; ++i) { + if (libinput_tablet_pad_mode_group_has_button(li_group, i)) { + group->buttons[button++] = i; + } + } + + group->mode_count = libinput_tablet_pad_mode_group_get_num_modes(li_group); + wl_list_insert(&pad->groups, &group->link); +} + struct wlr_tablet_pad *create_libinput_tablet_pad( struct libinput_device *libinput_dev) { assert(libinput_dev); @@ -16,6 +74,24 @@ struct wlr_tablet_pad *create_libinput_tablet_pad( wlr_log(WLR_ERROR, "Unable to allocate wlr_tablet_pad"); return NULL; } + + wlr_tablet_pad->button_count = + libinput_device_tablet_pad_get_num_buttons(libinput_dev); + wlr_tablet_pad->ring_count = + libinput_device_tablet_pad_get_num_rings(libinput_dev); + wlr_tablet_pad->strip_count = + libinput_device_tablet_pad_get_num_strips(libinput_dev); + + wlr_list_init(&wlr_tablet_pad->paths); + struct udev_device *udev = libinput_device_get_udev_device(libinput_dev); + wlr_list_push(&wlr_tablet_pad->paths, strdup(udev_device_get_syspath(udev))); + + wl_list_init(&wlr_tablet_pad->groups); + int groups = libinput_device_tablet_pad_get_num_mode_groups(libinput_dev); + for (int i = 0; i < groups; ++i) { + add_pad_group_from_libinput(wlr_tablet_pad, libinput_dev, i); + } + wlr_tablet_pad_init(wlr_tablet_pad, NULL); return wlr_tablet_pad; } @@ -35,6 +111,8 @@ void handle_tablet_pad_button(struct libinput_event *event, usec_to_msec(libinput_event_tablet_pad_get_time_usec(pevent)); wlr_event.button = libinput_event_tablet_pad_get_button_number(pevent); wlr_event.mode = libinput_event_tablet_pad_get_mode(pevent); + wlr_event.group = libinput_tablet_pad_mode_group_get_index( + libinput_event_tablet_pad_get_mode_group(pevent)); switch (libinput_event_tablet_pad_get_button_state(pevent)) { case LIBINPUT_BUTTON_STATE_PRESSED: wlr_event.state = WLR_BUTTON_PRESSED; diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index e9308b65..adfc6221 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -1,6 +1,11 @@ +#ifndef _POSIX_C_SOURCE +#define _POSIX_C_SOURCE 200809L +#endif +#include <string.h> #include <assert.h> #include <libinput.h> #include <stdlib.h> +#include <wayland-util.h> #include <wlr/backend/session.h> #include <wlr/interfaces/wlr_tablet_tool.h> #include <wlr/types/wlr_input_device.h> @@ -8,16 +13,174 @@ #include "backend/libinput.h" #include "util/signal.h" -struct wlr_tablet_tool *create_libinput_tablet_tool( +static struct wlr_tablet_impl tablet_impl; + +static bool tablet_is_libinput(struct wlr_tablet *tablet) { + return tablet->impl == &tablet_impl; +} + +struct wlr_libinput_tablet_tool { + struct wlr_tablet_tool wlr_tool; + + struct libinput_tablet_tool *libinput_tool; + + bool unique; + // Refcount for destroy + release + size_t pad_refs; +}; + +// TODO: Maybe this should be a wlr_list? Do we keep it, or want to get rid of +// it? +struct tablet_tool_list_elem { + struct wl_list link; + + struct wlr_libinput_tablet_tool *tool; +}; + +struct wlr_libinput_tablet { + struct wlr_tablet wlr_tablet; + + struct wl_list tools; // tablet_tool_list_elem::link +}; + +static void destroy_tool(struct wlr_libinput_tablet_tool *tool) { + wlr_signal_emit_safe(&tool->wlr_tool.events.destroy, &tool->wlr_tool); + libinput_tablet_tool_ref(tool->libinput_tool); + libinput_tablet_tool_set_user_data(tool->libinput_tool, NULL); + free(tool); +} + + +static void destroy_tablet(struct wlr_tablet *wlr_tablet) { + assert(tablet_is_libinput(wlr_tablet)); + struct wlr_libinput_tablet *tablet = + wl_container_of(wlr_tablet, tablet, wlr_tablet); + + struct tablet_tool_list_elem *pos; + struct tablet_tool_list_elem *tmp; + wl_list_for_each_safe(pos, tmp, &tablet->tools, link) { + struct wlr_libinput_tablet_tool *tool = pos->tool; + wl_list_remove(&pos->link); + free(pos); + + if (--tool->pad_refs == 0) { + destroy_tool(tool); + } + } + + free(tablet); +} + +static struct wlr_tablet_impl tablet_impl = { + .destroy = destroy_tablet, +}; + +struct wlr_tablet *create_libinput_tablet( struct libinput_device *libinput_dev) { assert(libinput_dev); - struct wlr_tablet_tool *wlr_tablet_tool = calloc(1, sizeof(struct wlr_tablet_tool)); - if (!wlr_tablet_tool) { + struct wlr_libinput_tablet *libinput_tablet = + calloc(1, sizeof(struct wlr_libinput_tablet)); + if (!libinput_tablet) { wlr_log(WLR_ERROR, "Unable to allocate wlr_tablet_tool"); return NULL; } - wlr_tablet_tool_init(wlr_tablet_tool, NULL); - return wlr_tablet_tool; + struct wlr_tablet *wlr_tablet = &libinput_tablet->wlr_tablet; + + wlr_list_init(&wlr_tablet->paths); + struct udev_device *udev = libinput_device_get_udev_device(libinput_dev); + wlr_list_push(&wlr_tablet->paths, strdup(udev_device_get_syspath(udev))); + wlr_tablet->name = strdup(libinput_device_get_name(libinput_dev)); + wl_list_init(&libinput_tablet->tools); + + wlr_tablet_init(wlr_tablet, &tablet_impl); + return wlr_tablet; +} + +static enum wlr_tablet_tool_type wlr_type_from_libinput_type( + enum libinput_tablet_tool_type value) { + switch (value) { + case LIBINPUT_TABLET_TOOL_TYPE_PEN: + return WLR_TABLET_TOOL_TYPE_PEN; + case LIBINPUT_TABLET_TOOL_TYPE_ERASER: + return WLR_TABLET_TOOL_TYPE_ERASER; + case LIBINPUT_TABLET_TOOL_TYPE_BRUSH: + return WLR_TABLET_TOOL_TYPE_BRUSH; + case LIBINPUT_TABLET_TOOL_TYPE_PENCIL: + return WLR_TABLET_TOOL_TYPE_PENCIL; + case LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH: + return WLR_TABLET_TOOL_TYPE_AIRBRUSH; + case LIBINPUT_TABLET_TOOL_TYPE_MOUSE: + return WLR_TABLET_TOOL_TYPE_MOUSE; + case LIBINPUT_TABLET_TOOL_TYPE_LENS: + return WLR_TABLET_TOOL_TYPE_LENS; + } + + assert(false && "UNREACHABLE"); +} + +static struct wlr_libinput_tablet_tool *get_wlr_tablet_tool( + struct libinput_tablet_tool *tool) { + struct wlr_libinput_tablet_tool *ret = + libinput_tablet_tool_get_user_data(tool); + + if (ret) { + return ret; + } + + ret = calloc(1, sizeof(struct wlr_libinput_tablet_tool)); + if (!ret) { + return NULL; + } + + ret->libinput_tool = libinput_tablet_tool_ref(tool); + ret->wlr_tool.pressure = libinput_tablet_tool_has_pressure(tool); + ret->wlr_tool.distance = libinput_tablet_tool_has_distance(tool); + ret->wlr_tool.tilt = libinput_tablet_tool_has_tilt(tool); + ret->wlr_tool.rotation = libinput_tablet_tool_has_rotation(tool); + ret->wlr_tool.slider = libinput_tablet_tool_has_slider(tool); + ret->wlr_tool.wheel = libinput_tablet_tool_has_wheel(tool); + + ret->wlr_tool.hardware_serial = libinput_tablet_tool_get_serial(tool); + ret->wlr_tool.hardware_wacom = libinput_tablet_tool_get_tool_id(tool); + ret->wlr_tool.type = wlr_type_from_libinput_type( + libinput_tablet_tool_get_type(tool)); + + ret->unique = libinput_tablet_tool_is_unique(tool); + + wl_signal_init(&ret->wlr_tool.events.destroy); + + libinput_tablet_tool_set_user_data(tool, ret); + return ret; +} + +static void ensure_tool_reference(struct wlr_libinput_tablet_tool *tool, + struct wlr_tablet *wlr_dev) { + assert(tablet_is_libinput(wlr_dev)); + struct wlr_libinput_tablet *tablet = wl_container_of(wlr_dev, tablet, wlr_tablet); + + struct tablet_tool_list_elem *pos; + wl_list_for_each(pos, &tablet->tools, link) { + if (pos->tool == tool) { // We already have a ref + // XXX: We *could* optimize the tool to the front of + // the list here, since we will probably get the next + // couple of events from the same tool. + // BUT the list should always be rather short (probably + // single digit amount of tools) so it might be more + // work than it saves + return; + } + } + + struct tablet_tool_list_elem *new = + calloc(1, sizeof(struct tablet_tool_list_elem)); + if (!new) { + wlr_log(WLR_ERROR, "Failed to allocate memory for tracking tablet tool"); + return; + } + + new->tool = tool; + wl_list_insert(&tablet->tools, &new->link); + ++tool->pad_refs; } void handle_tablet_tool_axis(struct libinput_event *event, @@ -31,16 +194,23 @@ void handle_tablet_tool_axis(struct libinput_event *event, struct libinput_event_tablet_tool *tevent = libinput_event_get_tablet_tool_event(event); struct wlr_event_tablet_tool_axis wlr_event = { 0 }; + struct wlr_libinput_tablet_tool *tool = get_wlr_tablet_tool( + libinput_event_tablet_tool_get_tool(tevent)); + ensure_tool_reference(tool, wlr_dev->tablet); + wlr_event.device = wlr_dev; + wlr_event.tool = &tool->wlr_tool; wlr_event.time_msec = usec_to_msec(libinput_event_tablet_tool_get_time_usec(tevent)); if (libinput_event_tablet_tool_x_has_changed(tevent)) { wlr_event.updated_axes |= WLR_TABLET_TOOL_AXIS_X; wlr_event.x = libinput_event_tablet_tool_get_x_transformed(tevent, 1); + wlr_event.dx = libinput_event_tablet_tool_get_dx(tevent); } if (libinput_event_tablet_tool_y_has_changed(tevent)) { wlr_event.updated_axes |= WLR_TABLET_TOOL_AXIS_Y; wlr_event.y = libinput_event_tablet_tool_get_y_transformed(tevent, 1); + wlr_event.dy = libinput_event_tablet_tool_get_dy(tevent); } if (libinput_event_tablet_tool_pressure_has_changed(tevent)) { wlr_event.updated_axes |= WLR_TABLET_TOOL_AXIS_PRESSURE; @@ -70,7 +240,7 @@ void handle_tablet_tool_axis(struct libinput_event *event, wlr_event.updated_axes |= WLR_TABLET_TOOL_AXIS_WHEEL; wlr_event.wheel_delta = libinput_event_tablet_tool_get_wheel_delta(tevent); } - wlr_signal_emit_safe(&wlr_dev->tablet_tool->events.axis, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->tablet->events.axis, &wlr_event); } void handle_tablet_tool_proximity(struct libinput_event *event, @@ -84,6 +254,11 @@ void handle_tablet_tool_proximity(struct libinput_event *event, struct libinput_event_tablet_tool *tevent = libinput_event_get_tablet_tool_event(event); struct wlr_event_tablet_tool_proximity wlr_event = { 0 }; + struct wlr_libinput_tablet_tool *tool = get_wlr_tablet_tool( + libinput_event_tablet_tool_get_tool(tevent)); + ensure_tool_reference(tool, wlr_dev->tablet); + + wlr_event.tool = &tool->wlr_tool; wlr_event.device = wlr_dev; wlr_event.time_msec = usec_to_msec(libinput_event_tablet_tool_get_time_usec(tevent)); @@ -93,10 +268,36 @@ void handle_tablet_tool_proximity(struct libinput_event *event, break; case LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN: wlr_event.state = WLR_TABLET_TOOL_PROXIMITY_IN; - handle_tablet_tool_axis(event, libinput_dev); break; } - wlr_signal_emit_safe(&wlr_dev->tablet_tool->events.proximity, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->tablet->events.proximity, &wlr_event); + + if (libinput_event_tablet_tool_get_proximity_state(tevent) == LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN) { + handle_tablet_tool_axis(event, libinput_dev); + } + + // If the tool is not unique, libinput will not find it again after the + // proximity out, so we should destroy it + if (!tool->unique && + libinput_event_tablet_tool_get_proximity_state(tevent) == LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT) { + // The tool isn't unique, it can't be on multiple tablets + assert(tool->pad_refs == 1); + assert(tablet_is_libinput(wlr_dev->tablet)); + struct wlr_libinput_tablet *tablet = + wl_container_of(wlr_dev->tablet, tablet, wlr_tablet); + struct tablet_tool_list_elem *pos; + struct tablet_tool_list_elem *tmp; + + wl_list_for_each_safe(pos, tmp, &tablet->tools, link) { + if (pos->tool == tool) { + wl_list_remove(&pos->link); + free(pos); + break; + } + } + + destroy_tool(tool); + } } void handle_tablet_tool_tip(struct libinput_event *event, @@ -111,7 +312,12 @@ void handle_tablet_tool_tip(struct libinput_event *event, struct libinput_event_tablet_tool *tevent = libinput_event_get_tablet_tool_event(event); struct wlr_event_tablet_tool_tip wlr_event = { 0 }; + struct wlr_libinput_tablet_tool *tool = get_wlr_tablet_tool( + libinput_event_tablet_tool_get_tool(tevent)); + ensure_tool_reference(tool, wlr_dev->tablet); + wlr_event.device = wlr_dev; + wlr_event.tool = &tool->wlr_tool; wlr_event.time_msec = usec_to_msec(libinput_event_tablet_tool_get_time_usec(tevent)); switch (libinput_event_tablet_tool_get_tip_state(tevent)) { @@ -122,7 +328,7 @@ void handle_tablet_tool_tip(struct libinput_event *event, wlr_event.state = WLR_TABLET_TOOL_TIP_DOWN; break; } - wlr_signal_emit_safe(&wlr_dev->tablet_tool->events.tip, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->tablet->events.tip, &wlr_event); } void handle_tablet_tool_button(struct libinput_event *event, @@ -137,7 +343,12 @@ void handle_tablet_tool_button(struct libinput_event *event, struct libinput_event_tablet_tool *tevent = libinput_event_get_tablet_tool_event(event); struct wlr_event_tablet_tool_button wlr_event = { 0 }; + struct wlr_libinput_tablet_tool *tool = get_wlr_tablet_tool( + libinput_event_tablet_tool_get_tool(tevent)); + ensure_tool_reference(tool, wlr_dev->tablet); + wlr_event.device = wlr_dev; + wlr_event.tool = &tool->wlr_tool; wlr_event.time_msec = usec_to_msec(libinput_event_tablet_tool_get_time_usec(tevent)); wlr_event.button = libinput_event_tablet_tool_get_button(tevent); @@ -149,5 +360,5 @@ void handle_tablet_tool_button(struct libinput_event *event, wlr_event.state = WLR_BUTTON_PRESSED; break; } - wlr_signal_emit_safe(&wlr_dev->tablet_tool->events.button, &wlr_event); + wlr_signal_emit_safe(&wlr_dev->tablet->events.button, &wlr_event); } diff --git a/docs/env_vars.md b/docs/env_vars.md index 3f1926d3..b28849cc 100644 --- a/docs/env_vars.md +++ b/docs/env_vars.md @@ -12,6 +12,8 @@ wlroots specific wayland, x11, headless) * *WLR_WL_OUTPUTS*: when using the wayland backend specifies the number of outputs * *WLR_X11_OUTPUTS*: when using the X11 backend specifies the number of outputs +* *WLR_HEADLESS_OUTPUTS*: when using the headless backend specifies the number + of outputs rootston specific ------------------ diff --git a/examples/tablet.c b/examples/tablet.c index 7332afe0..4a27d0e1 100644 --- a/examples/tablet.c +++ b/examples/tablet.c @@ -326,11 +326,11 @@ void new_input_notify(struct wl_listener *listener, void *data) { tstate->destroy.notify = tablet_tool_destroy_notify; wl_signal_add(&device->events.destroy, &tstate->destroy); tstate->axis.notify = tablet_tool_axis_notify; - wl_signal_add(&device->tablet_tool->events.axis, &tstate->axis); + wl_signal_add(&device->tablet->events.axis, &tstate->axis); tstate->proximity.notify = tablet_tool_proximity_notify; - wl_signal_add(&device->tablet_tool->events.proximity, &tstate->proximity); + wl_signal_add(&device->tablet->events.proximity, &tstate->proximity); tstate->button.notify = tablet_tool_button_notify; - wl_signal_add(&device->tablet_tool->events.button, &tstate->button); + wl_signal_add(&device->tablet->events.button, &tstate->button); wl_list_insert(&sample->tablet_tools, &tstate->link); break; default: diff --git a/include/backend/libinput.h b/include/backend/libinput.h index f0928133..d1fb3a44 100644 --- a/include/backend/libinput.h +++ b/include/backend/libinput.h @@ -65,7 +65,7 @@ void handle_touch_motion(struct libinput_event *event, void handle_touch_cancel(struct libinput_event *event, struct libinput_device *device); -struct wlr_tablet_tool *create_libinput_tablet_tool( +struct wlr_tablet *create_libinput_tablet( struct libinput_device *device); void handle_tablet_tool_axis(struct libinput_event *event, struct libinput_device *device); diff --git a/include/rootston/cursor.h b/include/rootston/cursor.h index a1a466c2..f7410dec 100644 --- a/include/rootston/cursor.h +++ b/include/rootston/cursor.h @@ -40,6 +40,8 @@ struct roots_cursor { struct wl_listener tool_axis; struct wl_listener tool_tip; + struct wl_listener tool_proximity; + struct wl_listener tool_button; struct wl_listener request_set_cursor; }; diff --git a/include/rootston/desktop.h b/include/rootston/desktop.h index 88c5ca90..2d28fa10 100644 --- a/include/rootston/desktop.h +++ b/include/rootston/desktop.h @@ -8,7 +8,7 @@ #include <wlr/types/wlr_idle.h> #include <wlr/types/wlr_input_inhibitor.h> #include <wlr/types/wlr_layer_shell.h> -#include <wlr/types/wlr_linux_dmabuf.h> +#include <wlr/types/wlr_linux_dmabuf_v1.h> #include <wlr/types/wlr_list.h> #include <wlr/types/wlr_output_layout.h> #include <wlr/types/wlr_output.h> @@ -52,10 +52,11 @@ struct roots_desktop { struct wlr_idle *idle; struct wlr_idle_inhibit_manager_v1 *idle_inhibit; struct wlr_input_inhibit_manager *input_inhibit; - struct wlr_linux_dmabuf *linux_dmabuf; + struct wlr_linux_dmabuf_v1 *linux_dmabuf; struct wlr_layer_shell *layer_shell; struct wlr_virtual_keyboard_manager_v1 *virtual_keyboard; struct wlr_screencopy_manager_v1 *screencopy; + struct wlr_tablet_manager_v2 *tablet_v2; struct wl_listener new_output; struct wl_listener layout_change; diff --git a/include/rootston/seat.h b/include/rootston/seat.h index 0e3043dd..3ddb97c5 100644 --- a/include/rootston/seat.h +++ b/include/rootston/seat.h @@ -30,7 +30,8 @@ struct roots_seat { struct wl_list keyboards; struct wl_list pointers; struct wl_list touch; - struct wl_list tablet_tools; + struct wl_list tablets; + struct wl_list tablet_pads; struct wl_listener new_drag_icon; struct wl_listener destroy; @@ -77,9 +78,11 @@ struct roots_touch { struct wl_list link; }; -struct roots_tablet_tool { +struct roots_tablet { struct roots_seat *seat; struct wlr_input_device *device; + struct wlr_tablet_v2_tablet *tablet_v2; + struct wl_listener device_destroy; struct wl_listener axis; struct wl_listener proximity; @@ -88,6 +91,37 @@ struct roots_tablet_tool { struct wl_list link; }; +struct roots_tablet_pad { + struct wl_list link; + struct wlr_tablet_v2_tablet_pad *tablet_v2_pad; + + struct roots_seat *seat; + struct wlr_input_device *device; + + struct wl_listener device_destroy; + struct wl_listener attach; + struct wl_listener button; + struct wl_listener ring; + struct wl_listener strip; + + struct roots_tablet *tablet; + struct wl_listener tablet_destroy; +}; + +struct roots_tablet_tool { + struct wl_list link; + struct wl_list tool_link; + struct wlr_tablet_v2_tablet_tool *tablet_v2_tool; + + struct roots_seat *seat; + + struct wl_listener set_cursor; + struct wl_listener tool_destroy; + + struct roots_tablet *current_tablet; + struct wl_listener tablet_destroy; +}; + struct roots_seat *roots_seat_create(struct roots_input *input, char *name); void roots_seat_destroy(struct roots_seat *seat); diff --git a/include/types/wlr_tablet_v2.h b/include/types/wlr_tablet_v2.h new file mode 100644 index 00000000..4b9e727d --- /dev/null +++ b/include/types/wlr_tablet_v2.h @@ -0,0 +1,93 @@ +#ifndef TYPES_WLR_TABLET_V2_H +#define TYPES_WLR_TABLET_V2_H + +#include "tablet-unstable-v2-protocol.h" +#include <wayland-server.h> +#include <wlr/types/wlr_tablet_v2.h> + +struct wlr_tablet_seat_v2 { + struct wl_list link; + struct wlr_seat *wlr_seat; + struct wlr_tablet_manager_v2 *manager; + + struct wl_list tablets; // wlr_tablet_v2_tablet::link + struct wl_list tools; + struct wl_list pads; + + struct wl_list clients; //wlr_tablet_seat_v2_client::link; + + struct wl_listener seat_destroy; +}; + +struct wlr_tablet_seat_client_v2 { + struct wl_list seat_link; + struct wl_list client_link; + struct wl_client *wl_client; + struct wl_resource *resource; + + struct wlr_tablet_manager_client_v2 *client; + struct wlr_seat_client *seat_client; + + struct wl_listener seat_client_destroy; + + struct wl_list tools; //wlr_tablet_tool_client_v2::link + struct wl_list tablets; //wlr_tablet_client_v2::link + struct wl_list pads; //wlr_tablet_pad_client_v2::link +}; + +struct wlr_tablet_client_v2 { + struct wl_list seat_link; // wlr_tablet_seat_client_v2::tablet + struct wl_list tablet_link; // wlr_tablet_v2_tablet::clients + struct wl_client *client; + struct wl_resource *resource; +}; + +struct wlr_tablet_pad_client_v2 { + struct wl_list seat_link; + struct wl_list pad_link; + struct wl_client *client; + struct wl_resource *resource; + struct wlr_tablet_v2_tablet_pad *pad; + + size_t button_count; + + size_t group_count; + struct wl_resource **groups; + + size_t ring_count; + struct wl_resource **rings; + + size_t strip_count; + struct wl_resource **strips; +}; + +struct wlr_tablet_tool_client_v2 { + struct wl_list seat_link; + struct wl_list tool_link; + struct wl_client *client; + struct wl_resource *resource; + struct wlr_tablet_v2_tablet_tool *tool; + struct wlr_tablet_seat_client_v2 *seat; + + struct wl_event_source *frame_source; +}; + +struct wlr_tablet_client_v2 *tablet_client_from_resource(struct wl_resource *resource); +void destroy_tablet_v2(struct wl_resource *resource); +void add_tablet_client(struct wlr_tablet_seat_client_v2 *seat, struct wlr_tablet_v2_tablet *tablet); + +void destroy_tablet_pad_v2(struct wl_resource *resource); +struct wlr_tablet_pad_client_v2 *tablet_pad_client_from_resource(struct wl_resource *resource); +void add_tablet_pad_client(struct wlr_tablet_seat_client_v2 *seat, struct wlr_tablet_v2_tablet_pad *pad); + +void destroy_tablet_tool_v2(struct wl_resource *resource); +struct wlr_tablet_tool_client_v2 *tablet_tool_client_from_resource(struct wl_resource *resource); +void add_tablet_tool_client(struct wlr_tablet_seat_client_v2 *seat, struct wlr_tablet_v2_tablet_tool *tool); + +struct wlr_tablet_seat_client_v2 *tablet_seat_client_from_resource(struct wl_resource *resource); +void tablet_seat_client_v2_destroy(struct wl_resource *resource); +struct wlr_tablet_seat_v2 *get_or_create_tablet_seat( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat); + +#endif /* TYPES_WLR_TABLET_V2_H */ diff --git a/include/util/array.h b/include/util/array.h new file mode 100644 index 00000000..1c046e1d --- /dev/null +++ b/include/util/array.h @@ -0,0 +1,9 @@ +#ifndef UTIL_ARRAY_H +#define UTIL_ARRAY_H + +#include <stdint.h> +#include <stdlib.h> + +size_t push_zeroes_to_end(uint32_t arr[], size_t n); + +#endif diff --git a/include/wlr/interfaces/wlr_tablet_tool.h b/include/wlr/interfaces/wlr_tablet_tool.h index 347a0003..12b2e32e 100644 --- a/include/wlr/interfaces/wlr_tablet_tool.h +++ b/include/wlr/interfaces/wlr_tablet_tool.h @@ -3,12 +3,12 @@ #include <wlr/types/wlr_tablet_tool.h> -struct wlr_tablet_tool_impl { - void (*destroy)(struct wlr_tablet_tool *tool); +struct wlr_tablet_impl { + void (*destroy)(struct wlr_tablet *tablet); }; -void wlr_tablet_tool_init(struct wlr_tablet_tool *tool, - struct wlr_tablet_tool_impl *impl); -void wlr_tablet_tool_destroy(struct wlr_tablet_tool *tool); +void wlr_tablet_init(struct wlr_tablet *tablet, + struct wlr_tablet_impl *impl); +void wlr_tablet_destroy(struct wlr_tablet *tablet); #endif diff --git a/include/wlr/types/wlr_input_device.h b/include/wlr/types/wlr_input_device.h index 5cf26b65..cce15d90 100644 --- a/include/wlr/types/wlr_input_device.h +++ b/include/wlr/types/wlr_input_device.h @@ -39,7 +39,7 @@ struct wlr_input_device { struct wlr_keyboard *keyboard; struct wlr_pointer *pointer; struct wlr_touch *touch; - struct wlr_tablet_tool *tablet_tool; + struct wlr_tablet *tablet; struct wlr_tablet_pad *tablet_pad; }; diff --git a/include/wlr/types/wlr_linux_dmabuf.h b/include/wlr/types/wlr_linux_dmabuf_v1.h index 4a03170c..43bc8385 100644 --- a/include/wlr/types/wlr_linux_dmabuf.h +++ b/include/wlr/types/wlr_linux_dmabuf_v1.h @@ -5,7 +5,7 @@ #include <wayland-server-protocol.h> #include <wlr/render/dmabuf.h> -struct wlr_dmabuf_buffer { +struct wlr_dmabuf_v1_buffer { struct wlr_renderer *renderer; struct wl_resource *buffer_resource; struct wl_resource *params_resource; @@ -17,24 +17,24 @@ struct wlr_dmabuf_buffer { * Returns true if the given resource was created via the linux-dmabuf * buffer protocol, false otherwise */ -bool wlr_dmabuf_resource_is_buffer(struct wl_resource *buffer_resource); +bool wlr_dmabuf_v1_resource_is_buffer(struct wl_resource *buffer_resource); /** * Returns the wlr_dmabuf_buffer if the given resource was created * via the linux-dmabuf buffer protocol */ -struct wlr_dmabuf_buffer *wlr_dmabuf_buffer_from_buffer_resource( +struct wlr_dmabuf_v1_buffer *wlr_dmabuf_v1_buffer_from_buffer_resource( struct wl_resource *buffer_resource); /** * Returns the wlr_dmabuf_buffer if the given resource was created * via the linux-dmabuf params protocol */ -struct wlr_dmabuf_buffer *wlr_dmabuf_buffer_from_params_resource( +struct wlr_dmabuf_v1_buffer *wlr_dmabuf_v1_buffer_from_params_resource( struct wl_resource *params_resource); /* the protocol interface */ -struct wlr_linux_dmabuf { +struct wlr_linux_dmabuf_v1 { struct wl_global *global; struct wlr_renderer *renderer; struct wl_list resources; @@ -50,18 +50,18 @@ struct wlr_linux_dmabuf { /** * Create linux-dmabuf interface */ -struct wlr_linux_dmabuf *wlr_linux_dmabuf_create(struct wl_display *display, +struct wlr_linux_dmabuf_v1 *wlr_linux_dmabuf_v1_create(struct wl_display *display, struct wlr_renderer *renderer); /** * Destroy the linux-dmabuf interface */ -void wlr_linux_dmabuf_destroy(struct wlr_linux_dmabuf *linux_dmabuf); +void wlr_linux_dmabuf_v1_destroy(struct wlr_linux_dmabuf_v1 *linux_dmabuf); /** * Returns the wlr_linux_dmabuf if the given resource was created * via the linux_dmabuf protocol */ -struct wlr_linux_dmabuf *wlr_linux_dmabuf_from_resource( +struct wlr_linux_dmabuf_v1 *wlr_linux_dmabuf_v1_from_resource( struct wl_resource *resource); #endif diff --git a/include/wlr/types/wlr_output.h b/include/wlr/types/wlr_output.h index 5084eb5a..c93ed2eb 100644 --- a/include/wlr/types/wlr_output.h +++ b/include/wlr/types/wlr_output.h @@ -6,7 +6,7 @@ #include <time.h> #include <wayland-server.h> #include <wayland-util.h> -#include <wlr/types/wlr_linux_dmabuf.h> +#include <wlr/render/dmabuf.h> struct wlr_output_mode { uint32_t flags; // enum wl_output_mode diff --git a/include/wlr/types/wlr_seat.h b/include/wlr/types/wlr_seat.h index 1c7a1472..92d0a233 100644 --- a/include/wlr/types/wlr_seat.h +++ b/include/wlr/types/wlr_seat.h @@ -540,6 +540,4 @@ bool wlr_seat_validate_grab_serial(struct wlr_seat *seat, uint32_t serial); struct wlr_seat_client *wlr_seat_client_from_resource( struct wl_resource *resource); -bool wlr_surface_is_pointer_cursor(struct wlr_surface *surface); - #endif diff --git a/include/wlr/types/wlr_tablet_pad.h b/include/wlr/types/wlr_tablet_pad.h index 73082c56..23ac464d 100644 --- a/include/wlr/types/wlr_tablet_pad.h +++ b/include/wlr/types/wlr_tablet_pad.h @@ -4,6 +4,7 @@ #include <stdint.h> #include <wayland-server.h> #include <wlr/types/wlr_input_device.h> +#include <wlr/types/wlr_list.h> /* * NOTE: the wlr tablet pad implementation does not currently support tablets @@ -20,16 +21,40 @@ struct wlr_tablet_pad { struct wl_signal button; struct wl_signal ring; struct wl_signal strip; + struct wl_signal attach_tablet; //struct wlr_tablet_tool } events; + size_t button_count; + size_t ring_count; + size_t strip_count; + + struct wl_list groups; // wlr_tablet_pad_group::link + struct wlr_list paths; // char * + void *data; }; +struct wlr_tablet_pad_group { + struct wl_list link; + + size_t button_count; + unsigned int *buttons; + + size_t strip_count; + unsigned int *strips; + + size_t ring_count; + unsigned int *rings; + + unsigned int mode_count; +}; + struct wlr_event_tablet_pad_button { uint32_t time_msec; uint32_t button; enum wlr_button_state state; unsigned int mode; + unsigned int group; }; enum wlr_tablet_pad_ring_source { diff --git a/include/wlr/types/wlr_tablet_tool.h b/include/wlr/types/wlr_tablet_tool.h index 22bf2649..bfa2e1f7 100644 --- a/include/wlr/types/wlr_tablet_tool.h +++ b/include/wlr/types/wlr_tablet_tool.h @@ -4,11 +4,47 @@ #include <stdint.h> #include <wayland-server.h> #include <wlr/types/wlr_input_device.h> +#include <wlr/types/wlr_list.h> -struct wlr_tablet_tool_impl; +/* + * Copy+Paste from libinput, but this should neither use libinput, nor + * tablet-unstable-v2 headers, so we can't include them + */ +enum wlr_tablet_tool_type { + WLR_TABLET_TOOL_TYPE_PEN = 1, /**< A generic pen */ + WLR_TABLET_TOOL_TYPE_ERASER, /**< Eraser */ + WLR_TABLET_TOOL_TYPE_BRUSH, /**< A paintbrush-like tool */ + WLR_TABLET_TOOL_TYPE_PENCIL, /**< Physical drawing tool, e.g. + Wacom Inking Pen */ + WLR_TABLET_TOOL_TYPE_AIRBRUSH, /**< An airbrush-like tool */ + WLR_TABLET_TOOL_TYPE_MOUSE, /**< A mouse bound to the tablet */ + WLR_TABLET_TOOL_TYPE_LENS, /**< A mouse tool with a lens */ +}; struct wlr_tablet_tool { - struct wlr_tablet_tool_impl *impl; + enum wlr_tablet_tool_type type; + uint64_t hardware_serial; + uint64_t hardware_wacom; + + // Capabilities + bool tilt; + bool pressure; + bool distance; + bool rotation; + bool slider; + bool wheel; + + struct { + struct wl_signal destroy; + } events; + + void *data; +}; + +struct wlr_tablet_impl; + +struct wlr_tablet { + struct wlr_tablet_impl *impl; struct { struct wl_signal axis; @@ -17,6 +53,9 @@ struct wlr_tablet_tool { struct wl_signal button; } events; + const char *name; + struct wlr_list paths; // char * + void *data; }; @@ -34,10 +73,14 @@ enum wlr_tablet_tool_axes { struct wlr_event_tablet_tool_axis { struct wlr_input_device *device; + struct wlr_tablet_tool *tool; + uint32_t time_msec; uint32_t updated_axes; // From 0..1 double x, y; + // Relative to last event + double dx, dy; double pressure; double distance; double tilt_x, tilt_y; @@ -53,6 +96,7 @@ enum wlr_tablet_tool_proximity_state { struct wlr_event_tablet_tool_proximity { struct wlr_input_device *device; + struct wlr_tablet_tool *tool; uint32_t time_msec; // From 0..1 double x, y; @@ -66,6 +110,7 @@ enum wlr_tablet_tool_tip_state { struct wlr_event_tablet_tool_tip { struct wlr_input_device *device; + struct wlr_tablet_tool *tool; uint32_t time_msec; // From 0..1 double x, y; @@ -74,6 +119,7 @@ struct wlr_event_tablet_tool_tip { struct wlr_event_tablet_tool_button { struct wlr_input_device *device; + struct wlr_tablet_tool *tool; uint32_t time_msec; uint32_t button; enum wlr_button_state state; diff --git a/include/wlr/types/wlr_tablet_v2.h b/include/wlr/types/wlr_tablet_v2.h new file mode 100644 index 00000000..afa74d05 --- /dev/null +++ b/include/wlr/types/wlr_tablet_v2.h @@ -0,0 +1,171 @@ +#ifndef WLR_TYPES_WLR_TABLET_V2_H +#define WLR_TYPES_WLR_TABLET_V2_H + +#include <wayland-server.h> +#include <wlr/types/wlr_seat.h> +#include <wlr/types/wlr_input_device.h> + +#include "tablet-unstable-v2-protocol.h" + +/* This can probably be even lower,the tools don't have a lot of buttons */ +#define WLR_TABLET_V2_TOOL_BUTTONS_CAP 16 + +struct wlr_tablet_client_v2; +struct wlr_tablet_tool_client_v2; +struct wlr_tablet_pad_client_v2; + +struct wlr_tablet_manager_v2 { + struct wl_global *wl_global; + struct wl_list clients; // wlr_tablet_manager_client_v2::link + struct wl_list seats; // wlr_tablet_seat_v2::link + + struct wl_listener display_destroy; + + void *data; +}; + +struct wlr_tablet_v2_tablet { + struct wl_list link; // wlr_tablet_seat_v2::tablets + struct wlr_tablet *wlr_tablet; + struct wlr_input_device *wlr_device; + struct wl_list clients; // wlr_tablet_client_v2::tablet_link + + struct wl_listener tool_destroy; + + struct wlr_tablet_client_v2 *current_client; +}; + +struct wlr_tablet_v2_tablet_tool { + struct wl_list link; // wlr_tablet_seat_v2::tablets + struct wlr_tablet_tool *wlr_tool; + struct wl_list clients; // wlr_tablet_tool_client_v2::tool_link + + struct wl_listener tool_destroy; + + struct wlr_tablet_tool_client_v2 *current_client; + struct wlr_surface *focused_surface; + struct wl_listener surface_destroy; + + uint32_t proximity_serial; + bool is_down; + uint32_t down_serial; + size_t num_buttons; + uint32_t pressed_buttons[WLR_TABLET_V2_TOOL_BUTTONS_CAP]; + uint32_t pressed_serials[WLR_TABLET_V2_TOOL_BUTTONS_CAP]; + + struct { + struct wl_signal set_cursor; // struct wlr_tablet_v2_event_cursor + } events; +}; + +struct wlr_tablet_v2_tablet_pad { + struct wl_list link; // wlr_tablet_seat_v2::pads + struct wlr_tablet_pad *wlr_pad; + struct wlr_input_device *wlr_device; + struct wl_list clients; // wlr_tablet_pad_client_v2::pad_link + + size_t group_count; + uint32_t *groups; + + struct wl_listener pad_destroy; + + struct wlr_tablet_pad_client_v2 *current_client; + + struct { + struct wl_signal button_feedback; // struct wlr_tablet_v2_event_feedback + struct wl_signal strip_feedback; // struct wlr_tablet_v2_event_feedback + struct wl_signal ring_feedback; // struct wlr_tablet_v2_event_feedback + } events; +}; + +struct wlr_tablet_v2_event_cursor { + struct wlr_surface *surface; + uint32_t serial; + int32_t hotspot_x; + int32_t hotspot_y; + struct wlr_seat_client *seat_client; +}; + +struct wlr_tablet_v2_event_feedback { + const char *description; + size_t index; + uint32_t serial; +}; + +struct wlr_tablet_v2_tablet *wlr_tablet_create( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat, + struct wlr_input_device *wlr_device); + +struct wlr_tablet_v2_tablet_pad *wlr_tablet_pad_create( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat, + struct wlr_input_device *wlr_device); + +struct wlr_tablet_v2_tablet_tool *wlr_tablet_tool_create( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat, + struct wlr_tablet_tool *wlr_tool); + +struct wlr_tablet_manager_v2 *wlr_tablet_v2_create(struct wl_display *display); +void wlr_tablet_v2_destroy(struct wlr_tablet_manager_v2 *manager); + +void wlr_send_tablet_v2_tablet_tool_proximity_in( + struct wlr_tablet_v2_tablet_tool *tool, + struct wlr_tablet_v2_tablet *tablet, + struct wlr_surface *surface); + +void wlr_send_tablet_v2_tablet_tool_down(struct wlr_tablet_v2_tablet_tool *tool); +void wlr_send_tablet_v2_tablet_tool_up(struct wlr_tablet_v2_tablet_tool *tool); + +void wlr_send_tablet_v2_tablet_tool_motion( + struct wlr_tablet_v2_tablet_tool *tool, double x, double y); + +void wlr_send_tablet_v2_tablet_tool_pressure( + struct wlr_tablet_v2_tablet_tool *tool, double pressure); + +void wlr_send_tablet_v2_tablet_tool_distance( + struct wlr_tablet_v2_tablet_tool *tool, double distance); + +void wlr_send_tablet_v2_tablet_tool_tilt( + struct wlr_tablet_v2_tablet_tool *tool, double x, double y); + +void wlr_send_tablet_v2_tablet_tool_rotation( + struct wlr_tablet_v2_tablet_tool *tool, double degrees); + +void wlr_send_tablet_v2_tablet_tool_slider( + struct wlr_tablet_v2_tablet_tool *tool, double position); + +void wlr_send_tablet_v2_tablet_tool_wheel( + struct wlr_tablet_v2_tablet_tool *tool, double degrees, int32_t clicks); + +void wlr_send_tablet_v2_tablet_tool_proximity_out( + struct wlr_tablet_v2_tablet_tool *tool); + +void wlr_send_tablet_v2_tablet_tool_button( + struct wlr_tablet_v2_tablet_tool *tool, uint32_t button, + enum zwp_tablet_pad_v2_button_state state); + +uint32_t wlr_send_tablet_v2_tablet_pad_enter( + struct wlr_tablet_v2_tablet_pad *pad, + struct wlr_tablet_v2_tablet *tablet, + struct wlr_surface *surface); + +void wlr_send_tablet_v2_tablet_pad_button( + struct wlr_tablet_v2_tablet_pad *pad, size_t button, + uint32_t time, enum zwp_tablet_pad_v2_button_state state); + +void wlr_send_tablet_v2_tablet_pad_strip( struct wlr_tablet_v2_tablet_pad *pad, + uint32_t strip, double position, bool finger, uint32_t time); +void wlr_send_tablet_v2_tablet_pad_ring(struct wlr_tablet_v2_tablet_pad *pad, + uint32_t ring, double position, bool finger, uint32_t time); + +uint32_t wlr_send_tablet_v2_tablet_pad_leave(struct wlr_tablet_v2_tablet_pad *pad, + struct wlr_surface *surface); + +uint32_t wlr_send_tablet_v2_tablet_pad_mode(struct wlr_tablet_v2_tablet_pad *pad, + size_t group, uint32_t mode, uint32_t time); + +bool wlr_surface_accepts_tablet_v2(struct wlr_tablet_v2_tablet *tablet, + struct wlr_surface *surface); +#endif /* WLR_TYPES_WLR_TABLET_V2_H */ diff --git a/include/wlr/types/wlr_xdg_shell.h b/include/wlr/types/wlr_xdg_shell.h index 9c0e6adc..5aa6b374 100644 --- a/include/wlr/types/wlr_xdg_shell.h +++ b/include/wlr/types/wlr_xdg_shell.h @@ -119,6 +119,8 @@ struct wlr_xdg_toplevel { struct wl_signal request_resize; struct wl_signal request_show_window_menu; struct wl_signal set_parent; + struct wl_signal set_title; + struct wl_signal set_app_id; } events; }; diff --git a/include/wlr/types/wlr_xdg_shell_v6.h b/include/wlr/types/wlr_xdg_shell_v6.h index 2e1b6f11..2357d945 100644 --- a/include/wlr/types/wlr_xdg_shell_v6.h +++ b/include/wlr/types/wlr_xdg_shell_v6.h @@ -127,6 +127,8 @@ struct wlr_xdg_toplevel_v6 { struct wl_signal request_resize; struct wl_signal request_show_window_menu; struct wl_signal set_parent; + struct wl_signal set_title; + struct wl_signal set_app_id; } events; }; diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h index 7471bbc6..2b643ec9 100644 --- a/include/wlr/xwayland.h +++ b/include/wlr/xwayland.h @@ -150,6 +150,8 @@ struct wlr_xwayland_surface { struct wl_signal set_parent; struct wl_signal set_pid; struct wl_signal set_window_type; + struct wl_signal set_hints; + struct wl_signal set_override_redirect; struct wl_signal ping_timeout; } events; @@ -200,9 +202,6 @@ void wlr_xwayland_surface_set_fullscreen(struct wlr_xwayland_surface *surface, void wlr_xwayland_set_seat(struct wlr_xwayland *xwayland, struct wlr_seat *seat); -bool wlr_xwayland_surface_is_unmanaged( - const struct wlr_xwayland_surface *surface); - bool wlr_surface_is_xwayland_surface(struct wlr_surface *surface); struct wlr_xwayland_surface *wlr_xwayland_surface_from_wlr_surface( diff --git a/meson.build b/meson.build index b65cd51a..5fd89832 100644 --- a/meson.build +++ b/meson.build @@ -126,6 +126,10 @@ else exclude_headers += 'xwayland.h' endif +if cc.has_header_symbol('fcntl.h', 'posix_fallocate', prefix: '#define _POSIX_C_SOURCE 200112L') + conf_data.set('WLR_HAS_POSIX_FALLOCATE', true) +endif + includedir = get_option('includedir') exclude_headers += 'meson.build' install_subdir('include/wlr', install_dir: includedir, exclude_files: exclude_headers) diff --git a/protocol/meson.build b/protocol/meson.build index 5ab82d84..b7a6e80a 100644 --- a/protocol/meson.build +++ b/protocol/meson.build @@ -33,6 +33,7 @@ protocols = [ [wl_protocol_dir, 'unstable/linux-dmabuf/linux-dmabuf-unstable-v1.xml'], [wl_protocol_dir, 'unstable/xdg-shell/xdg-shell-unstable-v6.xml'], [wl_protocol_dir, 'unstable/xdg-output/xdg-output-unstable-v1.xml'], + [wl_protocol_dir, 'unstable/tablet/tablet-unstable-v2.xml'], 'gamma-control.xml', 'gtk-primary-selection.xml', 'idle.xml', diff --git a/rootston/desktop.c b/rootston/desktop.c index 563c5938..5277dcc7 100644 --- a/rootston/desktop.c +++ b/rootston/desktop.c @@ -13,7 +13,7 @@ #include <wlr/types/wlr_idle.h> #include <wlr/types/wlr_input_inhibitor.h> #include <wlr/types/wlr_layer_shell.h> -#include <wlr/types/wlr_linux_dmabuf.h> +#include <wlr/types/wlr_linux_dmabuf_v1.h> #include <wlr/types/wlr_output_layout.h> #include <wlr/types/wlr_primary_selection.h> #include <wlr/types/wlr_server_decoration.h> @@ -22,6 +22,8 @@ #include <wlr/types/wlr_xdg_output.h> #include <wlr/types/wlr_xdg_shell_v6.h> #include <wlr/types/wlr_xdg_shell.h> +#include <wlr/types/wlr_xdg_output.h> +#include <wlr/types/wlr_tablet_v2.h> #include <wlr/util/log.h> #include "rootston/layers.h" #include "rootston/seat.h" @@ -801,6 +803,8 @@ struct roots_desktop *desktop_create(struct roots_server *server, &desktop->layer_shell_surface); desktop->layer_shell_surface.notify = handle_layer_shell_surface; + desktop->tablet_v2 = wlr_tablet_v2_create(server->wl_display); + #ifdef WLR_HAS_XWAYLAND const char *cursor_theme = NULL; const char *cursor_default = ROOTS_XCURSOR_DEFAULT; @@ -867,7 +871,7 @@ struct roots_desktop *desktop_create(struct roots_server *server, wl_signal_add(&desktop->input_inhibit->events.deactivate, &desktop->input_inhibit_deactivate); - desktop->linux_dmabuf = wlr_linux_dmabuf_create(server->wl_display, + desktop->linux_dmabuf = wlr_linux_dmabuf_v1_create(server->wl_display, server->renderer); desktop->virtual_keyboard = wlr_virtual_keyboard_manager_v1_create( diff --git a/rootston/main.c b/rootston/main.c index cc3ffd3e..6f4e2612 100644 --- a/rootston/main.c +++ b/rootston/main.c @@ -1,5 +1,6 @@ #define _POSIX_C_SOURCE 200112L #include <assert.h> +#include <signal.h> #include <stdlib.h> #include <unistd.h> #include <wayland-server.h> @@ -15,6 +16,11 @@ struct roots_server server = { 0 }; int main(int argc, char **argv) { + if (signal(SIGCHLD, SIG_IGN) == SIG_ERR) { + wlr_log_errno(WLR_ERROR, "Unable to install SIGCHLD handler"); + return 1; + } + wlr_log_init(WLR_DEBUG, NULL); server.config = roots_config_create_from_args(argc, argv); server.wl_display = wl_display_create(); diff --git a/rootston/seat.c b/rootston/seat.c index 544cfb90..cae548d3 100644 --- a/rootston/seat.c +++ b/rootston/seat.c @@ -1,12 +1,15 @@ #define _POSIX_C_SOURCE 199309L #include <assert.h> +#include <libinput.h> #include <stdlib.h> #include <string.h> #include <time.h> #include <wayland-server.h> +#include <wlr/backend/libinput.h> #include <wlr/config.h> #include <wlr/types/wlr_idle.h> #include <wlr/types/wlr_layer_shell.h> +#include <wlr/types/wlr_tablet_v2.h> #include <wlr/types/wlr_xcursor_manager.h> #include <wlr/util/log.h> #include "rootston/cursor.h" @@ -15,6 +18,7 @@ #include "rootston/seat.h" #include "rootston/xcursor.h" + static void handle_keyboard_key(struct wl_listener *listener, void *data) { struct roots_keyboard *keyboard = wl_container_of(listener, keyboard, keyboard_key); @@ -97,13 +101,102 @@ static void handle_touch_motion(struct wl_listener *listener, void *data) { roots_cursor_handle_touch_motion(cursor, event); } +static void handle_tablet_tool_position(struct roots_cursor *cursor, + struct roots_tablet *tablet, + struct wlr_tablet_tool *tool, + bool change_x, bool change_y, + double x, double y, double dx, double dy) { + if (!change_x && !change_y) { + return; + } + + switch (tool->type) { + case WLR_TABLET_TOOL_TYPE_MOUSE: + // They are 0 either way when they weren't modified + wlr_cursor_move(cursor->cursor, tablet->device, dx, dy); + break; + default: + wlr_cursor_warp_absolute(cursor->cursor, tablet->device, + change_x ? x : NAN, change_y ? y : NAN); + } + + double sx, sy; + struct roots_view *view = NULL; + struct roots_seat *seat = cursor->seat; + struct roots_desktop *desktop = seat->input->server->desktop; + struct wlr_surface *surface = desktop_surface_at(desktop, + cursor->cursor->x, cursor->cursor->y, &sx, &sy, &view); + struct roots_tablet_tool *roots_tool = tool->data; + + if (!surface) { + wlr_send_tablet_v2_tablet_tool_proximity_out(roots_tool->tablet_v2_tool); + /* XXX: TODO: Fallback pointer semantics */ + return; + } + + if (!wlr_surface_accepts_tablet_v2(tablet->tablet_v2, surface)) { + wlr_send_tablet_v2_tablet_tool_proximity_out(roots_tool->tablet_v2_tool); + /* XXX: TODO: Fallback pointer semantics */ + return; + } + + wlr_send_tablet_v2_tablet_tool_proximity_in(roots_tool->tablet_v2_tool, + tablet->tablet_v2, surface); + + wlr_send_tablet_v2_tablet_tool_motion(roots_tool->tablet_v2_tool, sx, sy); +} + static void handle_tool_axis(struct wl_listener *listener, void *data) { struct roots_cursor *cursor = wl_container_of(listener, cursor, tool_axis); struct roots_desktop *desktop = cursor->seat->input->server->desktop; wlr_idle_notify_activity(desktop->idle, cursor->seat->seat); struct wlr_event_tablet_tool_axis *event = data; - roots_cursor_handle_tool_axis(cursor, event); + struct roots_tablet_tool *roots_tool = event->tool->data; + + if (!roots_tool) { // Should this be an assert? + wlr_log(WLR_DEBUG, "Tool Axis, before proximity"); + return; + } + + /** + * We need to handle them ourselves, not pass it into the cursor + * without any consideration + */ + handle_tablet_tool_position(cursor, event->device->data, event->tool, + event->updated_axes & WLR_TABLET_TOOL_AXIS_X, + event->updated_axes & WLR_TABLET_TOOL_AXIS_Y, + event->x, event->y, event->dx, event->dy); + + if (event->updated_axes & WLR_TABLET_TOOL_AXIS_PRESSURE) { + wlr_send_tablet_v2_tablet_tool_pressure( + roots_tool->tablet_v2_tool, event->pressure); + } + + if (event->updated_axes & WLR_TABLET_TOOL_AXIS_DISTANCE) { + wlr_send_tablet_v2_tablet_tool_distance( + roots_tool->tablet_v2_tool, event->distance); + } + + if (event->updated_axes & (WLR_TABLET_TOOL_AXIS_TILT_X | WLR_TABLET_TOOL_AXIS_TILT_Y)) { + wlr_send_tablet_v2_tablet_tool_tilt( + roots_tool->tablet_v2_tool, event->tilt_x, event->tilt_y); + } + + if (event->updated_axes & WLR_TABLET_TOOL_AXIS_ROTATION) { + wlr_send_tablet_v2_tablet_tool_rotation( + roots_tool->tablet_v2_tool, event->rotation); + } + + if (event->updated_axes & WLR_TABLET_TOOL_AXIS_SLIDER) { + wlr_send_tablet_v2_tablet_tool_slider( + roots_tool->tablet_v2_tool, event->slider); + } + + if (event->updated_axes & WLR_TABLET_TOOL_AXIS_WHEEL) { + wlr_send_tablet_v2_tablet_tool_wheel( + roots_tool->tablet_v2_tool, event->wheel_delta, 0); + } } static void handle_tool_tip(struct wl_listener *listener, void *data) { @@ -112,7 +205,87 @@ static void handle_tool_tip(struct wl_listener *listener, void *data) { struct roots_desktop *desktop = cursor->seat->input->server->desktop; wlr_idle_notify_activity(desktop->idle, cursor->seat->seat); struct wlr_event_tablet_tool_tip *event = data; - roots_cursor_handle_tool_tip(cursor, event); + struct roots_tablet_tool *roots_tool = event->tool->data; + + if (event->state == WLR_TABLET_TOOL_TIP_DOWN) { + wlr_send_tablet_v2_tablet_tool_down(roots_tool->tablet_v2_tool); + } else { + wlr_send_tablet_v2_tablet_tool_up(roots_tool->tablet_v2_tool); + } +} + +static void handle_tablet_tool_destroy(struct wl_listener *listener, void *data) { + struct roots_tablet_tool *tool = + wl_container_of(listener, tool, tool_destroy); + + wl_list_remove(&tool->link); + wl_list_remove(&tool->tool_link); + + wl_list_remove(&tool->tool_destroy.link); + wl_list_remove(&tool->set_cursor.link); + + free(tool); +} + +static void handle_tool_button(struct wl_listener *listener, void *data) { + struct roots_cursor *cursor = + wl_container_of(listener, cursor, tool_button); + struct roots_desktop *desktop = cursor->seat->input->server->desktop; + wlr_idle_notify_activity(desktop->idle, cursor->seat->seat); + struct wlr_event_tablet_tool_button *event = data; + struct roots_tablet_tool *roots_tool = event->tool->data; + + wlr_send_tablet_v2_tablet_tool_button(roots_tool->tablet_v2_tool, + (enum zwp_tablet_pad_v2_button_state)event->button, + (enum zwp_tablet_pad_v2_button_state)event->state); +} + +static void handle_tablet_tool_set_cursor(struct wl_listener *listener, void *data) { + struct roots_tablet_tool *tool = + wl_container_of(listener, tool, set_cursor); + struct wlr_tablet_v2_event_cursor *evt = data; + + + struct wlr_seat_pointer_request_set_cursor_event event = { + .surface = evt->surface, + .hotspot_x = evt->hotspot_x, + .hotspot_y = evt->hotspot_y, + .serial = evt->serial, + .seat_client = evt->seat_client, + }; + + roots_cursor_handle_request_set_cursor(tool->seat->cursor, &event); +} + +static void handle_tool_proximity(struct wl_listener *listener, void *data) { + struct roots_cursor *cursor = + wl_container_of(listener, cursor, tool_proximity); + struct roots_desktop *desktop = cursor->seat->input->server->desktop; + wlr_idle_notify_activity(desktop->idle, cursor->seat->seat); + struct wlr_event_tablet_tool_proximity *event = data; + + struct wlr_tablet_tool *tool = event->tool; + if (!tool->data) { + struct roots_tablet_tool *roots_tool = + calloc(1, sizeof(struct roots_tablet_tool)); + roots_tool->seat = cursor->seat; + tool->data = roots_tool; + roots_tool->tablet_v2_tool = + wlr_tablet_tool_create(desktop->tablet_v2, + cursor->seat->seat, tool); + roots_tool->tool_destroy.notify = handle_tablet_tool_destroy; + wl_signal_add(&tool->events.destroy, &roots_tool->tool_destroy); + + roots_tool->set_cursor.notify = handle_tablet_tool_set_cursor; + wl_signal_add(&roots_tool->tablet_v2_tool->events.set_cursor, + &roots_tool->set_cursor); + + wl_list_init(&roots_tool->link); + wl_list_init(&roots_tool->tool_link); + } + + handle_tablet_tool_position(cursor, event->device->data, event->tool, + true, true, event->x, event->y, 0, 0); } static void handle_request_set_cursor(struct wl_listener *listener, @@ -164,7 +337,7 @@ void roots_seat_configure_cursor(struct roots_seat *seat) { struct roots_pointer *pointer; struct roots_touch *touch; - struct roots_tablet_tool *tablet_tool; + struct roots_tablet *tablet; struct roots_output *output; // reset mappings @@ -175,8 +348,8 @@ void roots_seat_configure_cursor(struct roots_seat *seat) { wl_list_for_each(touch, &seat->touch, link) { seat_reset_device_mappings(seat, touch->device); } - wl_list_for_each(tablet_tool, &seat->tablet_tools, link) { - seat_reset_device_mappings(seat, tablet_tool->device); + wl_list_for_each(tablet, &seat->tablets, link) { + seat_reset_device_mappings(seat, tablet->device); } // configure device to output mappings @@ -196,8 +369,8 @@ void roots_seat_configure_cursor(struct roots_seat *seat) { seat_set_device_output_mappings(seat, pointer->device, output->wlr_output); } - wl_list_for_each(tablet_tool, &seat->tablet_tools, link) { - seat_set_device_output_mappings(seat, tablet_tool->device, + wl_list_for_each(tablet, &seat->tablets, link) { + seat_set_device_output_mappings(seat, tablet->device, output->wlr_output); } wl_list_for_each(touch, &seat->touch, link) { @@ -251,6 +424,12 @@ static void roots_seat_init_cursor(struct roots_seat *seat) { wl_signal_add(&wlr_cursor->events.tablet_tool_tip, &seat->cursor->tool_tip); seat->cursor->tool_tip.notify = handle_tool_tip; + wl_signal_add(&wlr_cursor->events.tablet_tool_proximity, &seat->cursor->tool_proximity); + seat->cursor->tool_proximity.notify = handle_tool_proximity; + + wl_signal_add(&wlr_cursor->events.tablet_tool_button, &seat->cursor->tool_button); + seat->cursor->tool_button.notify = handle_tool_button; + wl_signal_add(&seat->seat->events.request_set_cursor, &seat->cursor->request_set_cursor); seat->cursor->request_set_cursor.notify = handle_request_set_cursor; @@ -375,7 +554,8 @@ struct roots_seat *roots_seat_create(struct roots_input *input, char *name) { wl_list_init(&seat->keyboards); wl_list_init(&seat->pointers); wl_list_init(&seat->touch); - wl_list_init(&seat->tablet_tools); + wl_list_init(&seat->tablets); + wl_list_init(&seat->tablet_pads); wl_list_init(&seat->views); wl_list_init(&seat->drag_icons); @@ -409,7 +589,7 @@ static void seat_update_capabilities(struct roots_seat *seat) { if (!wl_list_empty(&seat->keyboards)) { caps |= WL_SEAT_CAPABILITY_KEYBOARD; } - if (!wl_list_empty(&seat->pointers) || !wl_list_empty(&seat->tablet_tools)) { + if (!wl_list_empty(&seat->pointers) || !wl_list_empty(&seat->tablets)) { caps |= WL_SEAT_CAPABILITY_POINTER; } if (!wl_list_empty(&seat->touch)) { @@ -478,7 +658,7 @@ static void handle_pointer_destroy(struct wl_listener *listener, void *data) { static void seat_add_pointer(struct roots_seat *seat, struct wlr_input_device *device) { - struct roots_pointer *pointer = calloc(sizeof(struct roots_pointer), 1); + struct roots_pointer *pointer = calloc(1, sizeof(struct roots_pointer)); if (!pointer) { wlr_log(WLR_ERROR, "could not allocate pointer for seat"); return; @@ -511,7 +691,7 @@ static void handle_touch_destroy(struct wl_listener *listener, void *data) { static void seat_add_touch(struct roots_seat *seat, struct wlr_input_device *device) { - struct roots_touch *touch = calloc(sizeof(struct roots_touch), 1); + struct roots_touch *touch = calloc(1, sizeof(struct roots_touch)); if (!touch) { wlr_log(WLR_ERROR, "could not allocate touch for seat"); return; @@ -529,45 +709,201 @@ static void seat_add_touch(struct roots_seat *seat, roots_seat_configure_cursor(seat); } +static void handle_tablet_pad_destroy(struct wl_listener *listener, + void *data) { + struct roots_tablet_pad *tablet_pad = + wl_container_of(listener, tablet_pad, device_destroy); + struct roots_seat *seat = tablet_pad->seat; + + wl_list_remove(&tablet_pad->device_destroy.link); + wl_list_remove(&tablet_pad->tablet_destroy.link); + wl_list_remove(&tablet_pad->attach.link); + wl_list_remove(&tablet_pad->link); + + wl_list_remove(&tablet_pad->button.link); + wl_list_remove(&tablet_pad->strip.link); + wl_list_remove(&tablet_pad->ring.link); + free(tablet_pad); + + seat_update_capabilities(seat); +} + +static void handle_pad_tool_destroy(struct wl_listener *listener, void *data) { + struct roots_tablet_pad *pad = + wl_container_of(listener, pad, tablet_destroy); + + pad->tablet = NULL; + + wl_list_remove(&pad->tablet_destroy.link); + wl_list_init(&pad->tablet_destroy.link); +} + +static void attach_tablet_pad(struct roots_tablet_pad *pad, + struct roots_tablet *tool) { + wlr_log(WLR_DEBUG, "Attaching tablet pad \"%s\" to tablet tool \"%s\"", + pad->device->name, tool->device->name); + + pad->tablet = tool; + + pad->tablet_destroy.notify = handle_pad_tool_destroy; + wl_signal_add(&tool->device->events.destroy, &pad->tablet_destroy); +} + +static void handle_tablet_pad_attach(struct wl_listener *listener, void *data) { + struct roots_tablet_pad *pad = + wl_container_of(listener, pad, attach); + struct wlr_tablet_tool *wlr_tool = data; + struct roots_tablet *tool = wlr_tool->data; + + attach_tablet_pad(pad, tool); +} + +static void handle_tablet_pad_ring(struct wl_listener *listener, void *data) { + struct roots_tablet_pad *pad = + wl_container_of(listener, pad, ring); + struct wlr_event_tablet_pad_ring *event = data; + + wlr_send_tablet_v2_tablet_pad_ring(pad->tablet_v2_pad, + event->ring, event->position, + event->source == WLR_TABLET_PAD_RING_SOURCE_FINGER, + event->time_msec); +} + +static void handle_tablet_pad_strip(struct wl_listener *listener, void *data) { + struct roots_tablet_pad *pad = + wl_container_of(listener, pad, strip); + struct wlr_event_tablet_pad_strip *event = data; + + wlr_send_tablet_v2_tablet_pad_strip(pad->tablet_v2_pad, + event->strip, event->position, + event->source == WLR_TABLET_PAD_STRIP_SOURCE_FINGER, + event->time_msec); +} + +static void handle_tablet_pad_button(struct wl_listener *listener, void *data) { + struct roots_tablet_pad *pad = + wl_container_of(listener, pad, button); + struct wlr_event_tablet_pad_button *event = data; + + wlr_send_tablet_v2_tablet_pad_mode(pad->tablet_v2_pad, + event->group, event->mode, event->time_msec); + + wlr_send_tablet_v2_tablet_pad_button(pad->tablet_v2_pad, + event->button, event->time_msec, + (enum zwp_tablet_pad_v2_button_state)event->state); +} + static void seat_add_tablet_pad(struct roots_seat *seat, struct wlr_input_device *device) { - // TODO + struct roots_tablet_pad *tablet_pad = + calloc(1, sizeof(struct roots_tablet_pad)); + if (!tablet_pad) { + wlr_log(WLR_ERROR, "could not allocate tablet_pad for seat"); + return; + } + + device->data = tablet_pad; + tablet_pad->device = device; + tablet_pad->seat = seat; + wl_list_insert(&seat->tablet_pads, &tablet_pad->link); + + tablet_pad->device_destroy.notify = handle_tablet_pad_destroy; + wl_signal_add(&tablet_pad->device->events.destroy, + &tablet_pad->device_destroy); + + tablet_pad->attach.notify = handle_tablet_pad_attach; + wl_signal_add(&tablet_pad->device->tablet_pad->events.attach_tablet, &tablet_pad->attach); + + tablet_pad->button.notify = handle_tablet_pad_button; + wl_signal_add(&tablet_pad->device->tablet_pad->events.button, &tablet_pad->button); + + tablet_pad->strip.notify = handle_tablet_pad_strip; + wl_signal_add(&tablet_pad->device->tablet_pad->events.strip, &tablet_pad->strip); + + tablet_pad->ring.notify = handle_tablet_pad_ring; + wl_signal_add(&tablet_pad->device->tablet_pad->events.ring, &tablet_pad->ring); + + struct roots_desktop *desktop = seat->input->server->desktop; + tablet_pad->tablet_v2_pad = + wlr_tablet_pad_create(desktop->tablet_v2, seat->seat, device); + + /* Search for a sibling tablet */ + if (!wlr_input_device_is_libinput(device)) { + /* We can only do this on libinput devices */ + return; + } + + struct libinput_device_group *group = + libinput_device_get_device_group(wlr_libinput_get_device_handle(device)); + struct roots_tablet *tool; + wl_list_for_each(tool, &seat->tablets, link) { + if (!wlr_input_device_is_libinput(tool->device)) { + continue; + } + + struct libinput_device *li_dev = + wlr_libinput_get_device_handle(tool->device); + if (libinput_device_get_device_group(li_dev) == group) { + attach_tablet_pad(tablet_pad, tool); + break; + } + } } -static void handle_tablet_tool_destroy(struct wl_listener *listener, +static void handle_tablet_destroy(struct wl_listener *listener, void *data) { - struct roots_tablet_tool *tablet_tool = - wl_container_of(listener, tablet_tool, device_destroy); - struct roots_seat *seat = tablet_tool->seat; + struct roots_tablet *tablet = + wl_container_of(listener, tablet, device_destroy); + struct roots_seat *seat = tablet->seat; - wlr_cursor_detach_input_device(seat->cursor->cursor, tablet_tool->device); - wl_list_remove(&tablet_tool->device_destroy.link); - wl_list_remove(&tablet_tool->link); - free(tablet_tool); + wlr_cursor_detach_input_device(seat->cursor->cursor, tablet->device); + wl_list_remove(&tablet->device_destroy.link); + wl_list_remove(&tablet->link); + free(tablet); 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 = - calloc(sizeof(struct roots_tablet_tool), 1); - if (!tablet_tool) { - wlr_log(WLR_ERROR, "could not allocate tablet_tool for seat"); + struct roots_tablet *tablet = + calloc(1, sizeof(struct roots_tablet)); + if (!tablet) { + wlr_log(WLR_ERROR, "could not allocate tablet for seat"); return; } - device->data = tablet_tool; - tablet_tool->device = device; - tablet_tool->seat = seat; - wl_list_insert(&seat->tablet_tools, &tablet_tool->link); + device->data = tablet; + tablet->device = device; + tablet->seat = seat; + wl_list_insert(&seat->tablets, &tablet->link); - tablet_tool->device_destroy.notify = handle_tablet_tool_destroy; - wl_signal_add(&tablet_tool->device->events.destroy, - &tablet_tool->device_destroy); + tablet->device_destroy.notify = handle_tablet_destroy; + wl_signal_add(&tablet->device->events.destroy, + &tablet->device_destroy); wlr_cursor_attach_input_device(seat->cursor->cursor, device); roots_seat_configure_cursor(seat); + + struct roots_desktop *desktop = seat->input->server->desktop; + + tablet->tablet_v2 = + wlr_tablet_create(desktop->tablet_v2, seat->seat, device); + + struct libinput_device_group *group = + libinput_device_get_device_group(wlr_libinput_get_device_handle(device)); + struct roots_tablet_pad *pad; + wl_list_for_each(pad, &seat->tablet_pads, link) { + if (!wlr_input_device_is_libinput(pad->device)) { + continue; + } + + struct libinput_device *li_dev = + wlr_libinput_get_device_handle(pad->device); + if (libinput_device_get_device_group(li_dev) == group) { + attach_tablet_pad(pad, tablet); + } + } } void roots_seat_add_device(struct roots_seat *seat, @@ -788,7 +1124,7 @@ void roots_seat_set_focus(struct roots_seat *seat, struct roots_view *view) { #ifdef WLR_HAS_XWAYLAND if (view && view->type == ROOTS_XWAYLAND_VIEW && - wlr_xwayland_surface_is_unmanaged(view->xwayland_surface)) { + view->xwayland_surface->override_redirect) { return; } #endif @@ -833,6 +1169,13 @@ void roots_seat_set_focus(struct roots_seat *seat, struct roots_view *view) { wlr_seat_keyboard_notify_enter(seat->seat, view->wlr_surface, keyboard->keycodes, keyboard->num_keycodes, &keyboard->modifiers); + /* FIXME: Move this to a better place */ + struct roots_tablet_pad *pad; + wl_list_for_each(pad, &seat->tablet_pads, link) { + if (pad->tablet) { + wlr_send_tablet_v2_tablet_pad_enter(pad->tablet_v2_pad, pad->tablet->tablet_v2, view->wlr_surface); + } + } } else { wlr_seat_keyboard_notify_enter(seat->seat, view->wlr_surface, NULL, 0, NULL); diff --git a/types/meson.build b/types/meson.build index 49f87bf8..55c0e3ba 100644 --- a/types/meson.build +++ b/types/meson.build @@ -31,7 +31,7 @@ lib_wlr_types = static_library( 'wlr_input_inhibitor.c', 'wlr_keyboard.c', 'wlr_layer_shell.c', - 'wlr_linux_dmabuf.c', + 'wlr_linux_dmabuf_v1.c', 'wlr_list.c', 'wlr_matrix.c', 'wlr_output_damage.c', @@ -43,6 +43,10 @@ lib_wlr_types = static_library( 'wlr_screenshooter.c', 'wlr_server_decoration.c', 'wlr_surface.c', + 'tablet_v2/wlr_tablet_v2.c', + 'tablet_v2/wlr_tablet_v2_pad.c', + 'tablet_v2/wlr_tablet_v2_tablet.c', + 'tablet_v2/wlr_tablet_v2_tool.c', 'wlr_tablet_pad.c', 'wlr_tablet_tool.c', 'wlr_touch.c', diff --git a/types/seat/wlr_seat_pointer.c b/types/seat/wlr_seat_pointer.c index e54b79bf..899fb64f 100644 --- a/types/seat/wlr_seat_pointer.c +++ b/types/seat/wlr_seat_pointer.c @@ -355,7 +355,3 @@ void seat_client_destroy_pointer(struct wl_resource *resource) { } wl_resource_set_user_data(resource, NULL); } - -bool wlr_surface_is_pointer_cursor(struct wlr_surface *surface) { - return surface->role == &pointer_cursor_surface_role; -} diff --git a/types/tablet_v2/wlr_tablet_v2.c b/types/tablet_v2/wlr_tablet_v2.c new file mode 100644 index 00000000..fa058e79 --- /dev/null +++ b/types/tablet_v2/wlr_tablet_v2.c @@ -0,0 +1,310 @@ +#ifndef _POSIX_C_SOURCE +#define _POSIX_C_SOURCE 200809L +#endif + +#include <assert.h> +#include <libinput.h> +#include <stdlib.h> +#include <string.h> +#include <wayland-server.h> +#include <types/wlr_tablet_v2.h> +#include <wlr/config.h> +#include <wlr/types/wlr_seat.h> +#include <wlr/types/wlr_tablet_tool.h> +#include <wlr/types/wlr_tablet_v2.h> +#include <wlr/util/log.h> +#include "tablet-unstable-v2-protocol.h" + +#define TABLET_MANAGER_VERSION 1 + +struct wlr_tablet_manager_client_v2 { + struct wl_list link; + struct wl_client *client; + struct wl_resource *resource; + struct wlr_tablet_manager_v2 *manager; + + struct wl_list tablet_seats; // wlr_tablet_seat_client_v2::link +}; + +static void handle_wlr_seat_destroy(struct wl_listener *listener, void *data) { + struct wlr_tablet_seat_v2 *seat = + wl_container_of(listener, seat, seat_destroy); + + wl_list_remove(&seat->link); + wl_list_remove(&seat->seat_destroy.link); + + struct wlr_tablet_seat_client_v2 *client; + struct wlr_tablet_seat_client_v2 *tmp; + wl_list_for_each_safe(client, tmp, &seat->clients, seat_link) { + tablet_seat_client_v2_destroy(client->resource); + } +} + +static struct wlr_tablet_seat_v2 *create_tablet_seat( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat) { + struct wlr_tablet_seat_v2 *tablet_seat = + calloc(1, sizeof(struct wlr_tablet_seat_v2)); + if (!tablet_seat) { + return NULL; + } + + tablet_seat->manager = manager; + tablet_seat->wlr_seat = wlr_seat; + + wl_list_init(&tablet_seat->clients); + + wl_list_init(&tablet_seat->tablets); + wl_list_init(&tablet_seat->tools); + wl_list_init(&tablet_seat->pads); + + tablet_seat->seat_destroy.notify = handle_wlr_seat_destroy; + wl_signal_add(&wlr_seat->events.destroy, &tablet_seat->seat_destroy); + + wl_list_insert(&manager->seats, &tablet_seat->link); + return tablet_seat; +} + +struct wlr_tablet_seat_v2 *get_or_create_tablet_seat( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat) { + struct wlr_tablet_seat_v2 *pos; + wl_list_for_each(pos, &manager->seats, link) { + if (pos->wlr_seat == wlr_seat) { + return pos; + } + } + + return create_tablet_seat(manager, wlr_seat); +} + +static void tablet_seat_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} + +static struct zwp_tablet_seat_v2_interface seat_impl = { + .destroy = tablet_seat_destroy, +}; + +struct wlr_tablet_seat_client_v2 *tablet_seat_client_from_resource( + struct wl_resource *resource) { + assert(wl_resource_instance_of(resource, &zwp_tablet_seat_v2_interface, + &seat_impl)); + return wl_resource_get_user_data(resource); +} + +void tablet_seat_client_v2_destroy(struct wl_resource *resource) { + struct wlr_tablet_seat_client_v2 *seat = tablet_seat_client_from_resource(resource); + if (!seat) { + return; + } + + struct wlr_tablet_client_v2 *tablet; + struct wlr_tablet_client_v2 *tmp_tablet; + wl_list_for_each_safe(tablet, tmp_tablet, &seat->tablets, seat_link) { + destroy_tablet_v2(tablet->resource); + } + + struct wlr_tablet_pad_client_v2 *pad; + struct wlr_tablet_pad_client_v2 *tmp_pad; + wl_list_for_each_safe(pad, tmp_pad, &seat->pads, seat_link) { + destroy_tablet_pad_v2(pad->resource); + } + + struct wlr_tablet_tool_client_v2 *tool; + struct wlr_tablet_tool_client_v2 *tmp_tool; + wl_list_for_each_safe(tool, tmp_tool, &seat->tools, seat_link) { + destroy_tablet_tool_v2(tool->resource); + } + + wl_list_remove(&seat->seat_link); + wl_list_remove(&seat->client_link); + wl_list_remove(&seat->seat_client_destroy.link); + + free(seat); + wl_resource_set_user_data(resource, NULL); +} + +static void handle_seat_client_destroy(struct wl_listener *listener, void *data) { + struct wlr_tablet_seat_client_v2 *seat = + wl_container_of(listener, seat, seat_client_destroy); + tablet_seat_client_v2_destroy(seat->resource); +} + +static void tablet_manager_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} + +static struct wlr_tablet_manager_client_v2 *tablet_manager_client_from_resource(struct wl_resource *resource); + +static void get_tablet_seat(struct wl_client *wl_client, struct wl_resource *resource, + uint32_t id, struct wl_resource *seat_resource) +{ + struct wlr_tablet_manager_client_v2 *manager = tablet_manager_client_from_resource(resource); + if (!manager) { + /* Inert manager, just set up the resource for later + * destruction, without allocations or advertising things + */ + wl_resource_set_implementation(seat_resource, &seat_impl, NULL, + tablet_seat_client_v2_destroy); + return; + } + struct wlr_seat_client *seat = wlr_seat_client_from_resource(seat_resource); + struct wlr_tablet_seat_v2 *tablet_seat = + get_or_create_tablet_seat(manager->manager, seat->seat); + + if (!tablet_seat) { // This can only happen when we ran out of memory + wl_client_post_no_memory(wl_client); + return; + } + + struct wlr_tablet_seat_client_v2 *seat_client = + calloc(1, sizeof(struct wlr_tablet_seat_client_v2)); + if (tablet_seat == NULL) { + wl_client_post_no_memory(wl_client); + return; + } + + seat_client->resource = + wl_resource_create(wl_client, &zwp_tablet_seat_v2_interface, TABLET_MANAGER_VERSION, id); + if (seat_client->resource == NULL) { + free(seat_client); + wl_client_post_no_memory(wl_client); + return; + } + wl_resource_set_implementation(seat_client->resource, &seat_impl, seat_client, + tablet_seat_client_v2_destroy); + + + seat_client->seat_client = seat; + seat_client->client = manager; + seat_client->wl_client = wl_client; + wl_list_init(&seat_client->tools); + wl_list_init(&seat_client->tablets); + wl_list_init(&seat_client->pads); + + seat_client->seat_client_destroy.notify = handle_seat_client_destroy; + wl_signal_add(&seat->events.destroy, &seat_client->seat_client_destroy); + + wl_list_insert(&manager->tablet_seats, &seat_client->client_link); + wl_list_insert(&tablet_seat->clients, &seat_client->seat_link); + + // We need to emit the devices allready on the seat + struct wlr_tablet_v2_tablet *tablet_pos; + wl_list_for_each(tablet_pos, &tablet_seat->tablets, link) { + add_tablet_client(seat_client, tablet_pos); + } + + struct wlr_tablet_v2_tablet_pad *pad_pos; + wl_list_for_each(pad_pos, &tablet_seat->pads, link) { + add_tablet_pad_client(seat_client, pad_pos); + } + + struct wlr_tablet_v2_tablet_tool *tool_pos; + wl_list_for_each(tool_pos, &tablet_seat->tools, link) { + add_tablet_tool_client(seat_client, tool_pos); + } +} + +static struct zwp_tablet_manager_v2_interface manager_impl = { + .get_tablet_seat = get_tablet_seat, + .destroy = tablet_manager_destroy, +}; + +static struct wlr_tablet_manager_client_v2 *tablet_manager_client_from_resource ( + struct wl_resource *resource) { + assert(wl_resource_instance_of(resource, &zwp_tablet_manager_v2_interface, + &manager_impl)); + return wl_resource_get_user_data(resource); +} + +static void wlr_tablet_manager_v2_destroy(struct wl_resource *resource) { + struct wlr_tablet_manager_client_v2 *client = tablet_manager_client_from_resource(resource); + if (!client) { + return; + } + + struct wlr_tablet_seat_client_v2 *pos; + struct wlr_tablet_seat_client_v2 *tmp; + wl_list_for_each_safe(pos, tmp, &client->tablet_seats, client_link) { + tablet_seat_client_v2_destroy(pos->resource); + } + + wl_list_remove(&client->link); + + free(client); + wl_resource_set_user_data(resource, NULL); +} + +static void tablet_v2_bind(struct wl_client *wl_client, void *data, + uint32_t version, uint32_t id) { + struct wlr_tablet_manager_v2 *manager = data; + assert(wl_client && manager); + + struct wlr_tablet_manager_client_v2 *client = + calloc(1, sizeof(struct wlr_tablet_manager_client_v2)); + if (client == NULL) { + wl_client_post_no_memory(wl_client); + return; + } + + wl_list_init(&client->tablet_seats); + + client->resource = + wl_resource_create(wl_client, &zwp_tablet_manager_v2_interface, version, id); + if (client->resource == NULL) { + free(client); + wl_client_post_no_memory(wl_client); + return; + } + client->client = wl_client; + client->manager = manager; + + wl_resource_set_implementation(client->resource, &manager_impl, client, + wlr_tablet_manager_v2_destroy); + wl_list_insert(&manager->clients, &client->link); +} + +static void handle_display_destroy(struct wl_listener *listener, void *data) { + struct wlr_tablet_manager_v2 *tablet = + wl_container_of(listener, tablet, display_destroy); + wlr_tablet_v2_destroy(tablet); +} + +void wlr_tablet_v2_destroy(struct wlr_tablet_manager_v2 *manager) { + struct wlr_tablet_manager_client_v2 *tmp; + struct wlr_tablet_manager_client_v2 *pos; + + wl_list_for_each_safe(pos, tmp, &manager->clients, link) { + wlr_tablet_manager_v2_destroy(pos->resource); + } + + wl_global_destroy(manager->wl_global); + free(manager); +} + +struct wlr_tablet_manager_v2 *wlr_tablet_v2_create(struct wl_display *display) { + struct wlr_tablet_manager_v2 *tablet = + calloc(1, sizeof(struct wlr_tablet_manager_v2)); + if (!tablet) { + return NULL; + } + + wl_list_init(&tablet->clients); + wl_list_init(&tablet->seats); + + tablet->display_destroy.notify = handle_display_destroy; + wl_display_add_destroy_listener(display, &tablet->display_destroy); + + tablet->wl_global = wl_global_create(display, + &zwp_tablet_manager_v2_interface, TABLET_MANAGER_VERSION, + tablet, tablet_v2_bind); + if (tablet->wl_global == NULL) { + free(tablet); + return NULL; + } + + return tablet; +} diff --git a/types/tablet_v2/wlr_tablet_v2_pad.c b/types/tablet_v2/wlr_tablet_v2_pad.c new file mode 100644 index 00000000..1fcfa38e --- /dev/null +++ b/types/tablet_v2/wlr_tablet_v2_pad.c @@ -0,0 +1,566 @@ +#ifndef _POSIX_C_SOURCE +#define _POSIX_C_SOURCE 200809L +#endif + +#include "tablet-unstable-v2-protocol.h" +#include <assert.h> +#include <stdlib.h> +#include <types/wlr_tablet_v2.h> +#include <wayland-util.h> +#include <wlr/types/wlr_tablet_tool.h> +#include <wlr/types/wlr_tablet_v2.h> +#include <wlr/util/log.h> + +struct tablet_pad_auxiliary_user_data { + struct wlr_tablet_pad_client_v2 *pad; + size_t index; +}; + +static void handle_tablet_pad_v2_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} + +static void destroy_tablet_pad_ring_v2(struct wl_resource *resource) { + struct tablet_pad_auxiliary_user_data *aux = wl_resource_get_user_data(resource); + + if (!aux) { + return; + } + + aux->pad->rings[aux->index] = NULL; + free(aux); + wl_resource_set_user_data(resource, NULL); +} + +static void handle_tablet_pad_ring_v2_set_feedback(struct wl_client *client, + struct wl_resource *resource, const char *description, + uint32_t serial) { + struct tablet_pad_auxiliary_user_data *aux = wl_resource_get_user_data(resource); + if (!aux) { + return; + } + + struct wlr_tablet_v2_event_feedback evt = { + .serial = serial, + .description = description, + .index = aux->index + }; + + wl_signal_emit(&aux->pad->pad->events.ring_feedback, &evt); +} + +static void handle_tablet_pad_ring_v2_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} + +static struct zwp_tablet_pad_ring_v2_interface tablet_pad_ring_impl = { + .set_feedback = handle_tablet_pad_ring_v2_set_feedback, + .destroy = handle_tablet_pad_ring_v2_destroy, +}; + +static void destroy_tablet_pad_strip_v2(struct wl_resource *resource) { + struct tablet_pad_auxiliary_user_data *aux = wl_resource_get_user_data(resource); + if (!aux) { + return; + } + + aux->pad->strips[aux->index] = NULL; + free(aux); + wl_resource_set_user_data(resource, NULL); +} + +static void handle_tablet_pad_strip_v2_set_feedback(struct wl_client *client, + struct wl_resource *resource, const char *description, + uint32_t serial) { + struct tablet_pad_auxiliary_user_data *aux = wl_resource_get_user_data(resource); + if (!aux) { + return; + } + + struct wlr_tablet_v2_event_feedback evt = { + .serial = serial, + .description = description, + .index = aux->index + }; + + wl_signal_emit(&aux->pad->pad->events.strip_feedback, &evt); +} + +static void handle_tablet_pad_strip_v2_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} + +static struct zwp_tablet_pad_strip_v2_interface tablet_pad_strip_impl = { + .set_feedback = handle_tablet_pad_strip_v2_set_feedback, + .destroy = handle_tablet_pad_strip_v2_destroy, +}; + +static void handle_tablet_pad_v2_set_feedback( struct wl_client *client, + struct wl_resource *resource, uint32_t button, + const char *description, uint32_t serial) { + struct wlr_tablet_pad_client_v2 *pad = tablet_pad_client_from_resource(resource); + if (!pad) { + return; + } + + struct wlr_tablet_v2_event_feedback evt = { + .serial = serial, + .index = button, + .description = description, + }; + + wl_signal_emit(&pad->pad->events.button_feedback, &evt); +} + +static struct zwp_tablet_pad_v2_interface tablet_pad_impl = { + .set_feedback = handle_tablet_pad_v2_set_feedback, + .destroy = handle_tablet_pad_v2_destroy, +}; + +static void destroy_tablet_pad_group_v2(struct wl_resource *resource) { + struct tablet_pad_auxiliary_user_data *aux = wl_resource_get_user_data(resource); + + if (!aux) { + return; + } + + aux->pad->groups[aux->index] = NULL; + free(aux); + wl_resource_set_user_data(resource, NULL); +} + +void destroy_tablet_pad_v2(struct wl_resource *resource) { + struct wlr_tablet_pad_client_v2 *pad = + tablet_pad_client_from_resource(resource); + + if (!pad) { + return; + } + + wl_list_remove(&pad->seat_link); + wl_list_remove(&pad->pad_link); + + /* This isn't optimal, if the client destroys the resources in another + * order, it will be disconnected. + * But this makes things *way* easier for us, and (untested) I doubt + * clients will destroy it in another order. + */ + for (size_t i = 0; i < pad->group_count; ++i) { + if (pad->groups[i]) { + destroy_tablet_pad_group_v2(pad->groups[i]); + } + } + free(pad->groups); + + for (size_t i = 0; i < pad->ring_count; ++i) { + if (pad->rings[i]) { + destroy_tablet_pad_ring_v2(pad->rings[i]); + } + } + free(pad->rings); + + for (size_t i = 0; i < pad->strip_count; ++i) { + if (pad->strips[i]) { + destroy_tablet_pad_strip_v2(pad->strips[i]); + } + } + free(pad->strips); + + free(pad); + wl_resource_set_user_data(resource, NULL); +} + +static void handle_tablet_pad_group_v2_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} + +static struct zwp_tablet_pad_group_v2_interface tablet_pad_group_impl = { + .destroy = handle_tablet_pad_group_v2_destroy, +}; + +static void add_tablet_pad_group(struct wlr_tablet_v2_tablet_pad *pad, + struct wlr_tablet_pad_client_v2 *client, + struct wlr_tablet_pad_group *group, size_t index) { + + int version = wl_resource_get_version(client->resource); + client->groups[index] = + wl_resource_create(client->client, &zwp_tablet_pad_group_v2_interface, + version, 0); + if (!client->groups[index]) { + wl_client_post_no_memory(client->client); + return; + } + struct tablet_pad_auxiliary_user_data *user_data = + calloc(1, sizeof(struct tablet_pad_auxiliary_user_data)); + if (!user_data) { + wl_client_post_no_memory(client->client); + return; + } + user_data->pad = client; + user_data->index = index; + wl_resource_set_implementation(client->groups[index], &tablet_pad_group_impl, + user_data, destroy_tablet_pad_group_v2); + + zwp_tablet_pad_v2_send_group(client->resource, client->groups[index]); + zwp_tablet_pad_group_v2_send_modes(client->groups[index], group->mode_count); + + struct wl_array button_array; + wl_array_init(&button_array); + wl_array_add(&button_array, group->button_count * sizeof(int)); + memcpy(button_array.data, group->buttons, group->button_count * sizeof(int)); + zwp_tablet_pad_group_v2_send_buttons(client->groups[index], &button_array); + wl_array_release(&button_array); + + client->strip_count = group->strip_count; + for (size_t i = 0; i < group->strip_count; ++i) { + size_t strip = group->strips[i]; + struct tablet_pad_auxiliary_user_data *user_data = + calloc(1, sizeof(struct tablet_pad_auxiliary_user_data)); + if (!user_data) { + wl_client_post_no_memory(client->client); + return; + } + user_data->pad = client; + user_data->index = strip; + client->strips[strip] = + wl_resource_create(client->client, &zwp_tablet_pad_strip_v2_interface, 1, 0); + if (!client->strips[strip]) { + wl_client_post_no_memory(client->client); + return; + } + wl_resource_set_implementation(client->strips[strip], + &tablet_pad_strip_impl, user_data, destroy_tablet_pad_strip_v2); + zwp_tablet_pad_group_v2_send_strip(client->groups[index], client->strips[strip]); + } + + client->ring_count = group->ring_count; + for (size_t i = 0; i < group->ring_count; ++i) { + size_t ring = group->rings[i]; + struct tablet_pad_auxiliary_user_data *user_data = + calloc(1, sizeof(struct tablet_pad_auxiliary_user_data)); + if (!user_data) { + wl_client_post_no_memory(client->client); + return; + } + user_data->pad = client; + user_data->index = ring; + client->rings[ring] = + wl_resource_create(client->client, &zwp_tablet_pad_ring_v2_interface, 1, 0); + if (!client->rings[ring]) { + wl_client_post_no_memory(client->client); + return; + } + wl_resource_set_implementation(client->rings[ring], + &tablet_pad_ring_impl, user_data, destroy_tablet_pad_ring_v2); + zwp_tablet_pad_group_v2_send_ring(client->groups[index], client->rings[ring]); + } + + zwp_tablet_pad_group_v2_send_done(client->groups[index]); +} + +void add_tablet_pad_client(struct wlr_tablet_seat_client_v2 *seat, + struct wlr_tablet_v2_tablet_pad *pad) { + struct wlr_tablet_pad_client_v2 *client = + calloc(1, sizeof(struct wlr_tablet_pad_client_v2)); + if (!client) { + wl_client_post_no_memory(seat->wl_client); + return; + } + client->pad = pad; + + client->groups = calloc(wl_list_length(&pad->wlr_pad->groups), sizeof(struct wl_resource*)); + if (!client->groups) { + wl_client_post_no_memory(seat->wl_client); + free(client); + return; + } + + client->rings = calloc(pad->wlr_pad->ring_count, sizeof(struct wl_resource*)); + if (!client->rings) { + wl_client_post_no_memory(seat->wl_client); + free(client->groups); + free(client); + return; + } + + client->strips = calloc(pad->wlr_pad->strip_count, sizeof(struct wl_resource*)); + if (!client->strips) { + wl_client_post_no_memory(seat->wl_client); + free(client->groups); + free(client->rings); + free(client); + return; + } + + client->resource = + wl_resource_create(seat->wl_client, &zwp_tablet_pad_v2_interface, 1, 0); + if (!client->resource) { + wl_client_post_no_memory(seat->wl_client); + free(client->groups); + free(client->rings); + free(client->strips); + free(client); + return; + } + wl_resource_set_implementation(client->resource, &tablet_pad_impl, + client, destroy_tablet_pad_v2); + zwp_tablet_seat_v2_send_pad_added(seat->resource, client->resource); + client->client = seat->wl_client; + + // Send the expected events + if (pad->wlr_pad->button_count) { + zwp_tablet_pad_v2_send_buttons(client->resource, pad->wlr_pad->button_count); + } + for (size_t i = 0; i < pad->wlr_pad->paths.length; ++i) { + zwp_tablet_pad_v2_send_path(client->resource, + pad->wlr_pad->paths.items[i]); + } + size_t i = 0; + struct wlr_tablet_pad_group *group; + client->group_count = pad->group_count; + wl_list_for_each(group, &pad->wlr_pad->groups, link) { + add_tablet_pad_group(pad, client, group, i++); + } + + zwp_tablet_pad_v2_send_done(client->resource); + + wl_list_insert(&seat->pads, &client->seat_link); + wl_list_insert(&pad->clients, &client->pad_link); +} + +static void handle_wlr_tablet_pad_destroy(struct wl_listener *listener, void *data) { + struct wlr_tablet_v2_tablet_pad *pad = + wl_container_of(listener, pad, pad_destroy); + + struct wlr_tablet_pad_client_v2 *client; + struct wlr_tablet_pad_client_v2 *tmp_client; + wl_list_for_each_safe(client, tmp_client, &pad->clients, pad_link) { + zwp_tablet_pad_v2_send_removed(client->resource); + destroy_tablet_pad_v2(client->resource); + } + + wl_list_remove(&pad->clients); + wl_list_remove(&pad->link); + wl_list_remove(&pad->pad_destroy.link); + wl_list_remove(&pad->events.button_feedback.listener_list); + wl_list_remove(&pad->events.strip_feedback.listener_list); + wl_list_remove(&pad->events.ring_feedback.listener_list); + free(pad); +} + +struct wlr_tablet_v2_tablet_pad *wlr_tablet_pad_create( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat, + struct wlr_input_device *wlr_device) { + assert(wlr_device->type == WLR_INPUT_DEVICE_TABLET_PAD); + struct wlr_tablet_seat_v2 *seat = get_or_create_tablet_seat(manager, wlr_seat); + if (!seat) { + return NULL; + } + struct wlr_tablet_pad *wlr_pad = wlr_device->tablet_pad; + struct wlr_tablet_v2_tablet_pad *pad = calloc(1, sizeof(struct wlr_tablet_v2_tablet_pad)); + if (!pad) { + return NULL; + } + + pad->group_count = wl_list_length(&wlr_pad->groups); + pad->groups = calloc(pad->group_count, sizeof(int)); + if (!pad->groups) { + free(pad); + return NULL; + } + + pad->wlr_pad = wlr_pad; + wl_list_init(&pad->clients); + + pad->pad_destroy.notify = handle_wlr_tablet_pad_destroy; + wl_signal_add(&wlr_device->events.destroy, &pad->pad_destroy); + wl_list_insert(&seat->pads, &pad->link); + + // We need to create a tablet client for all clients on the seat + struct wlr_tablet_seat_client_v2 *pos; + wl_list_for_each(pos, &seat->clients, seat_link) { + // Tell the clients about the new tool + add_tablet_pad_client(pos, pad); + } + + wl_signal_init(&pad->events.button_feedback); + wl_signal_init(&pad->events.strip_feedback); + wl_signal_init(&pad->events.ring_feedback); + + return pad; +} + +struct wlr_tablet_pad_client_v2 *tablet_pad_client_from_resource(struct wl_resource *resource) { + assert(wl_resource_instance_of(resource, &zwp_tablet_pad_v2_interface, + &tablet_pad_impl)); + return wl_resource_get_user_data(resource); +} + +/* Actual protocol foo */ +uint32_t wlr_send_tablet_v2_tablet_pad_enter( + struct wlr_tablet_v2_tablet_pad *pad, + struct wlr_tablet_v2_tablet *tablet, + struct wlr_surface *surface) { + struct wl_client *client = wl_resource_get_client(surface->resource); + + struct wlr_tablet_client_v2 *tablet_tmp; + struct wlr_tablet_client_v2 *tablet_client = NULL; + wl_list_for_each(tablet_tmp, &tablet->clients, tablet_link) { + if (tablet_tmp->client == client) { + tablet_client = tablet_tmp; + break; + } + } + + // Couldn't find the client binding for the surface's client. Either + // the client didn't bind tablet_v2 at all, or not for the relevant + // seat + if (!tablet_client) { + return 0; + } + + struct wlr_tablet_pad_client_v2 *pad_tmp = NULL; + struct wlr_tablet_pad_client_v2 *pad_client = NULL; + wl_list_for_each(pad_tmp, &pad->clients, pad_link) { + if (pad_tmp->client == client) { + pad_client = pad_tmp; + break; + } + } + + // Couldn't find the client binding for the surface's client. Either + // the client didn't bind tablet_v2 at all, or not for the relevant + // seat + if (!pad_client) { + return 0; + } + + pad->current_client = pad_client; + + uint32_t serial = wl_display_next_serial(wl_client_get_display(client)); + + zwp_tablet_pad_v2_send_enter(pad_client->resource, serial, + tablet_client->resource, surface->resource); + + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + uint32_t time = now.tv_nsec / 1000; + + for (size_t i = 0; i < pad->group_count; ++i) { + zwp_tablet_pad_group_v2_send_mode_switch( + pad_client->groups[i], time, serial, pad->groups[i]); + } + + return serial; +} + +void wlr_send_tablet_v2_tablet_pad_button( + struct wlr_tablet_v2_tablet_pad *pad, size_t button, + uint32_t time, enum zwp_tablet_pad_v2_button_state state) { + + if (pad->current_client) { + zwp_tablet_pad_v2_send_button(pad->current_client->resource, + time, button, state); + } +} + +void wlr_send_tablet_v2_tablet_pad_strip(struct wlr_tablet_v2_tablet_pad *pad, + uint32_t strip, double position, bool finger, uint32_t time) { + if (!pad->current_client && + pad->current_client->strips && + pad->current_client->strips[strip]) { + return; + } + struct wl_resource *resource = pad->current_client->strips[strip]; + + if (finger) { + zwp_tablet_pad_strip_v2_send_source(resource, ZWP_TABLET_PAD_STRIP_V2_SOURCE_FINGER); + } + + if (position < 0) { + zwp_tablet_pad_strip_v2_send_stop(resource); + } else { + zwp_tablet_pad_strip_v2_send_position(resource, position * 65535); + } + zwp_tablet_pad_strip_v2_send_frame(resource, time); +} + +void wlr_send_tablet_v2_tablet_pad_ring(struct wlr_tablet_v2_tablet_pad *pad, + uint32_t ring, double position, bool finger, uint32_t time) { + if (!pad->current_client || + !pad->current_client->rings || + !pad->current_client->rings[ring]) { + return; + } + struct wl_resource *resource = pad->current_client->rings[ring]; + + if (finger) { + zwp_tablet_pad_ring_v2_send_source(resource, ZWP_TABLET_PAD_RING_V2_SOURCE_FINGER); + } + + if (position < 0) { + zwp_tablet_pad_ring_v2_send_stop(resource); + } else { + zwp_tablet_pad_ring_v2_send_angle(resource, position); + } + zwp_tablet_pad_ring_v2_send_frame(resource, time); +} + +uint32_t wlr_send_tablet_v2_tablet_pad_leave(struct wlr_tablet_v2_tablet_pad *pad, + struct wlr_surface *surface) { + struct wl_client *client = wl_resource_get_client(surface->resource); + if (!pad->current_client || client != pad->current_client->client) { + return 0; + } + + uint32_t serial = wl_display_next_serial(wl_client_get_display(client)); + + zwp_tablet_pad_v2_send_leave(pad->current_client->resource, serial, surface->resource); + return serial; +} + +uint32_t wlr_send_tablet_v2_tablet_pad_mode(struct wlr_tablet_v2_tablet_pad *pad, + size_t group, uint32_t mode, uint32_t time) { + if (!pad->current_client || + !pad->current_client->groups || + !pad->current_client->groups[group] ) { + return 0; + } + + if (pad->groups[group] == mode) { + return 0; + } + + pad->groups[group] = mode; + + struct wl_client *client = wl_resource_get_client(pad->current_client->resource); + uint32_t serial = wl_display_next_serial(wl_client_get_display(client)); + + zwp_tablet_pad_group_v2_send_mode_switch( + pad->current_client->groups[group], time, serial, mode); + return serial; +} + +bool wlr_surface_accepts_tablet_v2(struct wlr_tablet_v2_tablet *tablet, + struct wlr_surface *surface) { + struct wl_client *client = wl_resource_get_client(surface->resource); + + if (tablet->current_client && + tablet->current_client->client == client) { + return true; + } + + struct wlr_tablet_client_v2 *tablet_tmp; + wl_list_for_each(tablet_tmp, &tablet->clients, tablet_link) { + if (tablet_tmp->client == client) { + return true; + } + } + + return false; +} diff --git a/types/tablet_v2/wlr_tablet_v2_tablet.c b/types/tablet_v2/wlr_tablet_v2_tablet.c new file mode 100644 index 00000000..0d1b5aa3 --- /dev/null +++ b/types/tablet_v2/wlr_tablet_v2_tablet.c @@ -0,0 +1,132 @@ +#ifndef _POSIX_C_SOURCE +#define _POSIX_C_SOURCE 200809L +#endif + +#include <assert.h> +#include <stdlib.h> +#include <types/wlr_tablet_v2.h> +#include <wayland-util.h> +#include <wlr/types/wlr_tablet_tool.h> +#include <wlr/types/wlr_tablet_v2.h> +#include <wlr/util/log.h> + +#include "tablet-unstable-v2-protocol.h" + +void destroy_tablet_v2(struct wl_resource *resource) { + struct wlr_tablet_client_v2 *tablet = tablet_client_from_resource(resource); + + if (!tablet) { + return; + } + + wl_list_remove(&tablet->seat_link); + wl_list_remove(&tablet->tablet_link); + free(tablet); + wl_resource_set_user_data(resource, NULL); +} + +static void handle_tablet_v2_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} + +static struct zwp_tablet_v2_interface tablet_impl = { + .destroy = handle_tablet_v2_destroy, +}; + +static void handle_wlr_tablet_destroy(struct wl_listener *listener, void *data) { + struct wlr_tablet_v2_tablet *tablet = + wl_container_of(listener, tablet, tool_destroy); + + struct wlr_tablet_client_v2 *pos; + struct wlr_tablet_client_v2 *tmp; + wl_list_for_each_safe(pos, tmp, &tablet->clients, tablet_link) { + zwp_tablet_v2_send_removed(pos->resource); + } + + wl_list_remove(&tablet->clients); + wl_list_remove(&tablet->link); + wl_list_remove(&tablet->tool_destroy.link); + free(tablet); +} + +struct wlr_tablet_v2_tablet *wlr_tablet_create( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat, + struct wlr_input_device *wlr_device) { + assert(wlr_device->type == WLR_INPUT_DEVICE_TABLET_TOOL); + struct wlr_tablet_seat_v2 *seat = get_or_create_tablet_seat(manager, wlr_seat); + if (!seat) { + return NULL; + } + struct wlr_tablet *wlr_tablet = wlr_device->tablet; + struct wlr_tablet_v2_tablet *tablet = calloc(1, sizeof(struct wlr_tablet_v2_tablet)); + if (!tablet) { + return NULL; + } + + tablet->wlr_tablet = wlr_tablet; + tablet->wlr_device = wlr_device; + wl_list_init(&tablet->clients); + + + tablet->tool_destroy.notify = handle_wlr_tablet_destroy; + wl_signal_add(&wlr_device->events.destroy, &tablet->tool_destroy); + wl_list_insert(&seat->tablets, &tablet->link); + + // We need to create a tablet client for all clients on the seat + struct wlr_tablet_seat_client_v2 *pos; + wl_list_for_each(pos, &seat->clients, seat_link) { + // Tell the clients about the new tool + add_tablet_client(pos, tablet); + } + + return tablet; +} + + +void add_tablet_client(struct wlr_tablet_seat_client_v2 *seat, + struct wlr_tablet_v2_tablet *tablet) { + struct wlr_tablet_client_v2 *client = + calloc(1, sizeof(struct wlr_tablet_client_v2)); + if (!client) { + return; + } + + uint32_t version = wl_resource_get_version(seat->resource); + client->resource = + wl_resource_create(seat->wl_client, &zwp_tablet_v2_interface, + version, 0); + if (!client->resource) { + wl_resource_post_no_memory(seat->resource); + free(client); + return; + } + wl_resource_set_implementation(client->resource, &tablet_impl, + client, destroy_tablet_v2); + zwp_tablet_seat_v2_send_tablet_added(seat->resource, client->resource); + + // Send the expected events + if (tablet->wlr_tablet->name) { + zwp_tablet_v2_send_name(client->resource, + tablet->wlr_tablet->name); + } + zwp_tablet_v2_send_id(client->resource, + tablet->wlr_device->vendor, tablet->wlr_device->product); + for (size_t i = 0; i < tablet->wlr_tablet->paths.length; ++i) { + zwp_tablet_v2_send_path(client->resource, + tablet->wlr_tablet->paths.items[i]); + } + zwp_tablet_v2_send_done(client->resource); + + client->client = seat->wl_client; + wl_list_insert(&seat->tablets, &client->seat_link); + wl_list_insert(&tablet->clients, &client->tablet_link); +} + + +struct wlr_tablet_client_v2 *tablet_client_from_resource(struct wl_resource *resource) { + assert(wl_resource_instance_of(resource, &zwp_tablet_v2_interface, + &tablet_impl)); + return wl_resource_get_user_data(resource); +} diff --git a/types/tablet_v2/wlr_tablet_v2_tool.c b/types/tablet_v2/wlr_tablet_v2_tool.c new file mode 100644 index 00000000..62c00a37 --- /dev/null +++ b/types/tablet_v2/wlr_tablet_v2_tool.c @@ -0,0 +1,514 @@ +#ifndef _POSIX_C_SOURCE +#define _POSIX_C_SOURCE 200809L +#endif + +#include "tablet-unstable-v2-protocol.h" +#include "util/array.h" +#include <assert.h> +#include <stdlib.h> +#include <types/wlr_tablet_v2.h> +#include <wayland-util.h> +#include <wlr/types/wlr_tablet_tool.h> +#include <wlr/types/wlr_tablet_v2.h> +#include <wlr/util/log.h> + +static const struct wlr_surface_role tablet_tool_cursor_surface_role = { + .name = "wp_tablet_tool-cursor", +}; + +static void handle_tablet_tool_v2_set_cursor(struct wl_client *client, + struct wl_resource *resource, uint32_t serial, + struct wl_resource *surface_resource, + int32_t hotspot_x, int32_t hotspot_y) { + struct wlr_tablet_tool_client_v2 *tool = tablet_tool_client_from_resource(resource); + if (!tool) { + return; + } + + struct wlr_surface *surface = NULL; + if (surface_resource != NULL) { + surface = wlr_surface_from_resource(surface_resource); + if (!wlr_surface_set_role(surface, &tablet_tool_cursor_surface_role, NULL, + surface_resource, ZWP_TABLET_TOOL_V2_ERROR_ROLE)) { + return; + } + } + + struct wlr_tablet_v2_event_cursor evt = { + .surface = surface, + .serial = serial, + .hotspot_x = hotspot_x, + .hotspot_y = hotspot_y, + .seat_client = tool->seat->seat_client, + }; + + wl_signal_emit(&tool->tool->events.set_cursor, &evt); +} + +static void handle_tablet_tool_v2_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} +static struct zwp_tablet_tool_v2_interface tablet_tool_impl = { + .set_cursor = handle_tablet_tool_v2_set_cursor, + .destroy = handle_tablet_tool_v2_destroy, +}; + +static enum zwp_tablet_tool_v2_type tablet_type_from_wlr_type( + enum wlr_tablet_tool_type wlr_type) { + switch(wlr_type) { + case WLR_TABLET_TOOL_TYPE_PEN: + return ZWP_TABLET_TOOL_V2_TYPE_PEN; + case WLR_TABLET_TOOL_TYPE_ERASER: + return ZWP_TABLET_TOOL_V2_TYPE_ERASER; + case WLR_TABLET_TOOL_TYPE_BRUSH: + return ZWP_TABLET_TOOL_V2_TYPE_BRUSH; + case WLR_TABLET_TOOL_TYPE_PENCIL: + return ZWP_TABLET_TOOL_V2_TYPE_PENCIL; + case WLR_TABLET_TOOL_TYPE_AIRBRUSH: + return ZWP_TABLET_TOOL_V2_TYPE_AIRBRUSH; + case WLR_TABLET_TOOL_TYPE_MOUSE: + return ZWP_TABLET_TOOL_V2_TYPE_MOUSE; + case WLR_TABLET_TOOL_TYPE_LENS: + return ZWP_TABLET_TOOL_V2_TYPE_LENS; + } + + assert(false && "Unreachable"); +} + +void destroy_tablet_tool_v2(struct wl_resource *resource) { + struct wlr_tablet_tool_client_v2 *client = + tablet_tool_client_from_resource(resource); + + if (!client) { + return; + } + + if (client->frame_source) { + wl_event_source_remove(client->frame_source); + } + + if (client->tool && client->tool->current_client == client) { + client->tool->current_client = NULL; + } + + wl_list_remove(&client->seat_link); + wl_list_remove(&client->tool_link); + free(client); + + wl_resource_set_user_data(resource, NULL); +} + +void add_tablet_tool_client(struct wlr_tablet_seat_client_v2 *seat, + struct wlr_tablet_v2_tablet_tool *tool) { + struct wlr_tablet_tool_client_v2 *client = + calloc(1, sizeof(struct wlr_tablet_tool_client_v2)); + if (!client) { + return; + } + client->tool = tool; + client->seat = seat; + + client->resource = + wl_resource_create(seat->wl_client, &zwp_tablet_tool_v2_interface, 1, 0); + if (!client->resource) { + free(client); + return; + } + wl_resource_set_implementation(client->resource, &tablet_tool_impl, + client, destroy_tablet_tool_v2); + zwp_tablet_seat_v2_send_tool_added(seat->resource, client->resource); + + // Send the expected events + if (tool->wlr_tool->hardware_serial) { + zwp_tablet_tool_v2_send_hardware_serial( + client->resource, + tool->wlr_tool->hardware_serial >> 32, + tool->wlr_tool->hardware_serial & 0xFFFFFFFF); + } + if (tool->wlr_tool->hardware_wacom) { + zwp_tablet_tool_v2_send_hardware_id_wacom( + client->resource, + tool->wlr_tool->hardware_wacom >> 32, + tool->wlr_tool->hardware_wacom & 0xFFFFFFFF); + } + zwp_tablet_tool_v2_send_type(client->resource, + tablet_type_from_wlr_type(tool->wlr_tool->type)); + + if (tool->wlr_tool->tilt) { + zwp_tablet_tool_v2_send_capability(client->resource, + ZWP_TABLET_TOOL_V2_CAPABILITY_TILT); + } + + if (tool->wlr_tool->pressure) { + zwp_tablet_tool_v2_send_capability(client->resource, + ZWP_TABLET_TOOL_V2_CAPABILITY_PRESSURE); + } + + if (tool->wlr_tool->distance) { + zwp_tablet_tool_v2_send_capability(client->resource, + ZWP_TABLET_TOOL_V2_CAPABILITY_DISTANCE); + } + + if (tool->wlr_tool->rotation) { + zwp_tablet_tool_v2_send_capability(client->resource, + ZWP_TABLET_TOOL_V2_CAPABILITY_ROTATION); + } + + if (tool->wlr_tool->slider) { + zwp_tablet_tool_v2_send_capability(client->resource, + ZWP_TABLET_TOOL_V2_CAPABILITY_SLIDER); + } + + if (tool->wlr_tool->wheel) { + zwp_tablet_tool_v2_send_capability(client->resource, + ZWP_TABLET_TOOL_V2_CAPABILITY_WHEEL); + } + + zwp_tablet_tool_v2_send_done(client->resource); + + client->client = seat->wl_client; + wl_list_insert(&seat->tools, &client->seat_link); + wl_list_insert(&tool->clients, &client->tool_link); +} + +static void handle_wlr_tablet_tool_destroy(struct wl_listener *listener, void *data) { + struct wlr_tablet_v2_tablet_tool *tool = + wl_container_of(listener, tool, tool_destroy); + + struct wlr_tablet_tool_client_v2 *pos; + struct wlr_tablet_tool_client_v2 *tmp; + wl_list_for_each_safe(pos, tmp, &tool->clients, tool_link) { + zwp_tablet_tool_v2_send_removed(pos->resource); + pos->tool = NULL; + } + + wl_list_remove(&tool->clients); + wl_list_remove(&tool->link); + wl_list_remove(&tool->tool_destroy.link); + wl_list_remove(&tool->events.set_cursor.listener_list); + free(tool); +} + +struct wlr_tablet_v2_tablet_tool *wlr_tablet_tool_create( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat, + struct wlr_tablet_tool *wlr_tool) { + struct wlr_tablet_seat_v2 *seat = get_or_create_tablet_seat(manager, wlr_seat); + if (!seat) { + return NULL; + } + struct wlr_tablet_v2_tablet_tool *tool = + calloc(1, sizeof(struct wlr_tablet_v2_tablet_tool)); + if (!tool) { + return NULL; + } + + tool->wlr_tool = wlr_tool; + wl_list_init(&tool->clients); + + + tool->tool_destroy.notify = handle_wlr_tablet_tool_destroy; + wl_signal_add(&wlr_tool->events.destroy, &tool->tool_destroy); + wl_list_insert(&seat->tools, &tool->link); + + // We need to create a tablet client for all clients on the seat + struct wlr_tablet_seat_client_v2 *pos; + wl_list_for_each(pos, &seat->clients, seat_link) { + // Tell the clients about the new tool + add_tablet_tool_client(pos, tool); + } + + wl_signal_init(&tool->events.set_cursor); + + return tool; +} + +struct wlr_tablet_tool_client_v2 *tablet_tool_client_from_resource(struct wl_resource *resource) { + assert(wl_resource_instance_of(resource, &zwp_tablet_tool_v2_interface, + &tablet_tool_impl)); + return wl_resource_get_user_data(resource); +} + + +/* Actual protocol foo */ + +// Button 0 is KEY_RESERVED in input-event-codes on linux (and freebsd) +static ssize_t tablet_tool_button_update(struct wlr_tablet_v2_tablet_tool *tool, + uint32_t button, enum zwp_tablet_pad_v2_button_state state) { + bool found = false; + size_t i = 0; + for (; i < tool->num_buttons; ++i) { + if (tool->pressed_buttons[i] == button) { + found = true; + wlr_log(WLR_DEBUG, "Found the button \\o/: %u", button); + break; + + } + } + + if (state == ZWP_TABLET_PAD_V2_BUTTON_STATE_PRESSED && found) { + /* Already have the button saved, durr */ + return -1; + } + + if (state == ZWP_TABLET_PAD_V2_BUTTON_STATE_PRESSED && !found) { + if (tool->num_buttons < WLR_TABLET_V2_TOOL_BUTTONS_CAP) { + i = tool->num_buttons++; + tool->pressed_buttons[i] = button; + tool->pressed_serials[i] = -1; + } else { + i = -1; + wlr_log(WLR_ERROR, "You pressed more than %d tablet tool buttons. This is currently not supporte by wlroots. Please report this with a description of your tablet, since this is either a bug, or fancy hardware", + WLR_TABLET_V2_TOOL_BUTTONS_CAP); + } + } + if (state == ZWP_TABLET_PAD_V2_BUTTON_STATE_RELEASED && found) { + wlr_log(WLR_DEBUG, "Removed the button \\o/: %u", button); + tool->pressed_buttons[i] = 0; + tool->pressed_serials[i] = 0; + tool->num_buttons = push_zeroes_to_end(tool->pressed_buttons, WLR_TABLET_V2_TOOL_BUTTONS_CAP); + tool->num_buttons = push_zeroes_to_end(tool->pressed_serials, WLR_TABLET_V2_TOOL_BUTTONS_CAP); + } + + assert(tool->num_buttons <= WLR_TABLET_V2_TOOL_BUTTONS_CAP); + return i; +} + +static inline int64_t timespec_to_msec(const struct timespec *a) { + return (int64_t)a->tv_sec * 1000 + a->tv_nsec / 1000000; +} + +static void send_tool_frame(void *data) { + struct wlr_tablet_tool_client_v2 *tool = data; + + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + zwp_tablet_tool_v2_send_frame(tool->resource, timespec_to_msec(&now)); + tool->frame_source = NULL; +} + +static void queue_tool_frame(struct wlr_tablet_tool_client_v2 *tool) { + struct wl_display *display = wl_client_get_display(tool->client); + struct wl_event_loop *loop = wl_display_get_event_loop(display); + if (!tool->frame_source) { + tool->frame_source = + wl_event_loop_add_idle(loop, send_tool_frame, tool); + } +} + +void wlr_send_tablet_v2_tablet_tool_proximity_in( + struct wlr_tablet_v2_tablet_tool *tool, + struct wlr_tablet_v2_tablet *tablet, + struct wlr_surface *surface) { + struct wl_client *client = wl_resource_get_client(surface->resource); + + if (tool->focused_surface == surface) { + return; + } + + struct wlr_tablet_client_v2 *tablet_tmp; + struct wlr_tablet_client_v2 *tablet_client = NULL; + wl_list_for_each(tablet_tmp, &tablet->clients, tablet_link) { + if (tablet_tmp->client == client) { + tablet_client = tablet_tmp; + break; + } + } + + // Couldn't find the client binding for the surface's client. Either + // the client didn't bind tablet_v2 at all, or not for the relevant + // seat + if (!tablet_client) { + return; + } + + struct wlr_tablet_tool_client_v2 *tool_tmp = NULL; + struct wlr_tablet_tool_client_v2 *tool_client = NULL; + wl_list_for_each(tool_tmp, &tool->clients, tool_link) { + if (tool_tmp->client == client) { + tool_client = tool_tmp; + break; + } + } + + // Couldn't find the client binding for the surface's client. Either + // the client didn't bind tablet_v2 at all, or not for the relevant + // seat + if (!tool_client) { + return; + } + + tool->current_client = tool_client; + + uint32_t serial = wl_display_next_serial(wl_client_get_display(client)); + tool->focused_surface = surface; + tool->proximity_serial = serial; + + zwp_tablet_tool_v2_send_proximity_in(tool_client->resource, serial, + tablet_client->resource, surface->resource); + /* Send all the pressed buttons */ + for (size_t i = 0; i < tool->num_buttons; ++i) { + wlr_send_tablet_v2_tablet_tool_button(tool, + tool->pressed_buttons[i], + ZWP_TABLET_PAD_V2_BUTTON_STATE_PRESSED); + } + if (tool->is_down) { + wlr_send_tablet_v2_tablet_tool_down(tool); + } + + queue_tool_frame(tool_client); +} + +void wlr_send_tablet_v2_tablet_tool_motion( + struct wlr_tablet_v2_tablet_tool *tool, double x, double y) { + if (!tool->current_client) { + return; + } + + zwp_tablet_tool_v2_send_motion(tool->current_client->resource, + wl_fixed_from_double(x), wl_fixed_from_double(y)); + + queue_tool_frame(tool->current_client); +} + +void wlr_send_tablet_v2_tablet_tool_proximity_out( + struct wlr_tablet_v2_tablet_tool *tool) { + if (tool->current_client) { + for (size_t i = 0; i < tool->num_buttons; ++i) { + zwp_tablet_tool_v2_send_button(tool->current_client->resource, + tool->pressed_serials[i], + tool->pressed_buttons[i], + ZWP_TABLET_PAD_V2_BUTTON_STATE_RELEASED); + } + if (tool->is_down) { + zwp_tablet_tool_v2_send_up(tool->current_client->resource); + } + zwp_tablet_tool_v2_send_proximity_out(tool->current_client->resource); + if (tool->current_client->frame_source) { + wl_event_source_remove(tool->current_client->frame_source); + send_tool_frame(tool->current_client); + } + + tool->current_client = NULL; + tool->focused_surface = NULL; + } +} + +void wlr_send_tablet_v2_tablet_tool_pressure( + struct wlr_tablet_v2_tablet_tool *tool, double pressure) { + if (tool->current_client) { + zwp_tablet_tool_v2_send_pressure(tool->current_client->resource, + pressure * 65535); + + queue_tool_frame(tool->current_client); + } +} + +void wlr_send_tablet_v2_tablet_tool_distance( + struct wlr_tablet_v2_tablet_tool *tool, double distance) { + if (tool->current_client) { + zwp_tablet_tool_v2_send_distance(tool->current_client->resource, + distance * 65535); + + queue_tool_frame(tool->current_client); + } +} + +void wlr_send_tablet_v2_tablet_tool_tilt( + struct wlr_tablet_v2_tablet_tool *tool, double x, double y) { + if (!tool->current_client) { + return; + } + + zwp_tablet_tool_v2_send_tilt(tool->current_client->resource, + wl_fixed_from_double(x), wl_fixed_from_double(y)); + + queue_tool_frame(tool->current_client); +} + +void wlr_send_tablet_v2_tablet_tool_rotation( + struct wlr_tablet_v2_tablet_tool *tool, double degrees) { + if (!tool->current_client) { + return; + } + + zwp_tablet_tool_v2_send_rotation(tool->current_client->resource, + wl_fixed_from_double(degrees)); + + queue_tool_frame(tool->current_client); +} + +void wlr_send_tablet_v2_tablet_tool_slider( + struct wlr_tablet_v2_tablet_tool *tool, double position) { + if (!tool->current_client) { + return; + } + + zwp_tablet_tool_v2_send_slider(tool->current_client->resource, + position * 65535); + + queue_tool_frame(tool->current_client); +} + +void wlr_send_tablet_v2_tablet_tool_button( + struct wlr_tablet_v2_tablet_tool *tool, uint32_t button, + enum zwp_tablet_pad_v2_button_state state) { + ssize_t index = tablet_tool_button_update(tool, button, state); + + if (tool->current_client) { + struct wl_client *client = + wl_resource_get_client(tool->current_client->resource); + uint32_t serial = wl_display_next_serial(wl_client_get_display(client)); + if (index >= 0) { + tool->pressed_serials[index] = serial; + } + + zwp_tablet_tool_v2_send_button(tool->current_client->resource, + serial, button, state); + queue_tool_frame(tool->current_client); + } +} + +void wlr_send_tablet_v2_tablet_tool_wheel( + struct wlr_tablet_v2_tablet_tool *tool, double degrees, int32_t clicks) { + if (tool->current_client) { + zwp_tablet_tool_v2_send_wheel(tool->current_client->resource, + clicks, degrees); + + queue_tool_frame(tool->current_client); + } +} + +void wlr_send_tablet_v2_tablet_tool_down(struct wlr_tablet_v2_tablet_tool *tool) { + if (tool->is_down) { + return; + } + + tool->is_down = true; + if (tool->current_client) { + struct wl_client *client = + wl_resource_get_client(tool->current_client->resource); + uint32_t serial = wl_display_next_serial(wl_client_get_display(client)); + + zwp_tablet_tool_v2_send_down(tool->current_client->resource, + serial); + queue_tool_frame(tool->current_client); + + tool->down_serial = serial; + } +} + +void wlr_send_tablet_v2_tablet_tool_up(struct wlr_tablet_v2_tablet_tool *tool) { + if (!tool->is_down) { + return; + } + tool->is_down = false; + tool->down_serial = 0; + + if (tool->current_client) { + zwp_tablet_tool_v2_send_up(tool->current_client->resource); + queue_tool_frame(tool->current_client); + } +} + diff --git a/types/wlr_buffer.c b/types/wlr_buffer.c index 5e4aedac..55ed4792 100644 --- a/types/wlr_buffer.c +++ b/types/wlr_buffer.c @@ -1,8 +1,8 @@ #include <assert.h> #include <stdlib.h> -#include <wlr/types/wlr_buffer.h> -#include <wlr/types/wlr_linux_dmabuf.h> #include <wlr/render/wlr_renderer.h> +#include <wlr/types/wlr_buffer.h> +#include <wlr/types/wlr_linux_dmabuf_v1.h> #include <wlr/util/log.h> bool wlr_resource_is_buffer(struct wl_resource *resource) { @@ -21,9 +21,9 @@ bool wlr_buffer_get_resource_size(struct wl_resource *resource, resource)) { wlr_renderer_wl_drm_buffer_get_size(renderer, resource, width, height); - } else if (wlr_dmabuf_resource_is_buffer(resource)) { - struct wlr_dmabuf_buffer *dmabuf = - wlr_dmabuf_buffer_from_buffer_resource(resource); + } else if (wlr_dmabuf_v1_resource_is_buffer(resource)) { + struct wlr_dmabuf_v1_buffer *dmabuf = + wlr_dmabuf_v1_buffer_from_buffer_resource(resource); *width = dmabuf->attributes.width; *height = dmabuf->attributes.height; } else { @@ -77,9 +77,9 @@ struct wlr_buffer *wlr_buffer_create(struct wlr_renderer *renderer, released = true; } else if (wlr_renderer_resource_is_wl_drm_buffer(renderer, resource)) { texture = wlr_texture_from_wl_drm(renderer, resource); - } else if (wlr_dmabuf_resource_is_buffer(resource)) { - struct wlr_dmabuf_buffer *dmabuf = - wlr_dmabuf_buffer_from_buffer_resource(resource); + } else if (wlr_dmabuf_v1_resource_is_buffer(resource)) { + struct wlr_dmabuf_v1_buffer *dmabuf = + wlr_dmabuf_v1_buffer_from_buffer_resource(resource); texture = wlr_texture_from_dmabuf(renderer, &dmabuf->attributes); // We have imported the DMA-BUF, but we need to prevent the client from diff --git a/types/wlr_cursor.c b/types/wlr_cursor.c index 4a30215f..82ad1a4a 100644 --- a/types/wlr_cursor.c +++ b/types/wlr_cursor.c @@ -551,19 +551,19 @@ static struct wlr_cursor_device *cursor_device_create( wl_signal_add(&device->touch->events.cancel, &c_device->touch_cancel); c_device->touch_cancel.notify = handle_touch_cancel; } else if (device->type == WLR_INPUT_DEVICE_TABLET_TOOL) { - wl_signal_add(&device->tablet_tool->events.tip, + wl_signal_add(&device->tablet->events.tip, &c_device->tablet_tool_tip); c_device->tablet_tool_tip.notify = handle_tablet_tool_tip; - wl_signal_add(&device->tablet_tool->events.proximity, + wl_signal_add(&device->tablet->events.proximity, &c_device->tablet_tool_proximity); c_device->tablet_tool_proximity.notify = handle_tablet_tool_proximity; - wl_signal_add(&device->tablet_tool->events.axis, + wl_signal_add(&device->tablet->events.axis, &c_device->tablet_tool_axis); c_device->tablet_tool_axis.notify = handle_tablet_tool_axis; - wl_signal_add(&device->tablet_tool->events.button, + wl_signal_add(&device->tablet->events.button, &c_device->tablet_tool_button); c_device->tablet_tool_button.notify = handle_tablet_tool_button; } diff --git a/types/wlr_export_dmabuf_v1.c b/types/wlr_export_dmabuf_v1.c index 060f4afa..72c9bcec 100644 --- a/types/wlr_export_dmabuf_v1.c +++ b/types/wlr_export_dmabuf_v1.c @@ -2,8 +2,8 @@ #include <stdlib.h> #include <unistd.h> #include <wlr/interfaces/wlr_output.h> +#include <wlr/render/dmabuf.h> #include <wlr/types/wlr_export_dmabuf_v1.h> -#include <wlr/types/wlr_linux_dmabuf.h> #include <wlr/types/wlr_output.h> #include "wlr-export-dmabuf-unstable-v1-protocol.h" #include <wlr/util/log.h> diff --git a/types/wlr_input_device.c b/types/wlr_input_device.c index 3a8fc582..89ca13cb 100644 --- a/types/wlr_input_device.c +++ b/types/wlr_input_device.c @@ -44,7 +44,7 @@ void wlr_input_device_destroy(struct wlr_input_device *dev) { wlr_touch_destroy(dev->touch); break; case WLR_INPUT_DEVICE_TABLET_TOOL: - wlr_tablet_tool_destroy(dev->tablet_tool); + wlr_tablet_destroy(dev->tablet); break; case WLR_INPUT_DEVICE_TABLET_PAD: wlr_tablet_pad_destroy(dev->tablet_pad); diff --git a/types/wlr_keyboard.c b/types/wlr_keyboard.c index e941e8d1..3a4f5f67 100644 --- a/types/wlr_keyboard.c +++ b/types/wlr_keyboard.c @@ -1,3 +1,4 @@ +#include "util/array.h" #include <assert.h> #include <stdlib.h> #include <string.h> @@ -58,25 +59,6 @@ static bool keyboard_modifier_update(struct wlr_keyboard *keyboard) { return true; } -// https://www.geeksforgeeks.org/move-zeroes-end-array/ -static size_t push_zeroes_to_end(uint32_t arr[], size_t n) { - size_t count = 0; - - for (size_t i = 0; i < n; i++) { - if (arr[i] != 0) { - arr[count++] = arr[i]; - } - } - - size_t ret = count; - - while (count < n) { - arr[count++] = 0; - } - - return ret; -} - static void keyboard_key_update(struct wlr_keyboard *keyboard, struct wlr_event_keyboard_key *event) { bool found = false; diff --git a/types/wlr_linux_dmabuf.c b/types/wlr_linux_dmabuf_v1.c index 2d5259d8..f72e7c07 100644 --- a/types/wlr_linux_dmabuf.c +++ b/types/wlr_linux_dmabuf_v1.c @@ -4,7 +4,7 @@ #include <unistd.h> #include <wayland-server.h> #include <wlr/render/wlr_renderer.h> -#include <wlr/types/wlr_linux_dmabuf.h> +#include <wlr/types/wlr_linux_dmabuf_v1.h> #include <wlr/util/log.h> #include "linux-dmabuf-unstable-v1-protocol.h" #include "util/signal.h" @@ -20,13 +20,13 @@ static const struct wl_buffer_interface buffer_impl = { .destroy = buffer_handle_destroy, }; -bool wlr_dmabuf_resource_is_buffer(struct wl_resource *buffer_resource) { +bool wlr_dmabuf_v1_resource_is_buffer(struct wl_resource *buffer_resource) { if (!wl_resource_instance_of(buffer_resource, &wl_buffer_interface, &buffer_impl)) { return false; } - struct wlr_dmabuf_buffer *buffer = + struct wlr_dmabuf_v1_buffer *buffer = wl_resource_get_user_data(buffer_resource); if (buffer && buffer->buffer_resource && !buffer->params_resource && buffer->buffer_resource == buffer_resource) { @@ -36,12 +36,12 @@ bool wlr_dmabuf_resource_is_buffer(struct wl_resource *buffer_resource) { return false; } -struct wlr_dmabuf_buffer *wlr_dmabuf_buffer_from_buffer_resource( +struct wlr_dmabuf_v1_buffer *wlr_dmabuf_v1_buffer_from_buffer_resource( struct wl_resource *buffer_resource) { assert(wl_resource_instance_of(buffer_resource, &wl_buffer_interface, &buffer_impl)); - struct wlr_dmabuf_buffer *buffer = + struct wlr_dmabuf_v1_buffer *buffer = wl_resource_get_user_data(buffer_resource); assert(buffer); assert(buffer->buffer_resource); @@ -51,7 +51,7 @@ struct wlr_dmabuf_buffer *wlr_dmabuf_buffer_from_buffer_resource( return buffer; } -static void linux_dmabuf_buffer_destroy(struct wlr_dmabuf_buffer *buffer) { +static void linux_dmabuf_buffer_destroy(struct wlr_dmabuf_v1_buffer *buffer) { wlr_dmabuf_attributes_finish(&buffer->attributes); free(buffer); } @@ -65,8 +65,8 @@ static void params_add(struct wl_client *client, struct wl_resource *params_resource, int32_t fd, uint32_t plane_idx, uint32_t offset, uint32_t stride, uint32_t modifier_hi, uint32_t modifier_lo) { - struct wlr_dmabuf_buffer *buffer = - wlr_dmabuf_buffer_from_params_resource(params_resource); + struct wlr_dmabuf_v1_buffer *buffer = + wlr_dmabuf_v1_buffer_from_params_resource(params_resource); if (!buffer) { wl_resource_post_error(params_resource, @@ -113,12 +113,12 @@ static void params_add(struct wl_client *client, } static void buffer_handle_resource_destroy(struct wl_resource *buffer_resource) { - struct wlr_dmabuf_buffer *buffer = - wlr_dmabuf_buffer_from_buffer_resource(buffer_resource); + struct wlr_dmabuf_v1_buffer *buffer = + wlr_dmabuf_v1_buffer_from_buffer_resource(buffer_resource); linux_dmabuf_buffer_destroy(buffer); } -static bool check_import_dmabuf(struct wlr_dmabuf_buffer *buffer) { +static bool check_import_dmabuf(struct wlr_dmabuf_v1_buffer *buffer) { struct wlr_texture *texture = wlr_texture_from_dmabuf(buffer->renderer, &buffer->attributes); if (texture == NULL) { @@ -140,8 +140,8 @@ static void params_create_common(struct wl_client *client, "params was already used to create a wl_buffer"); return; } - struct wlr_dmabuf_buffer *buffer = - wlr_dmabuf_buffer_from_params_resource(params_resource); + struct wlr_dmabuf_v1_buffer *buffer = + wlr_dmabuf_v1_buffer_from_params_resource(params_resource); /* Switch the linux_dmabuf_buffer object from params resource to * eventually wl_buffer resource. */ @@ -302,13 +302,13 @@ static const struct zwp_linux_buffer_params_v1_interface .create_immed = params_create_immed, }; -struct wlr_dmabuf_buffer *wlr_dmabuf_buffer_from_params_resource( +struct wlr_dmabuf_v1_buffer *wlr_dmabuf_v1_buffer_from_params_resource( struct wl_resource *params_resource) { assert(wl_resource_instance_of(params_resource, &zwp_linux_buffer_params_v1_interface, &linux_buffer_params_impl)); - struct wlr_dmabuf_buffer *buffer = + struct wlr_dmabuf_v1_buffer *buffer = wl_resource_get_user_data(params_resource); assert(buffer); assert(buffer->params_resource); @@ -319,24 +319,24 @@ struct wlr_dmabuf_buffer *wlr_dmabuf_buffer_from_params_resource( } static void handle_params_destroy(struct wl_resource *params_resource) { - /* Check for NULL since wlr_dmabuf_buffer_from_params_resource will choke */ + /* Check for NULL since wlr_dmabuf_v1_buffer_from_params_resource will choke */ if (!wl_resource_get_user_data(params_resource)) { return; } - struct wlr_dmabuf_buffer *buffer = - wlr_dmabuf_buffer_from_params_resource(params_resource); + struct wlr_dmabuf_v1_buffer *buffer = + wlr_dmabuf_v1_buffer_from_params_resource(params_resource); linux_dmabuf_buffer_destroy(buffer); } static void linux_dmabuf_create_params(struct wl_client *client, struct wl_resource *linux_dmabuf_resource, uint32_t params_id) { - struct wlr_linux_dmabuf *linux_dmabuf = - wlr_linux_dmabuf_from_resource(linux_dmabuf_resource); + struct wlr_linux_dmabuf_v1 *linux_dmabuf = + wlr_linux_dmabuf_v1_from_resource(linux_dmabuf_resource); uint32_t version = wl_resource_get_version(linux_dmabuf_resource); - struct wlr_dmabuf_buffer *buffer = calloc(1, sizeof *buffer); + struct wlr_dmabuf_v1_buffer *buffer = calloc(1, sizeof *buffer); if (!buffer) { goto err; } @@ -372,17 +372,17 @@ static const struct zwp_linux_dmabuf_v1_interface linux_dmabuf_impl = { .create_params = linux_dmabuf_create_params, }; -struct wlr_linux_dmabuf *wlr_linux_dmabuf_from_resource( +struct wlr_linux_dmabuf_v1 *wlr_linux_dmabuf_v1_from_resource( struct wl_resource *resource) { assert(wl_resource_instance_of(resource, &zwp_linux_dmabuf_v1_interface, &linux_dmabuf_impl)); - struct wlr_linux_dmabuf *dmabuf = wl_resource_get_user_data(resource); + struct wlr_linux_dmabuf_v1 *dmabuf = wl_resource_get_user_data(resource); assert(dmabuf); return dmabuf; } -static void linux_dmabuf_send_modifiers(struct wlr_linux_dmabuf *linux_dmabuf, +static void linux_dmabuf_send_modifiers(struct wlr_linux_dmabuf_v1 *linux_dmabuf, struct wl_resource *resource) { struct wlr_renderer *renderer = linux_dmabuf->renderer; /* @@ -428,7 +428,7 @@ static void linux_dmabuf_resource_destroy(struct wl_resource *resource) { static void linux_dmabuf_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id) { - struct wlr_linux_dmabuf *linux_dmabuf = data; + struct wlr_linux_dmabuf_v1 *linux_dmabuf = data; struct wl_resource *resource = wl_resource_create(client, &zwp_linux_dmabuf_v1_interface, version, id); @@ -445,7 +445,7 @@ static void linux_dmabuf_bind(struct wl_client *client, void *data, } } -void wlr_linux_dmabuf_destroy(struct wlr_linux_dmabuf *linux_dmabuf) { +void wlr_linux_dmabuf_v1_destroy(struct wlr_linux_dmabuf_v1 *linux_dmabuf) { if (!linux_dmabuf) { return; } @@ -465,21 +465,21 @@ void wlr_linux_dmabuf_destroy(struct wlr_linux_dmabuf *linux_dmabuf) { } static void handle_display_destroy(struct wl_listener *listener, void *data) { - struct wlr_linux_dmabuf *linux_dmabuf = + struct wlr_linux_dmabuf_v1 *linux_dmabuf = wl_container_of(listener, linux_dmabuf, display_destroy); - wlr_linux_dmabuf_destroy(linux_dmabuf); + wlr_linux_dmabuf_v1_destroy(linux_dmabuf); } static void handle_renderer_destroy(struct wl_listener *listener, void *data) { - struct wlr_linux_dmabuf *linux_dmabuf = + struct wlr_linux_dmabuf_v1 *linux_dmabuf = wl_container_of(listener, linux_dmabuf, renderer_destroy); - wlr_linux_dmabuf_destroy(linux_dmabuf); + wlr_linux_dmabuf_v1_destroy(linux_dmabuf); } -struct wlr_linux_dmabuf *wlr_linux_dmabuf_create(struct wl_display *display, +struct wlr_linux_dmabuf_v1 *wlr_linux_dmabuf_v1_create(struct wl_display *display, struct wlr_renderer *renderer) { - struct wlr_linux_dmabuf *linux_dmabuf = - calloc(1, sizeof(struct wlr_linux_dmabuf)); + struct wlr_linux_dmabuf_v1 *linux_dmabuf = + calloc(1, sizeof(struct wlr_linux_dmabuf_v1)); if (linux_dmabuf == NULL) { wlr_log(WLR_ERROR, "could not create simple dmabuf manager"); return NULL; diff --git a/types/wlr_output.c b/types/wlr_output.c index 35b8c416..a1d00c0c 100644 --- a/types/wlr_output.c +++ b/types/wlr_output.c @@ -817,11 +817,6 @@ static void output_cursor_handle_destroy(struct wl_listener *listener, void wlr_output_cursor_set_surface(struct wlr_output_cursor *cursor, struct wlr_surface *surface, int32_t hotspot_x, int32_t hotspot_y) { - if (surface && !wlr_surface_is_pointer_cursor(surface)) { - wlr_log(WLR_ERROR, "Tried to set a cursor surface with invalid role"); - return; - } - hotspot_x *= cursor->output->scale; hotspot_y *= cursor->output->scale; diff --git a/types/wlr_tablet_pad.c b/types/wlr_tablet_pad.c index 3d25d685..804d6910 100644 --- a/types/wlr_tablet_pad.c +++ b/types/wlr_tablet_pad.c @@ -10,10 +10,18 @@ void wlr_tablet_pad_init(struct wlr_tablet_pad *pad, wl_signal_init(&pad->events.button); wl_signal_init(&pad->events.ring); wl_signal_init(&pad->events.strip); + wl_signal_init(&pad->events.attach_tablet); } void wlr_tablet_pad_destroy(struct wlr_tablet_pad *pad) { - if (pad && pad->impl && pad->impl->destroy) { + if (!pad) { + return; + } + + wlr_list_for_each(&pad->paths, free); + wlr_list_finish(&pad->paths); + + if (pad->impl && pad->impl->destroy) { pad->impl->destroy(pad); } else { free(pad); diff --git a/types/wlr_tablet_tool.c b/types/wlr_tablet_tool.c index f46a5434..ca92d4e2 100644 --- a/types/wlr_tablet_tool.c +++ b/types/wlr_tablet_tool.c @@ -4,22 +4,26 @@ #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) { - tool->impl = impl; - wl_signal_init(&tool->events.axis); - wl_signal_init(&tool->events.proximity); - wl_signal_init(&tool->events.tip); - wl_signal_init(&tool->events.button); +void wlr_tablet_init(struct wlr_tablet *tablet, + struct wlr_tablet_impl *impl) { + tablet->impl = impl; + wl_signal_init(&tablet->events.axis); + wl_signal_init(&tablet->events.proximity); + wl_signal_init(&tablet->events.tip); + wl_signal_init(&tablet->events.button); } -void wlr_tablet_tool_destroy(struct wlr_tablet_tool *tool) { - if (!tool) { +void wlr_tablet_destroy(struct wlr_tablet *tablet) { + if (!tablet) { return; } - if (tool->impl && tool->impl->destroy) { - tool->impl->destroy(tool); + + wlr_list_for_each(&tablet->paths, free); + wlr_list_finish(&tablet->paths); + + if (tablet->impl && tablet->impl->destroy) { + tablet->impl->destroy(tablet); } else { - free(tool); + free(tablet); } } diff --git a/types/xdg_shell/wlr_xdg_toplevel.c b/types/xdg_shell/wlr_xdg_toplevel.c index 67f18025..3bf7fd67 100644 --- a/types/xdg_shell/wlr_xdg_toplevel.c +++ b/types/xdg_shell/wlr_xdg_toplevel.c @@ -234,6 +234,7 @@ static void xdg_toplevel_handle_set_title(struct wl_client *client, free(surface->toplevel->title); surface->toplevel->title = tmp; + wlr_signal_emit_safe(&surface->toplevel->events.set_title, surface); } static void xdg_toplevel_handle_set_app_id(struct wl_client *client, @@ -249,6 +250,7 @@ static void xdg_toplevel_handle_set_app_id(struct wl_client *client, free(surface->toplevel->app_id); surface->toplevel->app_id = tmp; + wlr_signal_emit_safe(&surface->toplevel->events.set_app_id, surface); } static void xdg_toplevel_handle_show_window_menu(struct wl_client *client, @@ -472,6 +474,8 @@ void create_xdg_toplevel(struct wlr_xdg_surface *xdg_surface, wl_signal_init(&xdg_surface->toplevel->events.request_resize); wl_signal_init(&xdg_surface->toplevel->events.request_show_window_menu); wl_signal_init(&xdg_surface->toplevel->events.set_parent); + wl_signal_init(&xdg_surface->toplevel->events.set_title); + wl_signal_init(&xdg_surface->toplevel->events.set_app_id); xdg_surface->role = WLR_XDG_SURFACE_ROLE_TOPLEVEL; xdg_surface->toplevel->base = xdg_surface; diff --git a/types/xdg_shell_v6/wlr_xdg_toplevel_v6.c b/types/xdg_shell_v6/wlr_xdg_toplevel_v6.c index edde8b62..297f49f5 100644 --- a/types/xdg_shell_v6/wlr_xdg_toplevel_v6.c +++ b/types/xdg_shell_v6/wlr_xdg_toplevel_v6.c @@ -57,6 +57,7 @@ static void xdg_toplevel_handle_set_title(struct wl_client *client, free(surface->toplevel->title); surface->toplevel->title = tmp; + wlr_signal_emit_safe(&surface->toplevel->events.set_title, surface); } static void xdg_toplevel_handle_set_app_id(struct wl_client *client, @@ -71,6 +72,7 @@ static void xdg_toplevel_handle_set_app_id(struct wl_client *client, free(surface->toplevel->app_id); surface->toplevel->app_id = tmp; + wlr_signal_emit_safe(&surface->toplevel->events.set_app_id, surface); } static void xdg_toplevel_handle_show_window_menu(struct wl_client *client, @@ -442,6 +444,8 @@ void create_xdg_toplevel_v6(struct wlr_xdg_surface_v6 *xdg_surface, wl_signal_init(&xdg_surface->toplevel->events.request_resize); wl_signal_init(&xdg_surface->toplevel->events.request_show_window_menu); wl_signal_init(&xdg_surface->toplevel->events.set_parent); + wl_signal_init(&xdg_surface->toplevel->events.set_title); + wl_signal_init(&xdg_surface->toplevel->events.set_app_id); xdg_surface->role = WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL; xdg_surface->toplevel->base = xdg_surface; diff --git a/util/array.c b/util/array.c new file mode 100644 index 00000000..9ee39d33 --- /dev/null +++ b/util/array.c @@ -0,0 +1,21 @@ +#include <stdlib.h> +#include <stdint.h> + +// https://www.geeksforgeeks.org/move-zeroes-end-array/ +size_t push_zeroes_to_end(uint32_t arr[], size_t n) { + size_t count = 0; + + for (size_t i = 0; i < n; i++) { + if (arr[i] != 0) { + arr[count++] = arr[i]; + } + } + + size_t ret = count; + + while (count < n) { + arr[count++] = 0; + } + + return ret; +} diff --git a/util/meson.build b/util/meson.build index adc52a53..f9d1997d 100644 --- a/util/meson.build +++ b/util/meson.build @@ -1,6 +1,7 @@ lib_wlr_util = static_library( 'wlr_util', files( + 'array.c', 'log.c', 'os-compatibility.c', 'region.c', diff --git a/util/os-compatibility.c b/util/os-compatibility.c index 38333605..bd39705d 100644 --- a/util/os-compatibility.c +++ b/util/os-compatibility.c @@ -23,7 +23,7 @@ * SOFTWARE. */ -#define _XOPEN_SOURCE 700 +#define _POSIX_C_SOURCE 200809L #include <errno.h> #include <fcntl.h> #include <stdlib.h> @@ -32,20 +32,22 @@ #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> +#include <wlr/config.h> #include "util/os-compatibility.h" int os_fd_set_cloexec(int fd) { - long flags; - - if (fd == -1) + if (fd == -1) { return -1; + } - flags = fcntl(fd, F_GETFD); - if (flags == -1) + long flags = fcntl(fd, F_GETFD); + if (flags == -1) { return -1; + } - if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) + if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) { return -1; + } return 0; } @@ -58,15 +60,14 @@ int set_cloexec_or_close(int fd) { return fd; } -int create_tmpfile_cloexec(char *tmpname) -{ +int create_tmpfile_cloexec(char *tmpname) { int fd; - mode_t prev_umask = umask(0066); #ifdef HAVE_MKOSTEMP fd = mkostemp(tmpname, O_CLOEXEC); - if (fd >= 0) + if (fd >= 0) { unlink(tmpname); + } #else fd = mkstemp(tmpname); if (fd >= 0) { @@ -102,32 +103,29 @@ int create_tmpfile_cloexec(char *tmpname) */ int os_create_anonymous_file(off_t size) { static const char template[] = "/wlroots-shared-XXXXXX"; - const char *path; - char *name; - int fd; - int ret; - path = getenv("XDG_RUNTIME_DIR"); + const char *path = getenv("XDG_RUNTIME_DIR"); if (!path) { errno = ENOENT; return -1; } - name = malloc(strlen(path) + sizeof(template)); - if (!name) + char *name = malloc(strlen(path) + sizeof(template)); + if (!name) { return -1; + } strcpy(name, path); strcat(name, template); - fd = create_tmpfile_cloexec(name); - + int fd = create_tmpfile_cloexec(name); free(name); - - if (fd < 0) + if (fd < 0) { return -1; + } -#ifdef HAVE_POSIX_FALLOCATE +#ifdef WLR_HAS_POSIX_FALLOCATE + int ret; do { ret = posix_fallocate(fd, 0, size); } while (ret == EINTR); @@ -137,6 +135,7 @@ int os_create_anonymous_file(off_t size) { return -1; } #else + int ret; do { ret = ftruncate(fd, size); } while (ret < 0 && errno == EINTR); diff --git a/wlroots.syms b/wlroots.syms index ba085d0f..3176f874 100644 --- a/wlroots.syms +++ b/wlroots.syms @@ -1,4 +1,4 @@ -WLROOTS_0_0_0 { +{ global: wlr_*; _wlr_log; diff --git a/xwayland/xwm.c b/xwayland/xwm.c index 54cb88d0..7999480a 100644 --- a/xwayland/xwm.c +++ b/xwayland/xwm.c @@ -154,6 +154,8 @@ static struct wlr_xwayland_surface *xwayland_surface_create( wl_signal_init(&surface->events.set_parent); wl_signal_init(&surface->events.set_pid); wl_signal_init(&surface->events.set_window_type); + wl_signal_init(&surface->events.set_hints); + wl_signal_init(&surface->events.set_override_redirect); wl_signal_init(&surface->events.ping_timeout); xcb_get_geometry_reply_t *geometry_reply = @@ -240,8 +242,7 @@ static void xwm_send_focus_window(struct wlr_xwm *xwm, XCB_CONFIG_WINDOW_STACK_MODE, values); } - -void xwm_surface_activate(struct wlr_xwm *xwm, +static void xwm_surface_activate(struct wlr_xwm *xwm, struct wlr_xwayland_surface *xsurface) { if (xwm->focus_surface == xsurface || (xsurface && xsurface->override_redirect)) { @@ -492,6 +493,7 @@ static void read_surface_hints(struct wlr_xwm *xwm, xsurface->hints_urgency = xcb_icccm_wm_hints_get_urgency(&hints); wlr_log(WLR_DEBUG, "WM_HINTS (%d)", reply->value_len); + wlr_signal_emit_safe(&xsurface->events.set_hints, xsurface); } #else static void read_surface_hints(struct wlr_xwm *xwm, @@ -782,9 +784,7 @@ static void xwm_handle_configure_request(struct wlr_xwm *xwm, static void xwm_handle_configure_notify(struct wlr_xwm *xwm, xcb_configure_notify_event_t *ev) { - struct wlr_xwayland_surface *xsurface = - lookup_surface(xwm, ev->window); - + struct wlr_xwayland_surface *xsurface = lookup_surface(xwm, ev->window); if (!xsurface) { return; } @@ -793,6 +793,11 @@ static void xwm_handle_configure_notify(struct wlr_xwm *xwm, xsurface->y = ev->y; xsurface->width = ev->width; xsurface->height = ev->height; + + if (xsurface->override_redirect != ev->override_redirect) { + xsurface->override_redirect = ev->override_redirect; + wlr_signal_emit_safe(&xsurface->events.set_override_redirect, xsurface); + } } #define ICCCM_WITHDRAWN_STATE 0 @@ -832,6 +837,15 @@ static void xwm_handle_map_request(struct wlr_xwm *xwm, static void xwm_handle_map_notify(struct wlr_xwm *xwm, xcb_map_notify_event_t *ev) { wlr_log(WLR_DEBUG, "XCB_MAP_NOTIFY (%u)", ev->window); + struct wlr_xwayland_surface *xsurface = lookup_surface(xwm, ev->window); + if (!xsurface) { + return; + } + + if (xsurface->override_redirect != ev->override_redirect) { + xsurface->override_redirect = ev->override_redirect; + wlr_signal_emit_safe(&xsurface->events.set_override_redirect, xsurface); + } } static void xwm_handle_unmap_notify(struct wlr_xwm *xwm, @@ -1677,30 +1691,6 @@ bool xwm_atoms_contains(struct wlr_xwm *xwm, xcb_atom_t *atoms, return false; } -bool wlr_xwayland_surface_is_unmanaged( - const struct wlr_xwayland_surface *surface) { - static enum atom_name needles[] = { - NET_WM_WINDOW_TYPE_COMBO, - NET_WM_WINDOW_TYPE_DND, - NET_WM_WINDOW_TYPE_DROPDOWN_MENU, - NET_WM_WINDOW_TYPE_MENU, - NET_WM_WINDOW_TYPE_NOTIFICATION, - NET_WM_WINDOW_TYPE_POPUP_MENU, - NET_WM_WINDOW_TYPE_SPLASH, - NET_WM_WINDOW_TYPE_TOOLTIP, - NET_WM_WINDOW_TYPE_UTILITY, - }; - - for (size_t i = 0; i < sizeof(needles) / sizeof(needles[0]); ++i) { - if (xwm_atoms_contains(surface->xwm, surface->window_type, - surface->window_type_len, needles[i])) { - return true; - } - } - - return false; -} - void wlr_xwayland_surface_ping(struct wlr_xwayland_surface *surface) { xcb_client_message_data_t data = { 0 }; data.data32[0] = surface->xwm->atoms[_NET_WM_PING]; |