From 000b305eccb8d732aa2bde5f4b2f126c23e574cf Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Tue, 17 Apr 2018 19:09:42 +0200 Subject: backend/libinput: Manage tablet tool livetimes This adds the management code to manage tablet tools lifetimes from libinput. It follows the suggestion made in the tablet-unstable-v2.xml to destroy tablet_tools once all tablets that it got into contact with were removed from the system. This is implemented via a refcount. If a tool is *not* unique, it will be destroyed on proximity out. This is libinput specific and mentioned in libinput docs that tools will not be found again, so we shouldn't keep a reference to them. Also they can't be on other tablets as well, because they cannot be tracked. The naming in this commit is a bit off (to not break things). The wlr names stay the same, tablet_tool is the libinput_device with capaiblity LIBINPUT_DEVICE_CAP_TABLET_TOOL which is more akin to "tablet" in the tablet-unstable-v2 protocol. The struct that corresponds to the tablet_tool in tablet-unstable-v2 is called tablet_tool_tool, a rename should be done at some point in the future. --- backend/libinput/tablet_tool.c | 179 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 178 insertions(+), 1 deletion(-) (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index e9308b65..bae7780f 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -8,7 +9,57 @@ #include "backend/libinput.h" #include "util/signal.h" -struct wlr_tablet_tool *create_libinput_tablet_tool( +struct wlr_libinput_tablet_tool { + struct wlr_tablet_tool_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_tool wlr_tool; + + struct wl_list tools; // tablet_tool_list_elem::link +}; + +static void destroy_tool_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); +} + + +void wlr_libinput_tablet_tool_destroy(struct wlr_input_device *wlr_dev) { + struct wlr_libinput_tablet *tablet = + wl_container_of(wlr_dev->tablet_tool, tablet, wlr_tool); + + struct tablet_tool_list_elem *pos; + struct tablet_tool_list_elem *tmp; + wl_list_for_each_safe(pos, tmp, &tablet->tools, link) { + wl_list_remove(&pos->link); + struct wlr_libinput_tablet_tool *tool = pos->tool; + + if (--tool->pad_refs == 0) { + destroy_tool_tool(tool); + } + + free(pos); + } +} + +struct wlr_tablet_tool *wlr_libinput_tablet_tool_create( struct libinput_device *libinput_dev) { assert(libinput_dev); struct wlr_tablet_tool *wlr_tablet_tool = calloc(1, sizeof(struct wlr_tablet_tool)); @@ -20,6 +71,91 @@ struct wlr_tablet_tool *create_libinput_tablet_tool( return wlr_tablet_tool; } +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_tool *wlr_dev) { + struct tablet_tool_list_elem *pos; + struct wlr_libinput_tablet *tablet = wl_container_of(wlr_dev, tablet, wlr_tool); + + 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) {// TODO: Should we at least log? + return; + } + + new->tool = tool; + wl_list_insert(&tablet->tools, &new->link); + ++tool->pad_refs; +} + void handle_tablet_tool_axis(struct libinput_event *event, struct libinput_device *libinput_dev) { struct wlr_input_device *wlr_dev = @@ -31,7 +167,12 @@ 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_tool); + 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)) { @@ -84,6 +225,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_tool); + + 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)); @@ -97,6 +243,27 @@ void handle_tablet_tool_proximity(struct libinput_event *event, break; } wlr_signal_emit_safe(&wlr_dev->tablet_tool->events.proximity, &wlr_event); + + // If the tool is not unique, libinput will not find it again after the + // proximity out, so we should destroy it + if (!tool->unique) { + // The tool isn't unique, it can't be on multiple tablets + assert(tool->pad_refs == 1); + struct wlr_libinput_tablet *tablet = + wl_container_of(wlr_dev->tablet_tool, tablet, wlr_tool); + 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(tool); + } } void handle_tablet_tool_tip(struct libinput_event *event, @@ -111,7 +278,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_tool); + 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)) { @@ -137,7 +309,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_tool); + 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); -- cgit v1.2.3 From 77bac448ccac9827abfa2ab10e798295f07f3980 Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Mon, 23 Apr 2018 08:55:49 +0200 Subject: storage commit #2 --- backend/libinput/tablet_pad.c | 71 ++++++++++++- backend/libinput/tablet_tool.c | 24 ++++- include/wlr/types/wlr_tablet_pad.h | 22 ++++ include/wlr/types/wlr_tablet_tool.h | 8 ++ types/wlr_tablet_v2.c | 199 +++--------------------------------- 5 files changed, 137 insertions(+), 187 deletions(-) (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/tablet_pad.c b/backend/libinput/tablet_pad.c index 626c2219..ed5374c6 100644 --- a/backend/libinput/tablet_pad.c +++ b/backend/libinput/tablet_pad.c @@ -8,7 +8,60 @@ #include "backend/libinput.h" #include "util/signal.h" -struct wlr_tablet_pad *create_libinput_tablet_pad( +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_v2 *group = + calloc(1, sizeof(struct wlr_tablet_pad_group_v2)); + 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 *libinput_tablet_pad_create( struct libinput_device *libinput_dev) { assert(libinput_dev); struct wlr_tablet_pad *wlr_tablet_pad = calloc(1, sizeof(struct wlr_tablet_pad)); @@ -16,6 +69,22 @@ 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); + + //struct udev_device *udev = libinput_device_get_udev_device(libinput_dev); + //add_tablet_path(&pad->paths, udev_device_get_syspath(udev)); + + 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; } diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index bae7780f..6c48dcf0 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -1,3 +1,7 @@ +#ifndef _POSIX_C_SOURCE +#define _POSIX_C_SOURCE 200809L +#endif +#include #include #include #include @@ -9,6 +13,18 @@ #include "backend/libinput.h" #include "util/signal.h" +//TODO: Move out +static void add_tablet_path(struct wl_list *list, const char *path) { + struct wlr_tablet_path *tablet_path = calloc(1, sizeof(struct wlr_tablet_path)); + + if (!tablet_path) { + return; + } + + tablet_path->path = strdup(path); + wl_list_insert(list, &tablet_path->link); +} + struct wlr_libinput_tablet_tool { struct wlr_tablet_tool_tool wlr_tool; @@ -59,7 +75,7 @@ void wlr_libinput_tablet_tool_destroy(struct wlr_input_device *wlr_dev) { } } -struct wlr_tablet_tool *wlr_libinput_tablet_tool_create( +struct wlr_tablet_tool *libinput_tablet_tool_create( struct libinput_device *libinput_dev) { assert(libinput_dev); struct wlr_tablet_tool *wlr_tablet_tool = calloc(1, sizeof(struct wlr_tablet_tool)); @@ -67,6 +83,12 @@ struct wlr_tablet_tool *wlr_libinput_tablet_tool_create( wlr_log(WLR_ERROR, "Unable to allocate wlr_tablet_tool"); return NULL; } + + struct udev_device *udev = libinput_device_get_udev_device(libinput_dev); + add_tablet_path(&wlr_tablet_tool->paths, udev_device_get_syspath(udev)); + wlr_tablet_tool->name = strdup(libinput_device_get_name(libinput_dev)); + + wlr_tablet_tool_init(wlr_tablet_tool, NULL); return wlr_tablet_tool; } diff --git a/include/wlr/types/wlr_tablet_pad.h b/include/wlr/types/wlr_tablet_pad.h index 73082c56..b633f439 100644 --- a/include/wlr/types/wlr_tablet_pad.h +++ b/include/wlr/types/wlr_tablet_pad.h @@ -22,9 +22,31 @@ struct wlr_tablet_pad { struct wl_signal strip; } events; + size_t button_count; + size_t ring_count; + size_t strip_count; + + struct wl_list groups; // wlr_tablet_pad_group::link + struct wl_list paths; // wlr_tablet_path::link + void *data; }; +struct wlr_tablet_pad_group_v2 { + 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; diff --git a/include/wlr/types/wlr_tablet_tool.h b/include/wlr/types/wlr_tablet_tool.h index 08d37f68..884b486a 100644 --- a/include/wlr/types/wlr_tablet_tool.h +++ b/include/wlr/types/wlr_tablet_tool.h @@ -42,6 +42,11 @@ struct wlr_tablet_tool_tool { struct wlr_tablet_tool_impl; +struct wlr_tablet_path { + struct wl_list link; + char *path; +}; + struct wlr_tablet_tool { struct wlr_tablet_tool_impl *impl; @@ -52,6 +57,9 @@ struct wlr_tablet_tool { struct wl_signal button; } events; + const char *name; + struct wl_list paths; // wlr_table_path::link + void *data; }; diff --git a/types/wlr_tablet_v2.c b/types/wlr_tablet_v2.c index 076975c4..56f4d567 100644 --- a/types/wlr_tablet_v2.c +++ b/types/wlr_tablet_v2.c @@ -15,8 +15,6 @@ struct wlr_tablet_manager_v2 { struct wl_global *wl_global; - struct wl_list tablets; // wlr_tablet_v2::link - struct wl_list pads; // wlr_tablet_pad_v2::link struct wl_list clients; // wlr_tablet_manager_client_v2::link struct wl_listener display_destroy; @@ -36,69 +34,44 @@ struct wlr_tablet_manager_client_v2 { struct wlr_tablet_seat_v2 { struct wl_list link; + struct wl_client *wl_client; struct wl_resource *resource; struct wlr_tablet_manager_client_v2 *client; struct wlr_seat_client *seat; struct wl_listener seat_destroy; + struct wl_listener client_destroy; struct wl_list tools; struct wl_list tablets; struct wl_list pads; //wlr_tablet_pad_client_v2::link }; -struct wlr_tablet_v2 { - struct wl_list link; - struct wl_list resources; - - char *name; - struct wl_list paths; // wlr_tablet_path::link - // USB vendor/product id - unsigned int vid; - unsigned int pid; -}; - -struct wlr_tablet_pad_v2 { - struct wl_list link; - struct wl_list resources; - - struct wlr_tablet_v2 *tablet; - - struct wl_list groups; // wlr_tablet_pad_group::link - struct wl_list paths; // wlr_tablet_path::link - size_t button_count; - size_t ring_count; - size_t strip_count; -}; - -struct wlr_tablet_tool_v2 { +struct wlr_tablet_client_v2 { struct wl_list link; + struct wl_client *client; + struct wl_resource *resource; - enum zwp_tablet_tool_v2_type type; - uint64_t hardware_serial; - uint64_t hardware_wacom; - - // Capabilities - bool tilt; - bool pressure; - bool distance; - bool rotation; - bool slider; - bool wheel; + struct wl_listener device_destroy; + struct wl_listener client_destroy; }; struct wlr_tablet_tool_client_v2 { struct wl_list link; + struct wl_client *client; struct wl_resource *resource; struct wlr_surface *cursor; struct wl_listener cursor_destroy; + + struct wl_listener tool_destroy; + struct wl_listener client_destroy; }; struct wlr_tablet_pad_client_v2 { struct wl_list link; - struct wlr_tablet_pad_v2 *pad; + struct wl_client *client; struct wl_resource *resource; size_t button_count; @@ -108,155 +81,11 @@ struct wlr_tablet_pad_client_v2 { size_t strip_cout; struct wl_resource **strips; -}; - -struct wlr_tablet_pad_group_v2 { - struct wl_list link; - struct wl_list resources; - struct wlr_tablet_pad_v2 *pad; - - 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 wl_listener device_destroy; + struct wl_listener client_destroy; }; -struct wlr_tablet_path { - struct wl_list link; - char *path; -}; - -void add_tablet_path(struct wl_list *list, const char *path) { - struct wlr_tablet_path *tablet_path = calloc(1, sizeof(struct wlr_tablet_path)); - - if (!tablet_path) { - return; - } - - tablet_path->path = strdup(path); - wl_list_insert(list, &tablet_path->link); -} - -void wlr_tablet_destroy(struct wlr_tablet_v2 *tablet) { - wl_list_remove(&tablet->link); - free(tablet->name); - - struct wlr_tablet_path *tmp; - struct wlr_tablet_path *pos; - wl_list_for_each_safe(pos, tmp, &tablet->paths, link) { - free(pos->path); - wl_list_remove(&pos->link); - free(pos); - } - - free(tablet); -} - -static void add_pad_group_from_libinput(struct wlr_tablet_pad_v2 *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_v2 *group = - calloc(1, sizeof(struct wlr_tablet_pad_group_v2)); - 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_v2 *tablet_pad_from_libinput(struct wlr_tablet_manager_v2 *manager, - struct libinput_device *device) { - struct wlr_tablet_pad_v2 *pad = calloc(1, sizeof(struct wlr_tablet_pad_v2)); - if (!pad) { - return NULL; - } - - pad->button_count = libinput_device_tablet_pad_get_num_buttons(device); - pad->ring_count = libinput_device_tablet_pad_get_num_rings(device); - pad->strip_count = libinput_device_tablet_pad_get_num_strips(device); - - struct udev_device *udev = libinput_device_get_udev_device(device); - add_tablet_path(&pad->paths, udev_device_get_syspath(udev)); - - int groups = libinput_device_tablet_pad_get_num_mode_groups(device); - for (int i = 0; i < groups; ++i) { - add_pad_group_from_libinput(pad, device, i); - } - - wl_list_insert(&manager->pads, &pad->link); - return pad; -} - -struct wlr_tablet_v2 *tablet_from_libinput(struct wlr_tablet_manager_v2 *manager, - struct libinput_device *device) { - struct wlr_tablet_v2 *tablet = calloc(1, sizeof(struct wlr_tablet_v2)); - if (!tablet) { - return NULL; - } - - wl_list_init(&tablet->resources); - - tablet->vid = libinput_device_get_id_vendor(device); - tablet->pid = libinput_device_get_id_product(device); - tablet->name = strdup(libinput_device_get_name(device)); - if (!tablet->name) { - free(tablet); - return NULL; - } - - struct udev_device *udev = libinput_device_get_udev_device(device); - add_tablet_path(&tablet->paths, udev_device_get_syspath(udev)); - - wl_list_insert(&manager->tablets, &tablet->link); - return tablet; -} - void wlr_tablet_v2_destroy(struct wlr_tablet_manager_v2 *manager); static struct wlr_tablet_manager_client_v2 *tablet_manager_client_from_resource(struct wl_resource *resource); -- cgit v1.2.3 From e235f7d33621b5879a5f9a8a1d89d4a8515857c3 Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Tue, 24 Apr 2018 08:10:45 +0200 Subject: Basic tablet_v2 object lifetime --- backend/libinput/tablet_pad.c | 28 +- backend/libinput/tablet_tool.c | 12 +- include/rootston/cursor.h | 1 + include/rootston/desktop.h | 1 + include/wlr/types/wlr_tablet_pad.h | 2 +- include/wlr/types/wlr_tablet_tool.h | 2 +- include/wlr/types/wlr_tablet_v2.h | 62 ++++ rootston/desktop.c | 4 + rootston/seat.c | 26 ++ types/wlr_tablet_v2.c | 673 ++++++++++++++++++++++++++++++++++-- 10 files changed, 763 insertions(+), 48 deletions(-) create mode 100644 include/wlr/types/wlr_tablet_v2.h (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/tablet_pad.c b/backend/libinput/tablet_pad.c index ed5374c6..2558d09c 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 +#include #include #include #include @@ -8,12 +12,26 @@ #include "backend/libinput.h" #include "util/signal.h" +//TODO: Move out +static void add_tablet_path(struct wl_list *list, const char *path) { + struct wlr_tablet_path *tablet_path = calloc(1, sizeof(struct wlr_tablet_path)); + + if (!tablet_path) { + return; + } + + tablet_path->path = strdup(path); + assert(tablet_path->path); + wl_list_insert(list, &tablet_path->link); +} + +// 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_v2 *group = - calloc(1, sizeof(struct wlr_tablet_pad_group_v2)); + struct wlr_tablet_pad_group *group = + calloc(1, sizeof(struct wlr_tablet_pad_group)); if (!group) { return; } @@ -77,9 +95,11 @@ struct wlr_tablet_pad *libinput_tablet_pad_create( wlr_tablet_pad->strip_count = libinput_device_tablet_pad_get_num_strips(libinput_dev); - //struct udev_device *udev = libinput_device_get_udev_device(libinput_dev); - //add_tablet_path(&pad->paths, udev_device_get_syspath(udev)); + wl_list_init(&wlr_tablet_pad->paths); + struct udev_device *udev = libinput_device_get_udev_device(libinput_dev); + add_tablet_path(&wlr_tablet_pad->paths, 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); diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index 6c48dcf0..f69e41f8 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -64,30 +64,32 @@ void wlr_libinput_tablet_tool_destroy(struct wlr_input_device *wlr_dev) { struct tablet_tool_list_elem *pos; struct tablet_tool_list_elem *tmp; wl_list_for_each_safe(pos, tmp, &tablet->tools, link) { - wl_list_remove(&pos->link); struct wlr_libinput_tablet_tool *tool = pos->tool; + wl_list_remove(&pos->link); + free(pos); if (--tool->pad_refs == 0) { destroy_tool_tool(tool); } - - free(pos); } } struct wlr_tablet_tool *libinput_tablet_tool_create( struct libinput_device *libinput_dev) { assert(libinput_dev); - struct wlr_tablet_tool *wlr_tablet_tool = calloc(1, sizeof(struct wlr_tablet_tool)); + struct wlr_libinput_tablet *libinput_tablet_tool = + calloc(1, sizeof(struct wlr_libinput_tablet)); + struct wlr_tablet_tool *wlr_tablet_tool = &libinput_tablet_tool->wlr_tool; if (!wlr_tablet_tool) { wlr_log(WLR_ERROR, "Unable to allocate wlr_tablet_tool"); return NULL; } + wl_list_init(&wlr_tablet_tool->paths); struct udev_device *udev = libinput_device_get_udev_device(libinput_dev); add_tablet_path(&wlr_tablet_tool->paths, udev_device_get_syspath(udev)); wlr_tablet_tool->name = strdup(libinput_device_get_name(libinput_dev)); - + wl_list_init(&libinput_tablet_tool->tools); wlr_tablet_tool_init(wlr_tablet_tool, NULL); return wlr_tablet_tool; diff --git a/include/rootston/cursor.h b/include/rootston/cursor.h index a1a466c2..0478c3ca 100644 --- a/include/rootston/cursor.h +++ b/include/rootston/cursor.h @@ -40,6 +40,7 @@ struct roots_cursor { struct wl_listener tool_axis; struct wl_listener tool_tip; + struct wl_listener tool_proximity; struct wl_listener request_set_cursor; }; diff --git a/include/rootston/desktop.h b/include/rootston/desktop.h index 88c5ca90..d9add26a 100644 --- a/include/rootston/desktop.h +++ b/include/rootston/desktop.h @@ -56,6 +56,7 @@ struct roots_desktop { 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/wlr/types/wlr_tablet_pad.h b/include/wlr/types/wlr_tablet_pad.h index b633f439..b71f5b9a 100644 --- a/include/wlr/types/wlr_tablet_pad.h +++ b/include/wlr/types/wlr_tablet_pad.h @@ -32,7 +32,7 @@ struct wlr_tablet_pad { void *data; }; -struct wlr_tablet_pad_group_v2 { +struct wlr_tablet_pad_group { struct wl_list link; size_t button_count; diff --git a/include/wlr/types/wlr_tablet_tool.h b/include/wlr/types/wlr_tablet_tool.h index 884b486a..114ce98a 100644 --- a/include/wlr/types/wlr_tablet_tool.h +++ b/include/wlr/types/wlr_tablet_tool.h @@ -17,7 +17,7 @@ enum wlr_tablet_tool_type { 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 */ + WLR_TABLET_TOOL_TYPE_LENS, /**< A mouse tool with a lens */ }; struct wlr_tablet_tool_tool { diff --git a/include/wlr/types/wlr_tablet_v2.h b/include/wlr/types/wlr_tablet_v2.h new file mode 100644 index 00000000..358f0719 --- /dev/null +++ b/include/wlr/types/wlr_tablet_v2.h @@ -0,0 +1,62 @@ +#ifndef WLR_TYPES_WLR_TABLET_V2_H +#define WLR_TYPES_WLR_TABLET_V2_H + +#include +#include +#include + +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_tool *wlr_tool; + struct wlr_input_device *wlr_device; + struct wl_list clients; // wlr_tablet_client_v2::tablet_link + + struct wl_listener tool_destroy; +}; + +struct wlr_tablet_v2_tablet_tool { + struct wl_list link; // wlr_tablet_seat_v2::tablets + struct wlr_tablet_tool_tool *wlr_tool; + struct wl_list clients; // wlr_tablet_tool_client_v2::tablet_link + + struct wl_listener tool_destroy; +}; + +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::tablet_link + + struct wl_listener pad_destroy; +}; + +struct wlr_tablet_v2_tablet *wlr_make_tablet( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat, + struct wlr_input_device *wlr_device); + +struct wlr_tablet_v2_tablet_pad *wlr_make_tablet_pad( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat, + struct wlr_input_device *wlr_device); + +struct wlr_tablet_v2_tablet_tool *wlr_make_tablet_tool( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat, + struct wlr_tablet_tool_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); + +#endif /* WLR_TYPES_WLR_TABLET_V2_H */ diff --git a/rootston/desktop.c b/rootston/desktop.c index 563c5938..3f9faf24 100644 --- a/rootston/desktop.c +++ b/rootston/desktop.c @@ -22,6 +22,8 @@ #include #include #include +#include +#include #include #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; diff --git a/rootston/seat.c b/rootston/seat.c index 544cfb90..455e9b00 100644 --- a/rootston/seat.c +++ b/rootston/seat.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include "rootston/cursor.h" #include "rootston/input.h" @@ -115,6 +116,19 @@ static void handle_tool_tip(struct wl_listener *listener, void *data) { roots_cursor_handle_tool_tip(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 *tool = event->tool; + if (!tool->data) { + tool->data = wlr_make_tablet_tool(desktop->tablet_v2, cursor->seat->seat, tool); + } +} + static void handle_request_set_cursor(struct wl_listener *listener, void *data) { struct roots_cursor *cursor = @@ -251,6 +265,9 @@ 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(&seat->seat->events.request_set_cursor, &seat->cursor->request_set_cursor); seat->cursor->request_set_cursor.notify = handle_request_set_cursor; @@ -532,6 +549,10 @@ static void seat_add_touch(struct roots_seat *seat, static void seat_add_tablet_pad(struct roots_seat *seat, struct wlr_input_device *device) { // TODO + // FIXME: This needs to be stored on the roots_tablet_tool + struct roots_desktop *desktop = seat->input->server->desktop; + (void)wlr_make_tablet_pad(desktop->tablet_v2, seat->seat, device); + } static void handle_tablet_tool_destroy(struct wl_listener *listener, @@ -568,6 +589,11 @@ static void seat_add_tablet_tool(struct roots_seat *seat, wlr_cursor_attach_input_device(seat->cursor->cursor, device); roots_seat_configure_cursor(seat); + + struct roots_desktop *desktop = seat->input->server->desktop; + + // FIXME: This needs to be stored on the roots_tablet_tool + (void)wlr_make_tablet(desktop->tablet_v2, seat->seat, device); } void roots_seat_add_device(struct roots_seat *seat, diff --git a/types/wlr_tablet_v2.c b/types/wlr_tablet_v2.c index 56f4d567..db08c184 100644 --- a/types/wlr_tablet_v2.c +++ b/types/wlr_tablet_v2.c @@ -2,6 +2,9 @@ #define _POSIX_C_SOURCE 200809L #endif +#include + +#include #include #include #include @@ -9,17 +12,22 @@ #include #include #include +#include #include "tablet-unstable-v2-protocol.h" +struct wlr_tablet_seat_v2 { + struct wl_list link; + struct wlr_seat *wlr_seat; + struct wlr_tablet_manager_v2 *manager; -struct wlr_tablet_manager_v2 { - struct wl_global *wl_global; - struct wl_list clients; // wlr_tablet_manager_client_v2::link + struct wl_list tablets; // wlr_tablet_v2_tablet::link + struct wl_list tools; + struct wl_list pads; - struct wl_listener display_destroy; + struct wl_list clients; //wlr_tablet_seat_v2_client::link; - void *data; + struct wl_listener seat_destroy; }; struct wlr_tablet_manager_client_v2 { @@ -29,19 +37,19 @@ struct wlr_tablet_manager_client_v2 { struct wlr_tablet_manager_v2 *manager; - struct wl_list tablet_seats; // wlr_tablet_seat_v2::link + struct wl_list tablet_seats; // wlr_tablet_seat_client_v2::link }; -struct wlr_tablet_seat_v2 { - struct wl_list link; +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; - struct wl_listener seat_destroy; - struct wl_listener client_destroy; + struct wl_listener seat_client_destroy; struct wl_list tools; struct wl_list tablets; @@ -49,16 +57,17 @@ struct wlr_tablet_seat_v2 { }; struct wlr_tablet_client_v2 { - struct wl_list link; + 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 wl_listener device_destroy; - struct wl_listener client_destroy; }; struct wlr_tablet_tool_client_v2 { - struct wl_list link; + struct wl_list seat_link; + struct wl_list tool_link; struct wl_client *client; struct wl_resource *resource; @@ -66,26 +75,587 @@ struct wlr_tablet_tool_client_v2 { struct wl_listener cursor_destroy; struct wl_listener tool_destroy; - struct wl_listener client_destroy; }; struct wlr_tablet_pad_client_v2 { - struct wl_list link; + struct wl_list seat_link; + struct wl_list pad_link; struct wl_client *client; struct wl_resource *resource; size_t button_count; - size_t ring_cout; + size_t group_count; + struct wl_resource **groups; + + size_t ring_count; struct wl_resource **rings; - size_t strip_cout; + size_t strip_count; struct wl_resource **strips; struct wl_listener device_destroy; - struct wl_listener client_destroy; }; +static struct zwp_tablet_v2_interface tablet_impl; + +static 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); +} + +static void destroy_tablet_v2(struct wl_resource *resource) { + struct wlr_tablet_client_v2 *tablet = tablet_client_from_resource(resource); + + wl_list_remove(&tablet->seat_link); + wl_list_remove(&tablet->tablet_link); + + //wl_list_remove(tablet->device_destroy.link); + //wl_list_remove(tablet->client_destroy.link); +} + +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 struct wlr_tablet_seat_v2 *make_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); + + wl_list_insert(&manager->seats, &tablet_seat->link); + return tablet_seat; +} + +static struct wlr_tablet_seat_v2 *get_or_make_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 make_tablet_seat(manager, wlr_seat); +} + +static 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; + } + + client->resource = + wl_resource_create(seat->wl_client, &zwp_tablet_v2_interface, 1, 0); + if (!client->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_tool->name) { + zwp_tablet_v2_send_name(client->resource, tablet->wlr_tool->name); + } + zwp_tablet_v2_send_id(client->resource, + tablet->wlr_device->vendor, tablet->wlr_device->product); + struct wlr_tablet_path *path; + wl_list_for_each(path, &tablet->wlr_tool->paths, link) { + zwp_tablet_v2_send_path(client->resource, path->path); + } + 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); +} + +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) { + // XXX: Add a timer/flag to destroy if client is slow? + 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); +} + +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 = NULL, + .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"); +} + +static 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->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, NULL); + 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); +} + +struct wlr_tablet_v2_tablet *wlr_make_tablet( + 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_make_tablet_seat(manager, wlr_seat); + if (!seat) { + return NULL; + } + struct wlr_tablet_tool *tool = wlr_device->tablet_tool; + struct wlr_tablet_v2_tablet *tablet = calloc(1, sizeof(struct wlr_tablet_v2_tablet)); + if (!tablet) { + return NULL; + } + + tablet->wlr_tool = tool; + 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; +} + +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) { + // XXX: Add a timer/flag to destroy if client is slow? + zwp_tablet_tool_v2_send_removed(pos->resource); + } + + wl_list_remove(&tool->clients); + wl_list_remove(&tool->link); + wl_list_remove(&tool->tool_destroy.link); + free(tool); +} + +struct wlr_tablet_v2_tablet_tool *wlr_make_tablet_tool( + struct wlr_tablet_manager_v2 *manager, + struct wlr_seat *wlr_seat, + struct wlr_tablet_tool_tool *wlr_tool) { + struct wlr_tablet_seat_v2 *seat = get_or_make_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); + } + + return tool; +} + +static struct zwp_tablet_pad_v2_interface tablet_pad_impl; + +static 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); +} + + +static void destroy_tablet_pad_v2(struct wl_resource *resource) { + struct wlr_tablet_pad_client_v2 *pad = + tablet_pad_client_from_resource(resource); + + wl_list_remove(&pad->seat_link); + wl_list_remove(&pad->pad_link); + + //wl_list_remove(tablet->device_destroy.link); + //wl_list_remove(tablet->client_destroy.link); +} + +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 wlr_tablet_pad_client_v2 *client = wl_resource_get_user_data(resource); + + for (size_t i = 0; i < client->ring_count; ++i) { + if (client->rings[i] == resource) { + client->rings[i] = NULL; + return; + } + } +} + +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 = NULL, + .destroy = handle_tablet_pad_ring_v2_destroy, +}; + +static void destroy_tablet_pad_strip_v2(struct wl_resource *resource) { + struct wlr_tablet_pad_client_v2 *client = wl_resource_get_user_data(resource); + + for (size_t i = 0; i < client->strip_count; ++i) { + if (client->strips[i] == resource) { + client->strips[i] = NULL; + return; + } + } +} + +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 = NULL, + .destroy = handle_tablet_pad_strip_v2_destroy, +}; + +static struct zwp_tablet_pad_v2_interface tablet_pad_impl = { + .set_feedback = NULL, + .destroy = handle_tablet_pad_v2_destroy, +}; + +static void destroy_tablet_pad_group_v2(struct wl_resource *resource) { + struct wlr_tablet_pad_client_v2 *client = wl_resource_get_user_data(resource); + + for (size_t i = 0; i < client->group_count; ++i) { + if (client->groups[i] == resource) { + client->groups[i] = NULL; + return; + } + } +} + +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) { + client->groups[index] = + wl_resource_create(client->client, &zwp_tablet_pad_group_v2_interface, 1, 0); + if (!client->groups[index]) { + wl_client_post_no_memory(client->client); + return; + } + wl_resource_set_implementation(client->groups[index], &tablet_pad_group_impl, + client, 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); + + client->strip_count = group->strip_count; + for (size_t i = 0; i < group->strip_count; ++i) { + size_t strip = group->strips[i]; + client->strips[strip] = + wl_resource_create(client->client, &zwp_tablet_pad_strip_v2_interface, 1, 0); + wl_resource_set_implementation(client->strips[strip], + &tablet_pad_strip_impl, + client, 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]; + client->rings[ring] = + wl_resource_create(client->client, &zwp_tablet_pad_ring_v2_interface, 1, 0); + wl_resource_set_implementation(client->rings[ring], + &tablet_pad_ring_impl, + client, 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]); +} + +static 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->groups = calloc(sizeof(int), wl_list_length(&pad->wlr_pad->groups)); + if (!client->groups) { + wl_client_post_no_memory(seat->wl_client); + free(client); + return; + } + + client->rings = calloc(sizeof(struct wl_resource*), pad->wlr_pad->ring_count); + if (!client->rings) { + wl_client_post_no_memory(seat->wl_client); + free(client->groups); + free(client); + return; + } + + client->strips = calloc(sizeof(struct wl_resource*), pad->wlr_pad->strip_count); + 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); + } + struct wlr_tablet_path *path; + wl_list_for_each(path, &pad->wlr_pad->paths, link) { + zwp_tablet_pad_v2_send_path(client->resource, path->path); + } + size_t i = 0; + struct wlr_tablet_pad_group *group; + 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 *pos; + struct wlr_tablet_pad_client_v2 *tmp; + wl_list_for_each_safe(pos, tmp, &pad->clients, pad_link) { + // XXX: Add a timer/flag to destroy if client is slow? + zwp_tablet_pad_v2_send_removed(pos->resource); + } + + wl_list_remove(&pad->clients); + wl_list_remove(&pad->link); + wl_list_remove(&pad->pad_destroy.link); + free(pad); +} + +struct wlr_tablet_v2_tablet_pad *wlr_make_tablet_pad( + 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_make_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->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); + } + + wlr_log(L_DEBUG, "Created tablet v2 pad:"); + struct wlr_tablet_path *path; + wl_list_for_each(path, &wlr_pad->paths, link) { + wlr_log(L_DEBUG, "%s", path->path); + } + + return pad; +} + void wlr_tablet_v2_destroy(struct wlr_tablet_manager_v2 *manager); static struct wlr_tablet_manager_client_v2 *tablet_manager_client_from_resource(struct wl_resource *resource); @@ -98,15 +668,15 @@ static struct zwp_tablet_seat_v2_interface seat_impl = { .destroy = tablet_seat_destroy, }; -static struct wlr_tablet_seat_v2 *tablet_seat_from_resource ( +static struct wlr_tablet_seat_client_v2 *tablet_seat_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); } -static void wlr_tablet_seat_v2_destroy(struct wl_resource *resource) { - struct wlr_tablet_seat_v2 *seat = tablet_seat_from_resource(resource); +static void wlr_tablet_seat_client_v2_destroy(struct wl_resource *resource) { + struct wlr_tablet_seat_client_v2 *seat = tablet_seat_from_resource(resource); seat->resource = NULL; /* We can't just destroy the struct, because we may need to iterate it @@ -116,15 +686,15 @@ static void wlr_tablet_seat_v2_destroy(struct wl_resource *resource) { } static void handle_seat_destroy(struct wl_listener *listener, void *data) { - struct wlr_tablet_seat_v2 *seat = - wl_container_of(listener, seat, seat_destroy); + struct wlr_tablet_seat_client_v2 *seat = + wl_container_of(listener, seat, seat_client_destroy); seat->seat = NULL; - wl_list_remove(&seat->seat_destroy.link); + wl_list_remove(&seat->seat_client_destroy.link); /* Remove leaves it in a defunct state, we will remove again in the * actual destroy sequence */ - wl_list_init(&seat->seat_destroy.link); + wl_list_init(&seat->seat_client_destroy.link); } static void tablet_manager_destroy(struct wl_client *client, @@ -137,32 +707,60 @@ static void get_tablet_seat(struct wl_client *wl_client, struct wl_resource *res { struct wlr_tablet_manager_client_v2 *manager = tablet_manager_client_from_resource(resource); struct wlr_seat_client *seat = wlr_seat_client_from_resource(seat_resource); - struct wlr_tablet_seat_v2 *tablet_seat = - calloc(1, sizeof(struct wlr_tablet_seat_v2)); + get_or_make_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; } - tablet_seat->resource = + seat_client->resource = wl_resource_create(wl_client, &zwp_tablet_seat_v2_interface, 1, id); - if (tablet_seat->resource == NULL) { - free(tablet_seat); + 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, + wlr_tablet_seat_client_v2_destroy); + + seat_client->seat = 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); - tablet_seat->seat = seat; - tablet_seat->client = manager; + seat_client->seat_client_destroy.notify = handle_seat_destroy; + wl_signal_add(&seat->events.destroy, &seat_client->seat_client_destroy); - tablet_seat->seat_destroy.notify = handle_seat_destroy; - wl_signal_add(&seat->events.destroy, &tablet_seat->seat_destroy); + wl_list_insert(&manager->tablet_seats, &seat_client->client_link); + wl_list_insert(&tablet_seat->clients, &seat_client->seat_link); + + // We need to emmit 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); + } - wl_resource_set_implementation(tablet_seat->resource, &seat_impl, tablet_seat, - wlr_tablet_seat_v2_destroy); - wl_list_insert(&manager->tablet_seats, &tablet_seat->link); + 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 = { @@ -242,6 +840,7 @@ struct wlr_tablet_manager_v2 *wlr_tablet_v2_create(struct wl_display *display) { } 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); -- cgit v1.2.3 From 391eef6ea9acfd12856970548cb75dbef83dc702 Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Wed, 2 May 2018 09:26:34 +0200 Subject: Propagate most axis events to clients --- backend/libinput/tablet_tool.c | 3 +- include/rootston/seat.h | 13 ++++++ include/wlr/types/wlr_tablet_v2.h | 15 +++++++ rootston/seat.c | 93 +++++++++++++++++++++++++++++++++++++-- types/wlr_tablet_v2.c | 51 ++++++++++++++++++++- 5 files changed, 170 insertions(+), 5 deletions(-) (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index f69e41f8..36b64836 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -270,7 +270,8 @@ void handle_tablet_tool_proximity(struct libinput_event *event, // If the tool is not unique, libinput will not find it again after the // proximity out, so we should destroy it - if (!tool->unique) { + 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); struct wlr_libinput_tablet *tablet = diff --git a/include/rootston/seat.h b/include/rootston/seat.h index 31ddd6fa..1a0b889a 100644 --- a/include/rootston/seat.h +++ b/include/rootston/seat.h @@ -111,6 +111,19 @@ struct roots_tablet_pad { struct wl_listener tablet_destroy; }; +struct roots_tablet_tool_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 tool_destroy; + + struct roots_tablet_tool *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/wlr/types/wlr_tablet_v2.h b/include/wlr/types/wlr_tablet_v2.h index 4b2fffe4..a07a0177 100644 --- a/include/wlr/types/wlr_tablet_v2.h +++ b/include/wlr/types/wlr_tablet_v2.h @@ -7,6 +7,7 @@ #include "tablet-unstable-v2-protocol.h" +struct wlr_tablet_client_v2; struct wlr_tablet_tool_client_v2; struct wlr_tablet_pad_client_v2; @@ -27,6 +28,8 @@ struct wlr_tablet_v2_tablet { 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 { @@ -37,6 +40,9 @@ struct wlr_tablet_v2_tablet_tool { struct wl_listener tool_destroy; struct wlr_tablet_tool_client_v2 *current_client; + struct wlr_surface *focused_surface; + struct wl_listener surface_destroy; + struct wl_listener client_destroy; }; struct wlr_tablet_v2_tablet_pad { @@ -79,6 +85,12 @@ uint32_t wlr_send_tablet_v2_tablet_tool_proximity_in( 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_distance( + struct wlr_tablet_v2_tablet_tool *tool, uint32_t distance); + +void wlr_send_tablet_v2_tablet_tool_wheel( + struct wlr_tablet_v2_tablet_tool *tool, double delta, int32_t clicks); + void wlr_send_tablet_v2_tablet_tool_proximity_out( struct wlr_tablet_v2_tablet_tool *tool); @@ -101,4 +113,7 @@ uint32_t wlr_send_tablet_v2_tablet_pad_leave(struct wlr_tablet_v2_tablet_pad *pa 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/rootston/seat.c b/rootston/seat.c index 8f84fc4b..eb909e78 100644 --- a/rootston/seat.c +++ b/rootston/seat.c @@ -101,13 +101,75 @@ 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_tool *tool, + struct wlr_tablet_tool_tool *tool_tool, + bool change_x, bool change_y, double x, double y, + uint32_t time) { + if (!change_x && !change_y) { + return; + } + + wlr_cursor_warp_absolute(cursor->cursor, tool->device, + change_x ? x : -1 , change_y ? y : -1); + + 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_tool *roots_tool = 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(tool->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, + tool->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) { + wlr_log(L_DEBUG, "Tool Axis"); 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_tool *roots_tool = event->tool->data; + + if (!roots_tool) { + wlr_log(L_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->time_msec); + + 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_WHEEL) { + wlr_send_tablet_v2_tablet_tool_wheel(roots_tool->tablet_v2_tool, event->wheel_delta, 0); + } + //roots_cursor_handle_tool_axis(cursor, event); } static void handle_tool_tip(struct wl_listener *listener, void *data) { @@ -119,7 +181,22 @@ static void handle_tool_tip(struct wl_listener *listener, void *data) { roots_cursor_handle_tool_tip(cursor, event); } +static void handle_tablet_tool_tool_destroy(struct wl_listener *listener, void *data) { + wlr_log(L_DEBUG, "Tool destroy"); + struct roots_tablet_tool_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->tablet_destroy.link); + + free(tool); +} + static void handle_tool_proximity(struct wl_listener *listener, void *data) { + wlr_log(L_DEBUG, "Tool Proximity"); struct roots_cursor *cursor = wl_container_of(listener, cursor, tool_proximity); struct roots_desktop *desktop = cursor->seat->input->server->desktop; @@ -128,8 +205,18 @@ static void handle_tool_proximity(struct wl_listener *listener, void *data) { struct wlr_tablet_tool_tool *tool = event->tool; if (!tool->data) { - tool->data = wlr_make_tablet_tool(desktop->tablet_v2, cursor->seat->seat, tool); - } + struct roots_tablet_tool_tool *roots_tool = + calloc(1, sizeof(struct roots_tablet_tool_tool)); + roots_tool->seat = cursor->seat; + tool->data = roots_tool; + roots_tool->tablet_v2_tool = + wlr_make_tablet_tool(desktop->tablet_v2, cursor->seat->seat, tool); + roots_tool->tool_destroy.notify = handle_tablet_tool_tool_destroy; + wl_signal_add(&tool->events.destroy, &roots_tool->tool_destroy); + } + + handle_tablet_tool_position(cursor, event->device->data, event->tool, + true, true, event->x, event->y, event->time_msec); } static void handle_request_set_cursor(struct wl_listener *listener, diff --git a/types/wlr_tablet_v2.c b/types/wlr_tablet_v2.c index f980aa0d..042713b7 100644 --- a/types/wlr_tablet_v2.c +++ b/types/wlr_tablet_v2.c @@ -950,8 +950,11 @@ static void send_tool_frame(void *data) { } 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(NULL, send_tool_frame, tool); + tool->frame_source = + wl_event_loop_add_idle(loop, send_tool_frame, tool); } } @@ -961,6 +964,10 @@ uint32_t wlr_send_tablet_v2_tablet_tool_proximity_in( struct wlr_surface *surface) { struct wl_client *client = wl_resource_get_client(surface->resource); + if (tool->focused_surface == surface) { + return 0; + } + 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) { @@ -1004,6 +1011,7 @@ uint32_t wlr_send_tablet_v2_tablet_tool_proximity_in( tablet_client->resource, surface->resource); queue_tool_frame(tool_client); + tool->focused_surface = surface; return serial; } @@ -1028,9 +1036,31 @@ void wlr_send_tablet_v2_tablet_tool_proximity_out( wl_event_source_remove(tool->current_client->frame_source); send_tool_frame(tool->current_client); } + tool->current_client = NULL; + } +} + +void wlr_send_tablet_v2_tablet_tool_distance( + struct wlr_tablet_v2_tablet_tool *tool, uint32_t distance) { + if (tool->current_client) { + zwp_tablet_tool_v2_send_distance(tool->current_client->resource, + distance); + + queue_tool_frame(tool->current_client); } } +void wlr_send_tablet_v2_tablet_tool_wheel( + struct wlr_tablet_v2_tablet_tool *tool, double delta, int32_t clicks) { + if (tool->current_client) { + zwp_tablet_tool_v2_send_wheel(tool->current_client->resource, + clicks, delta); + + queue_tool_frame(tool->current_client); + } + +} + uint32_t wlr_send_tablet_v2_tablet_pad_enter( struct wlr_tablet_v2_tablet_pad *pad, @@ -1183,3 +1213,22 @@ uint32_t wlr_send_tablet_v2_tablet_pad_mode(struct wlr_tablet_v2_tablet_pad *pad 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; +} -- cgit v1.2.3 From 5c7a37f30922d973e176b0eec29bb5fddf241eee Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Fri, 4 May 2018 11:46:32 +0200 Subject: Add tool buttons --- backend/libinput/tablet_tool.c | 5 +++- include/rootston/cursor.h | 1 + include/wlr/types/wlr_tablet_v2.h | 11 +++++++ rootston/seat.c | 19 +++++++++--- types/wlr_tablet_v2.c | 63 +++++++++++++++++++++++++++++++++++++-- 5 files changed, 91 insertions(+), 8 deletions(-) (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index 36b64836..3a39f5dc 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -263,11 +263,14 @@ 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); + 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 && diff --git a/include/rootston/cursor.h b/include/rootston/cursor.h index 0478c3ca..f7410dec 100644 --- a/include/rootston/cursor.h +++ b/include/rootston/cursor.h @@ -41,6 +41,7 @@ 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/wlr/types/wlr_tablet_v2.h b/include/wlr/types/wlr_tablet_v2.h index a07a0177..12995308 100644 --- a/include/wlr/types/wlr_tablet_v2.h +++ b/include/wlr/types/wlr_tablet_v2.h @@ -7,6 +7,9 @@ #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; @@ -43,6 +46,10 @@ struct wlr_tablet_v2_tablet_tool { struct wlr_surface *focused_surface; struct wl_listener surface_destroy; struct wl_listener client_destroy; + + uint32_t button_serial; + size_t num_buttons; + uint32_t pressed_buttons[WLR_TABLEt_V2_TOOL_BUTTONS_CAP]; }; struct wlr_tablet_v2_tablet_pad { @@ -94,6 +101,10 @@ void wlr_send_tablet_v2_tablet_tool_wheel( void wlr_send_tablet_v2_tablet_tool_proximity_out( struct wlr_tablet_v2_tablet_tool *tool); +uint32_t 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, diff --git a/rootston/seat.c b/rootston/seat.c index eb909e78..eb1e7e0b 100644 --- a/rootston/seat.c +++ b/rootston/seat.c @@ -140,7 +140,6 @@ static void handle_tablet_tool_position(struct roots_cursor *cursor, } static void handle_tool_axis(struct wl_listener *listener, void *data) { - wlr_log(L_DEBUG, "Tool Axis"); struct roots_cursor *cursor = wl_container_of(listener, cursor, tool_axis); struct roots_desktop *desktop = cursor->seat->input->server->desktop; @@ -148,7 +147,7 @@ static void handle_tool_axis(struct wl_listener *listener, void *data) { struct wlr_event_tablet_tool_axis *event = data; struct roots_tablet_tool_tool *roots_tool = event->tool->data; - if (!roots_tool) { + if (!roots_tool) { // Should this be an assert? wlr_log(L_DEBUG, "Tool Axis, before proximity"); return; } @@ -182,7 +181,6 @@ static void handle_tool_tip(struct wl_listener *listener, void *data) { } static void handle_tablet_tool_tool_destroy(struct wl_listener *listener, void *data) { - wlr_log(L_DEBUG, "Tool destroy"); struct roots_tablet_tool_tool *tool = wl_container_of(listener, tool, tool_destroy); @@ -195,8 +193,18 @@ static void handle_tablet_tool_tool_destroy(struct wl_listener *listener, void * 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_tool *roots_tool = event->tool->data; + + wlr_send_tablet_v2_tablet_tool_button(roots_tool->tablet_v2_tool, event->button, event->state); +} + static void handle_tool_proximity(struct wl_listener *listener, void *data) { - wlr_log(L_DEBUG, "Tool Proximity"); struct roots_cursor *cursor = wl_container_of(listener, cursor, tool_proximity); struct roots_desktop *desktop = cursor->seat->input->server->desktop; @@ -358,6 +366,9 @@ static void roots_seat_init_cursor(struct roots_seat *seat) { 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; diff --git a/types/wlr_tablet_v2.c b/types/wlr_tablet_v2.c index 042713b7..104de65f 100644 --- a/types/wlr_tablet_v2.c +++ b/types/wlr_tablet_v2.c @@ -941,6 +941,47 @@ struct wlr_tablet_manager_v2 *wlr_tablet_v2_create(struct wl_display *display) { } /* Actual protocol foo */ +// 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 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; + break; + } + } + + if (button == ZWP_TABLET_PAD_V2_BUTTON_STATE_PRESSED && !found && + tool->num_buttons < WLR_TABLEt_V2_TOOL_BUTTONS_CAP) { + tool->pressed_buttons[tool->num_buttons++] = button; + } + if (button == ZWP_TABLET_PAD_V2_BUTTON_STATE_RELEASED && found) { + tool->pressed_buttons[i] = 0; + tool->num_buttons = push_zeroes_to_end(tool->pressed_buttons, WLR_TABLEt_V2_TOOL_BUTTONS_CAP); + } + + assert(tool->num_buttons <= WLR_TABLEt_V2_TOOL_BUTTONS_CAP); +} static void send_tool_frame(void *data) { struct wlr_tablet_tool_client_v2 *tool = data; @@ -1041,7 +1082,7 @@ void wlr_send_tablet_v2_tablet_tool_proximity_out( } void wlr_send_tablet_v2_tablet_tool_distance( - struct wlr_tablet_v2_tablet_tool *tool, uint32_t distance) { + struct wlr_tablet_v2_tablet_tool *tool, uint32_t distance) { if (tool->current_client) { zwp_tablet_tool_v2_send_distance(tool->current_client->resource, distance); @@ -1050,6 +1091,24 @@ void wlr_send_tablet_v2_tablet_tool_distance( } } +uint32_t 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) { + tablet_tool_button_update(tool, button, state); + + if (tool->current_client) { + uint32_t serial = ++tool->button_serial; + + zwp_tablet_tool_v2_send_button(tool->current_client->resource, + serial, button, state); + queue_tool_frame(tool->current_client); + + return serial; + } + + return 0; +} + void wlr_send_tablet_v2_tablet_tool_wheel( struct wlr_tablet_v2_tablet_tool *tool, double delta, int32_t clicks) { if (tool->current_client) { @@ -1058,10 +1117,8 @@ void wlr_send_tablet_v2_tablet_tool_wheel( queue_tool_frame(tool->current_client); } - } - uint32_t wlr_send_tablet_v2_tablet_pad_enter( struct wlr_tablet_v2_tablet_pad *pad, struct wlr_tablet_v2_tablet *tablet, -- cgit v1.2.3 From 599f84f736ef617374660c82acf52bff0e95c566 Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Fri, 4 May 2018 16:40:41 +0200 Subject: Fix borked rebase --- backend/libinput/tablet_pad.c | 2 +- backend/libinput/tablet_tool.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/tablet_pad.c b/backend/libinput/tablet_pad.c index 7c196bf1..bb65adf6 100644 --- a/backend/libinput/tablet_pad.c +++ b/backend/libinput/tablet_pad.c @@ -79,7 +79,7 @@ static void add_pad_group_from_libinput(struct wlr_tablet_pad *pad, wl_list_insert(&pad->groups, &group->link); } -struct wlr_tablet_pad *libinput_tablet_pad_create( +struct wlr_tablet_pad *create_libinput_tablet_pad( struct libinput_device *libinput_dev) { assert(libinput_dev); struct wlr_tablet_pad *wlr_tablet_pad = calloc(1, sizeof(struct wlr_tablet_pad)); diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index 3a39f5dc..a20637c1 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -74,7 +74,7 @@ void wlr_libinput_tablet_tool_destroy(struct wlr_input_device *wlr_dev) { } } -struct wlr_tablet_tool *libinput_tablet_tool_create( +struct wlr_tablet_tool *create_libinput_tablet_tool( struct libinput_device *libinput_dev) { assert(libinput_dev); struct wlr_libinput_tablet *libinput_tablet_tool = -- cgit v1.2.3 From 31cec36b741d3c645c18c4e7e8dedbd6c6e3ece5 Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Tue, 15 May 2018 15:41:32 +0200 Subject: 1st feedback pass Rename make_ functions to _create Implement set_cursor and set_feedback --- backend/libinput/tablet_pad.c | 6 +- backend/libinput/tablet_tool.c | 4 +- include/wlr/types/wlr_tablet_v2.h | 29 ++++++- rootston/seat.c | 13 ++-- types/wlr_tablet_v2.c | 154 +++++++++++++++++++++++++++++++------- 5 files changed, 166 insertions(+), 40 deletions(-) (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/tablet_pad.c b/backend/libinput/tablet_pad.c index bb65adf6..f1fb6d7a 100644 --- a/backend/libinput/tablet_pad.c +++ b/backend/libinput/tablet_pad.c @@ -21,7 +21,11 @@ static void add_tablet_path(struct wl_list *list, const char *path) { } tablet_path->path = strdup(path); - assert(tablet_path->path); + if (!tablet_path->path) { + free(tablet_path); + return; + } + wl_list_insert(list, &tablet_path->link); } diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index a20637c1..f02e045a 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -79,11 +79,11 @@ struct wlr_tablet_tool *create_libinput_tablet_tool( assert(libinput_dev); struct wlr_libinput_tablet *libinput_tablet_tool = calloc(1, sizeof(struct wlr_libinput_tablet)); - struct wlr_tablet_tool *wlr_tablet_tool = &libinput_tablet_tool->wlr_tool; - if (!wlr_tablet_tool) { + if (!libinput_tablet_tool) { wlr_log(WLR_ERROR, "Unable to allocate wlr_tablet_tool"); return NULL; } + struct wlr_tablet_tool *wlr_tablet_tool = &libinput_tablet_tool->wlr_tool; wl_list_init(&wlr_tablet_tool->paths); struct udev_device *udev = libinput_device_get_udev_device(libinput_dev); diff --git a/include/wlr/types/wlr_tablet_v2.h b/include/wlr/types/wlr_tablet_v2.h index 12995308..0be672cb 100644 --- a/include/wlr/types/wlr_tablet_v2.h +++ b/include/wlr/types/wlr_tablet_v2.h @@ -50,6 +50,10 @@ struct wlr_tablet_v2_tablet_tool { uint32_t button_serial; size_t num_buttons; uint32_t pressed_buttons[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 { @@ -64,19 +68,38 @@ struct wlr_tablet_v2_tablet_pad { 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_tablet_v2_event_feedback { + const char *description; + size_t index; + uint32_t serial; }; -struct wlr_tablet_v2_tablet *wlr_make_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); -struct wlr_tablet_v2_tablet_pad *wlr_make_tablet_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); -struct wlr_tablet_v2_tablet_tool *wlr_make_tablet_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_tool *wlr_tool); diff --git a/rootston/seat.c b/rootston/seat.c index b7bf28fc..6b12f682 100644 --- a/rootston/seat.c +++ b/rootston/seat.c @@ -148,7 +148,7 @@ static void handle_tool_axis(struct wl_listener *listener, void *data) { struct roots_tablet_tool_tool *roots_tool = event->tool->data; if (!roots_tool) { // Should this be an assert? - wlr_log(L_DEBUG, "Tool Axis, before proximity"); + wlr_log(WLR_DEBUG, "Tool Axis, before proximity"); return; } @@ -217,7 +217,8 @@ static void handle_tool_proximity(struct wl_listener *listener, void *data) { roots_tool->seat = cursor->seat; tool->data = roots_tool; roots_tool->tablet_v2_tool = - wlr_make_tablet_tool(desktop->tablet_v2, cursor->seat->seat, tool); + wlr_tablet_tool_create(desktop->tablet_v2, + cursor->seat->seat, tool); roots_tool->tool_destroy.notify = handle_tablet_tool_tool_destroy; wl_signal_add(&tool->events.destroy, &roots_tool->tool_destroy); wl_list_init(&roots_tool->link); @@ -683,7 +684,7 @@ static void handle_pad_tool_destroy(struct wl_listener *listener, void *data) { static void attach_tablet_pad(struct roots_tablet_pad *pad, struct roots_tablet_tool *tool) { - wlr_log(L_DEBUG, "Attaching tablet pad \"%s\" to tablet tool \"%s\"", + wlr_log(WLR_DEBUG, "Attaching tablet pad \"%s\" to tablet tool \"%s\"", pad->device->name, tool->device->name); pad->tablet = tool; @@ -742,7 +743,7 @@ static void seat_add_tablet_pad(struct roots_seat *seat, struct roots_tablet_pad *tablet_pad = calloc(sizeof(struct roots_tablet_pad), 1); if (!tablet_pad) { - wlr_log(L_ERROR, "could not allocate tablet_pad for seat"); + wlr_log(WLR_ERROR, "could not allocate tablet_pad for seat"); return; } @@ -772,7 +773,7 @@ static void seat_add_tablet_pad(struct roots_seat *seat, struct roots_desktop *desktop = seat->input->server->desktop; tablet_pad->tablet_v2_pad = - wlr_make_tablet_pad(desktop->tablet_v2, seat->seat, device); + wlr_tablet_pad_create(desktop->tablet_v2, seat->seat, device); /* Search for a sibling tablet */ if (!wlr_input_device_is_libinput(device)) { @@ -837,7 +838,7 @@ static void seat_add_tablet_tool(struct roots_seat *seat, struct roots_desktop *desktop = seat->input->server->desktop; tablet_tool->tablet_v2 = - wlr_make_tablet(desktop->tablet_v2, seat->seat, device); + 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)); diff --git a/types/wlr_tablet_v2.c b/types/wlr_tablet_v2.c index 104de65f..e05e85f3 100644 --- a/types/wlr_tablet_v2.c +++ b/types/wlr_tablet_v2.c @@ -2,18 +2,16 @@ #define _POSIX_C_SOURCE 200809L #endif -#include - -#include #include #include -#include #include +#include #include #include #include #include - +#include +#include #include "tablet-unstable-v2-protocol.h" struct wlr_tablet_seat_v2 { @@ -68,6 +66,7 @@ struct wlr_tablet_tool_client_v2 { struct wl_list tool_link; struct wl_client *client; struct wl_resource *resource; + struct wlr_tablet_v2_tablet_tool *tool; uint32_t proximity_serial; @@ -79,6 +78,7 @@ struct wlr_tablet_pad_client_v2 { struct wl_list pad_link; struct wl_client *client; struct wl_resource *resource; + struct wlr_tablet_v2_tablet_pad *pad; uint32_t enter_serial; uint32_t mode_serial; @@ -96,6 +96,11 @@ struct wlr_tablet_pad_client_v2 { struct wl_resource **strips; }; +struct tablet_pad_auxiliary_user_data { + struct wlr_tablet_pad_client_v2 *pad; + size_t index; +}; + static struct zwp_tablet_v2_interface tablet_impl; static struct wlr_tablet_client_v2 *tablet_client_from_resource(struct wl_resource *resource) { @@ -257,12 +262,35 @@ static void handle_wlr_tablet_destroy(struct wl_listener *listener, void *data) free(tablet); } +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 = wl_resource_get_user_data(resource); + if (!tool) { + return; + } + + struct wlr_surface *surface = wlr_surface_from_resource(surface_resource); + + struct wlr_tablet_v2_event_cursor evt = { + .surface = surface, + .serial = serial, + .hotspot_x = hotspot_x, + .hotspot_y = hotspot_y, + }; + + 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 = NULL, + .set_cursor = handle_tablet_tool_v2_set_cursor, .destroy = handle_tablet_tool_v2_destroy, }; @@ -308,6 +336,7 @@ static void add_tablet_tool_client(struct wlr_tablet_seat_client_v2 *seat, if (!client) { return; } + client->tool = tool; client->resource = wl_resource_create(seat->wl_client, &zwp_tablet_tool_v2_interface, 1, 0); @@ -372,7 +401,7 @@ static void add_tablet_tool_client(struct wlr_tablet_seat_client_v2 *seat, wl_list_insert(&tool->clients, &client->tool_link); } -struct wlr_tablet_v2_tablet *wlr_make_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) { @@ -420,10 +449,11 @@ static void handle_wlr_tablet_tool_destroy(struct wl_listener *listener, void *d 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_make_tablet_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_tool *wlr_tool) { @@ -452,6 +482,8 @@ struct wlr_tablet_v2_tablet_tool *wlr_make_tablet_tool( add_tablet_tool_client(pos, tool); } + wl_signal_init(&tool->events.set_cursor); + return tool; } @@ -506,14 +538,30 @@ static void handle_tablet_pad_v2_destroy(struct wl_client *client, } static void destroy_tablet_pad_ring_v2(struct wl_resource *resource) { - struct wlr_tablet_pad_client_v2 *client = wl_resource_get_user_data(resource); + struct tablet_pad_auxiliary_user_data *aux = wl_resource_get_user_data(resource); - for (size_t i = 0; i < client->ring_count; ++i) { - if (client->rings[i] == resource) { - client->rings[i] = NULL; - return; - } + if (!aux) { + return; } + + aux->pad->rings[aux->index] = NULL; + free(aux); +} +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, @@ -522,19 +570,35 @@ static void handle_tablet_pad_ring_v2_destroy(struct wl_client *client, } static struct zwp_tablet_pad_ring_v2_interface tablet_pad_ring_impl = { - .set_feedback = NULL, + .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 wlr_tablet_pad_client_v2 *client = wl_resource_get_user_data(resource); + struct tablet_pad_auxiliary_user_data *aux = wl_resource_get_user_data(resource); + if (!aux) { + return; + } - for (size_t i = 0; i < client->strip_count; ++i) { - if (client->strips[i] == resource) { - client->strips[i] = NULL; - return; - } + aux->pad->strips[aux->index] = NULL; + free(aux); +} + +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, @@ -543,12 +607,26 @@ static void handle_tablet_pad_strip_v2_destroy(struct wl_client *client, } static struct zwp_tablet_pad_strip_v2_interface tablet_pad_strip_impl = { - .set_feedback = NULL, + .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_v2_tablet_pad *pad = wl_resource_get_user_data(resource); + + struct wlr_tablet_v2_event_feedback evt = { + .serial = serial, + .index = button, + .description = description, + }; + + wl_signal_emit(&pad->events.button_feedback, &evt); +} + static struct zwp_tablet_pad_v2_interface tablet_pad_impl = { - .set_feedback = NULL, + .set_feedback = handle_tablet_pad_v2_set_feedback, .destroy = handle_tablet_pad_v2_destroy, }; @@ -597,22 +675,34 @@ static void add_tablet_pad_group(struct wlr_tablet_v2_tablet_pad *pad, 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) { + continue; + } + user_data->pad = client; + user_data->index = strip; client->strips[strip] = wl_resource_create(client->client, &zwp_tablet_pad_strip_v2_interface, 1, 0); wl_resource_set_implementation(client->strips[strip], - &tablet_pad_strip_impl, - client, destroy_tablet_pad_strip_v2); + &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) { + continue; + } + user_data->pad = client; + user_data->index = ring; client->rings[ring] = wl_resource_create(client->client, &zwp_tablet_pad_ring_v2_interface, 1, 0); wl_resource_set_implementation(client->rings[ring], - &tablet_pad_ring_impl, - client, destroy_tablet_pad_ring_v2); + &tablet_pad_ring_impl, user_data, destroy_tablet_pad_ring_v2); zwp_tablet_pad_group_v2_send_ring(client->groups[index], client->rings[ring]); } @@ -627,6 +717,7 @@ static void add_tablet_pad_client(struct wlr_tablet_seat_client_v2 *seat, wl_client_post_no_memory(seat->wl_client); return; } + client->pad = pad; client->groups = calloc(sizeof(int), wl_list_length(&pad->wlr_pad->groups)); if (!client->groups) { @@ -700,10 +791,13 @@ static void handle_wlr_tablet_pad_destroy(struct wl_listener *listener, void *da 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_make_tablet_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) { @@ -739,6 +833,10 @@ struct wlr_tablet_v2_tablet_pad *wlr_make_tablet_pad( 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; } -- cgit v1.2.3 From adba68a3c1fb51771342512f570c552a7404cc93 Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Tue, 15 May 2018 15:49:55 +0200 Subject: Use tablet_tool impl in libinput backend --- backend/libinput/events.c | 3 --- backend/libinput/tablet_tool.c | 12 +++++++++--- include/backend/libinput.h | 1 - 3 files changed, 9 insertions(+), 7 deletions(-) (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/events.c b/backend/libinput/events.c index d15de6bb..93664af2 100644 --- a/backend/libinput/events.c +++ b/backend/libinput/events.c @@ -186,9 +186,6 @@ static void handle_device_removed(struct wlr_libinput_backend *backend, } struct wlr_input_device *dev, *tmp_dev; wl_list_for_each_safe(dev, tmp_dev, wlr_devices, link) { - if (dev->type == WLR_INPUT_DEVICE_TABLET_TOOL) { - wlr_libinput_tablet_tool_destroy(dev); - } wlr_input_device_destroy(dev); } for (size_t i = 0; i < backend->wlr_device_lists.length; i++) { diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index f02e045a..7cecb091 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -57,9 +57,9 @@ static void destroy_tool_tool(struct wlr_libinput_tablet_tool *tool) { } -void wlr_libinput_tablet_tool_destroy(struct wlr_input_device *wlr_dev) { +static void libinput_tablet_tool_destroy(struct wlr_tablet_tool *tool) { struct wlr_libinput_tablet *tablet = - wl_container_of(wlr_dev->tablet_tool, tablet, wlr_tool); + wl_container_of(tool, tablet, wlr_tool); struct tablet_tool_list_elem *pos; struct tablet_tool_list_elem *tmp; @@ -72,8 +72,14 @@ void wlr_libinput_tablet_tool_destroy(struct wlr_input_device *wlr_dev) { destroy_tool_tool(tool); } } + + free(tablet); } +static struct wlr_tablet_tool_impl tool_impl = { + .destroy = libinput_tablet_tool_destroy, +}; + struct wlr_tablet_tool *create_libinput_tablet_tool( struct libinput_device *libinput_dev) { assert(libinput_dev); @@ -91,7 +97,7 @@ struct wlr_tablet_tool *create_libinput_tablet_tool( wlr_tablet_tool->name = strdup(libinput_device_get_name(libinput_dev)); wl_list_init(&libinput_tablet_tool->tools); - wlr_tablet_tool_init(wlr_tablet_tool, NULL); + wlr_tablet_tool_init(wlr_tablet_tool, &tool_impl); return wlr_tablet_tool; } diff --git a/include/backend/libinput.h b/include/backend/libinput.h index 6ecdf44f..f0928133 100644 --- a/include/backend/libinput.h +++ b/include/backend/libinput.h @@ -67,7 +67,6 @@ void handle_touch_cancel(struct libinput_event *event, struct wlr_tablet_tool *create_libinput_tablet_tool( struct libinput_device *device); -void wlr_libinput_tablet_tool_destroy(struct wlr_input_device *device); void handle_tablet_tool_axis(struct libinput_event *event, struct libinput_device *device); void handle_tablet_tool_proximity(struct libinput_event *event, -- cgit v1.2.3 From 0c9a26828a764ec2648fa1f72178d5df4dd7b36b Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Tue, 15 May 2018 16:16:19 +0200 Subject: Use wlr_list for paths, and improve inert resource handling --- backend/libinput/tablet_pad.c | 21 ++-------------- backend/libinput/tablet_tool.c | 16 ++----------- include/wlr/types/wlr_tablet_pad.h | 3 ++- include/wlr/types/wlr_tablet_tool.h | 8 ++----- types/wlr_tablet_pad.c | 9 ++++++- types/wlr_tablet_tool.c | 4 ++++ types/wlr_tablet_v2.c | 48 +++++++++++++++++++++++++++---------- 7 files changed, 55 insertions(+), 54 deletions(-) (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/tablet_pad.c b/backend/libinput/tablet_pad.c index f1fb6d7a..579a11cf 100644 --- a/backend/libinput/tablet_pad.c +++ b/backend/libinput/tablet_pad.c @@ -12,23 +12,6 @@ #include "backend/libinput.h" #include "util/signal.h" -//TODO: Move out -static void add_tablet_path(struct wl_list *list, const char *path) { - struct wlr_tablet_path *tablet_path = calloc(1, sizeof(struct wlr_tablet_path)); - - if (!tablet_path) { - return; - } - - tablet_path->path = strdup(path); - if (!tablet_path->path) { - free(tablet_path); - return; - } - - wl_list_insert(list, &tablet_path->link); -} - // 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) { @@ -99,9 +82,9 @@ struct wlr_tablet_pad *create_libinput_tablet_pad( wlr_tablet_pad->strip_count = libinput_device_tablet_pad_get_num_strips(libinput_dev); - wl_list_init(&wlr_tablet_pad->paths); + wlr_list_init(&wlr_tablet_pad->paths); struct udev_device *udev = libinput_device_get_udev_device(libinput_dev); - add_tablet_path(&wlr_tablet_pad->paths, udev_device_get_syspath(udev)); + 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); diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index 7cecb091..5dc0584c 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -13,18 +13,6 @@ #include "backend/libinput.h" #include "util/signal.h" -//TODO: Move out -static void add_tablet_path(struct wl_list *list, const char *path) { - struct wlr_tablet_path *tablet_path = calloc(1, sizeof(struct wlr_tablet_path)); - - if (!tablet_path) { - return; - } - - tablet_path->path = strdup(path); - wl_list_insert(list, &tablet_path->link); -} - struct wlr_libinput_tablet_tool { struct wlr_tablet_tool_tool wlr_tool; @@ -91,9 +79,9 @@ struct wlr_tablet_tool *create_libinput_tablet_tool( } struct wlr_tablet_tool *wlr_tablet_tool = &libinput_tablet_tool->wlr_tool; - wl_list_init(&wlr_tablet_tool->paths); + wlr_list_init(&wlr_tablet_tool->paths); struct udev_device *udev = libinput_device_get_udev_device(libinput_dev); - add_tablet_path(&wlr_tablet_tool->paths, udev_device_get_syspath(udev)); + wlr_list_push(&wlr_tablet_tool->paths, strdup(udev_device_get_syspath(udev))); wlr_tablet_tool->name = strdup(libinput_device_get_name(libinput_dev)); wl_list_init(&libinput_tablet_tool->tools); diff --git a/include/wlr/types/wlr_tablet_pad.h b/include/wlr/types/wlr_tablet_pad.h index ec291c75..23ac464d 100644 --- a/include/wlr/types/wlr_tablet_pad.h +++ b/include/wlr/types/wlr_tablet_pad.h @@ -4,6 +4,7 @@ #include #include #include +#include /* * NOTE: the wlr tablet pad implementation does not currently support tablets @@ -28,7 +29,7 @@ struct wlr_tablet_pad { size_t strip_count; struct wl_list groups; // wlr_tablet_pad_group::link - struct wl_list paths; // wlr_tablet_path::link + struct wlr_list paths; // char * void *data; }; diff --git a/include/wlr/types/wlr_tablet_tool.h b/include/wlr/types/wlr_tablet_tool.h index 114ce98a..71fa0f82 100644 --- a/include/wlr/types/wlr_tablet_tool.h +++ b/include/wlr/types/wlr_tablet_tool.h @@ -4,6 +4,7 @@ #include #include #include +#include /* * Copy+Paste from libinput, but this should neither use libinput, nor @@ -42,11 +43,6 @@ struct wlr_tablet_tool_tool { struct wlr_tablet_tool_impl; -struct wlr_tablet_path { - struct wl_list link; - char *path; -}; - struct wlr_tablet_tool { struct wlr_tablet_tool_impl *impl; @@ -58,7 +54,7 @@ struct wlr_tablet_tool { } events; const char *name; - struct wl_list paths; // wlr_table_path::link + struct wlr_list paths; // char * void *data; }; diff --git a/types/wlr_tablet_pad.c b/types/wlr_tablet_pad.c index f7d6c436..804d6910 100644 --- a/types/wlr_tablet_pad.c +++ b/types/wlr_tablet_pad.c @@ -14,7 +14,14 @@ void wlr_tablet_pad_init(struct wlr_tablet_pad *pad, } 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..85a13832 100644 --- a/types/wlr_tablet_tool.c +++ b/types/wlr_tablet_tool.c @@ -17,6 +17,10 @@ void wlr_tablet_tool_destroy(struct wlr_tablet_tool *tool) { if (!tool) { return; } + + wlr_list_for_each(&tool->paths, free); + wlr_list_finish(&tool->paths); + if (tool->impl && tool->impl->destroy) { tool->impl->destroy(tool); } else { diff --git a/types/wlr_tablet_v2.c b/types/wlr_tablet_v2.c index e05e85f3..52089c47 100644 --- a/types/wlr_tablet_v2.c +++ b/types/wlr_tablet_v2.c @@ -234,9 +234,9 @@ static void add_tablet_client(struct wlr_tablet_seat_client_v2 *seat, } zwp_tablet_v2_send_id(client->resource, tablet->wlr_device->vendor, tablet->wlr_device->product); - struct wlr_tablet_path *path; - wl_list_for_each(path, &tablet->wlr_tool->paths, link) { - zwp_tablet_v2_send_path(client->resource, path->path); + for (size_t i = 0; i < tablet->wlr_tool->paths.length; ++i) { + zwp_tablet_v2_send_path(client->resource, + tablet->wlr_tool->paths.items[i]); } zwp_tablet_v2_send_done(client->resource); @@ -546,6 +546,7 @@ static void destroy_tablet_pad_ring_v2(struct wl_resource *resource) { 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, @@ -582,6 +583,7 @@ static void destroy_tablet_pad_strip_v2(struct wl_resource *resource) { 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, @@ -631,14 +633,15 @@ static struct zwp_tablet_pad_v2_interface tablet_pad_impl = { }; static void destroy_tablet_pad_group_v2(struct wl_resource *resource) { - struct wlr_tablet_pad_client_v2 *client = wl_resource_get_user_data(resource); + struct tablet_pad_auxiliary_user_data *aux = wl_resource_get_user_data(resource); - for (size_t i = 0; i < client->group_count; ++i) { - if (client->groups[i] == resource) { - client->groups[i] = NULL; - return; - } + if (!aux) { + return; } + + aux->pad->groups[aux->index] = NULL; + free(aux); + wl_resource_set_user_data(resource, NULL); } static void handle_tablet_pad_group_v2_destroy(struct wl_client *client, @@ -659,8 +662,15 @@ static void add_tablet_pad_group(struct wlr_tablet_v2_tablet_pad *pad, 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) { + return; + } + user_data->pad = client; + user_data->index = index; wl_resource_set_implementation(client->groups[index], &tablet_pad_group_impl, - client, destroy_tablet_pad_group_v2); + 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); @@ -762,9 +772,9 @@ static void add_tablet_pad_client(struct wlr_tablet_seat_client_v2 *seat, if (pad->wlr_pad->button_count) { zwp_tablet_pad_v2_send_buttons(client->resource, pad->wlr_pad->button_count); } - struct wlr_tablet_path *path; - wl_list_for_each(path, &pad->wlr_pad->paths, link) { - zwp_tablet_pad_v2_send_path(client->resource, path->path); + 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; @@ -786,6 +796,18 @@ static void handle_wlr_tablet_pad_destroy(struct wl_listener *listener, void *da wl_list_for_each_safe(pos, tmp, &pad->clients, pad_link) { // XXX: Add a timer/flag to destroy if client is slow? zwp_tablet_pad_v2_send_removed(pos->resource); + + for (size_t i = 0; i < pos->group_count; ++i) { + destroy_tablet_pad_group_v2(pos->groups[i]); + } + + for (size_t i = 0; i < pos->strip_count; ++i) { + destroy_tablet_pad_strip_v2(pos->strips[i]); + } + + for (size_t i = 0; i < pos->ring_count; ++i) { + destroy_tablet_pad_ring_v2(pos->rings[i]); + } } wl_list_remove(&pad->clients); -- cgit v1.2.3 From 3be916f9b8dd697d5876e017b544e3d42c11397e Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Sat, 19 May 2018 14:35:02 +0200 Subject: Add asserts and rename destroy function in libinput backend --- backend/libinput/tablet_tool.c | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index 5dc0584c..d780330a 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -13,6 +13,12 @@ #include "backend/libinput.h" #include "util/signal.h" +static struct wlr_tablet_tool_impl tool_impl; + +static bool tablet_tool_is_libinput(struct wlr_tablet_tool *tool) { + return tool->impl == &tool_impl; +} + struct wlr_libinput_tablet_tool { struct wlr_tablet_tool_tool wlr_tool; @@ -45,7 +51,8 @@ static void destroy_tool_tool(struct wlr_libinput_tablet_tool *tool) { } -static void libinput_tablet_tool_destroy(struct wlr_tablet_tool *tool) { +static void destroy_tablet_tool(struct wlr_tablet_tool *tool) { + assert(tablet_tool_is_libinput(tool)); struct wlr_libinput_tablet *tablet = wl_container_of(tool, tablet, wlr_tool); @@ -65,7 +72,7 @@ static void libinput_tablet_tool_destroy(struct wlr_tablet_tool *tool) { } static struct wlr_tablet_tool_impl tool_impl = { - .destroy = libinput_tablet_tool_destroy, + .destroy = destroy_tablet_tool, }; struct wlr_tablet_tool *create_libinput_tablet_tool( @@ -148,6 +155,7 @@ static struct wlr_libinput_tablet_tool *get_wlr_tablet_tool( static void ensure_tool_reference(struct wlr_libinput_tablet_tool *tool, struct wlr_tablet_tool *wlr_dev) { + assert(tablet_tool_is_libinput(wlr_dev)); struct tablet_tool_list_elem *pos; struct wlr_libinput_tablet *tablet = wl_container_of(wlr_dev, tablet, wlr_tool); @@ -271,6 +279,7 @@ void handle_tablet_tool_proximity(struct libinput_event *event, 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_tool_is_libinput(wlr_dev->tablet_tool)); struct wlr_libinput_tablet *tablet = wl_container_of(wlr_dev->tablet_tool, tablet, wlr_tool); struct tablet_tool_list_elem *pos; -- cgit v1.2.3 From 48e2cba9b6d94b549dbd3edcb94183a66e904224 Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Fri, 25 May 2018 10:04:25 +0200 Subject: Handle relative motion for mouse tools --- backend/libinput/tablet_tool.c | 2 ++ include/wlr/types/wlr_tablet_tool.h | 2 ++ rootston/seat.c | 19 +++++++++++++------ 3 files changed, 17 insertions(+), 6 deletions(-) (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index d780330a..0dab6795 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -204,10 +204,12 @@ void handle_tablet_tool_axis(struct libinput_event *event, 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; diff --git a/include/wlr/types/wlr_tablet_tool.h b/include/wlr/types/wlr_tablet_tool.h index 71fa0f82..0a92ffe2 100644 --- a/include/wlr/types/wlr_tablet_tool.h +++ b/include/wlr/types/wlr_tablet_tool.h @@ -79,6 +79,8 @@ struct wlr_event_tablet_tool_axis { 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; diff --git a/rootston/seat.c b/rootston/seat.c index 56b9c50e..e9bfbdf7 100644 --- a/rootston/seat.c +++ b/rootston/seat.c @@ -104,14 +104,21 @@ static void handle_touch_motion(struct wl_listener *listener, void *data) { static void handle_tablet_tool_position(struct roots_cursor *cursor, struct roots_tablet_tool *tool, struct wlr_tablet_tool_tool *tool_tool, - bool change_x, bool change_y, double x, double y, - uint32_t time) { + bool change_x, bool change_y, + double x, double y, double dx, double dy) { if (!change_x && !change_y) { return; } - wlr_cursor_warp_absolute(cursor->cursor, tool->device, - change_x ? x : NAN, change_y ? y : NAN); + switch (tool_tool->type) { + case WLR_TABLET_TOOL_TYPE_MOUSE: + // They are 0 either way when they weren't modified + wlr_cursor_move(cursor->cursor, tool->device, dx, dy); + break; + default: + wlr_cursor_warp_absolute(cursor->cursor, tool->device, + change_x ? x : NAN, change_y ? y : NAN); + } double sx, sy; struct roots_view *view = NULL; @@ -159,7 +166,7 @@ static void handle_tool_axis(struct wl_listener *listener, void *data) { 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->time_msec); + 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); @@ -271,7 +278,7 @@ static void handle_tool_proximity(struct wl_listener *listener, void *data) { } handle_tablet_tool_position(cursor, event->device->data, event->tool, - true, true, event->x, event->y, event->time_msec); + true, true, event->x, event->y, 0, 0); } static void handle_request_set_cursor(struct wl_listener *listener, -- cgit v1.2.3 From d9e978e1b379c811c47f4b3b75f1ec186a640ff7 Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Sat, 16 Jun 2018 11:19:48 +0200 Subject: rename wlr_tablet_tool to wlr_tablet The previous naming was based on the input-device capability names from libinput. With code that uses the libinput_tablet_tool and mapping into tablet-v2, this is confusing, so the name is changed to follow the names used in the protocol. --- backend/headless/input_device.c | 8 ++-- backend/libinput/events.c | 4 +- backend/libinput/tablet_tool.c | 71 ++++++++++++++++---------------- examples/tablet.c | 6 +-- include/backend/libinput.h | 2 +- include/wlr/interfaces/wlr_tablet_tool.h | 10 ++--- include/wlr/types/wlr_input_device.h | 2 +- include/wlr/types/wlr_tablet_tool.h | 18 ++++---- include/wlr/types/wlr_tablet_v2.h | 6 +-- rootston/seat.c | 4 +- types/tablet_v2/wlr_tablet_v2_tablet.c | 13 +++--- types/tablet_v2/wlr_tablet_v2_tool.c | 2 +- types/wlr_cursor.c | 8 ++-- types/wlr_input_device.c | 2 +- types/wlr_tablet_tool.c | 28 ++++++------- 15 files changed, 93 insertions(+), 91 deletions(-) (limited to 'backend/libinput/tablet_tool.c') 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_tool.c b/backend/libinput/tablet_tool.c index 0dab6795..563338b8 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -13,14 +13,14 @@ #include "backend/libinput.h" #include "util/signal.h" -static struct wlr_tablet_tool_impl tool_impl; +static struct wlr_tablet_impl tablet_impl; -static bool tablet_tool_is_libinput(struct wlr_tablet_tool *tool) { - return tool->impl == &tool_impl; +static bool tablet_is_libinput(struct wlr_tablet *tablet) { + return tablet->impl == &tablet_impl; } struct wlr_libinput_tablet_tool { - struct wlr_tablet_tool_tool wlr_tool; + struct wlr_tablet_tool wlr_tool; struct libinput_tablet_tool *libinput_tool; @@ -38,7 +38,7 @@ struct tablet_tool_list_elem { }; struct wlr_libinput_tablet { - struct wlr_tablet_tool wlr_tool; + struct wlr_tablet wlr_tablet; struct wl_list tools; // tablet_tool_list_elem::link }; @@ -51,10 +51,10 @@ static void destroy_tool_tool(struct wlr_libinput_tablet_tool *tool) { } -static void destroy_tablet_tool(struct wlr_tablet_tool *tool) { - assert(tablet_tool_is_libinput(tool)); +static void destroy_tablet(struct wlr_tablet *wlr_tablet) { + assert(tablet_is_libinput(wlr_tablet)); struct wlr_libinput_tablet *tablet = - wl_container_of(tool, tablet, wlr_tool); + wl_container_of(wlr_tablet, tablet, wlr_tablet); struct tablet_tool_list_elem *pos; struct tablet_tool_list_elem *tmp; @@ -71,29 +71,29 @@ static void destroy_tablet_tool(struct wlr_tablet_tool *tool) { free(tablet); } -static struct wlr_tablet_tool_impl tool_impl = { - .destroy = destroy_tablet_tool, +static struct wlr_tablet_impl tablet_impl = { + .destroy = destroy_tablet, }; -struct wlr_tablet_tool *create_libinput_tablet_tool( +struct wlr_tablet *create_libinput_tablet( struct libinput_device *libinput_dev) { assert(libinput_dev); - struct wlr_libinput_tablet *libinput_tablet_tool = + struct wlr_libinput_tablet *libinput_tablet = calloc(1, sizeof(struct wlr_libinput_tablet)); - if (!libinput_tablet_tool) { + if (!libinput_tablet) { wlr_log(WLR_ERROR, "Unable to allocate wlr_tablet_tool"); return NULL; } - struct wlr_tablet_tool *wlr_tablet_tool = &libinput_tablet_tool->wlr_tool; + struct wlr_tablet *wlr_tablet = &libinput_tablet->wlr_tablet; - wlr_list_init(&wlr_tablet_tool->paths); + wlr_list_init(&wlr_tablet->paths); struct udev_device *udev = libinput_device_get_udev_device(libinput_dev); - wlr_list_push(&wlr_tablet_tool->paths, strdup(udev_device_get_syspath(udev))); - wlr_tablet_tool->name = strdup(libinput_device_get_name(libinput_dev)); - wl_list_init(&libinput_tablet_tool->tools); + 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_tool_init(wlr_tablet_tool, &tool_impl); - return wlr_tablet_tool; + wlr_tablet_init(wlr_tablet, &tablet_impl); + return wlr_tablet; } static enum wlr_tablet_tool_type wlr_type_from_libinput_type( @@ -154,11 +154,11 @@ static struct wlr_libinput_tablet_tool *get_wlr_tablet_tool( } static void ensure_tool_reference(struct wlr_libinput_tablet_tool *tool, - struct wlr_tablet_tool *wlr_dev) { - assert(tablet_tool_is_libinput(wlr_dev)); - struct tablet_tool_list_elem *pos; - struct wlr_libinput_tablet *tablet = wl_container_of(wlr_dev, tablet, wlr_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 @@ -173,7 +173,8 @@ static void ensure_tool_reference(struct wlr_libinput_tablet_tool *tool, struct tablet_tool_list_elem *new = calloc(1, sizeof(struct tablet_tool_list_elem)); - if (!new) {// TODO: Should we at least log? + if (!new) { + wlr_log(WLR_ERROR, "Failed to allocate memory for tracking tablet tool"); return; } @@ -195,7 +196,7 @@ void handle_tablet_tool_axis(struct libinput_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_tool); + ensure_tool_reference(tool, wlr_dev->tablet); wlr_event.device = wlr_dev; wlr_event.tool = &tool->wlr_tool; @@ -239,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, @@ -255,7 +256,7 @@ void handle_tablet_tool_proximity(struct libinput_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_tool); + ensure_tool_reference(tool, wlr_dev->tablet); wlr_event.tool = &tool->wlr_tool; wlr_event.device = wlr_dev; @@ -269,7 +270,7 @@ void handle_tablet_tool_proximity(struct libinput_event *event, wlr_event.state = WLR_TABLET_TOOL_PROXIMITY_IN; 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); @@ -281,9 +282,9 @@ void handle_tablet_tool_proximity(struct libinput_event *event, 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_tool_is_libinput(wlr_dev->tablet_tool)); + assert(tablet_is_libinput(wlr_dev->tablet)); struct wlr_libinput_tablet *tablet = - wl_container_of(wlr_dev->tablet_tool, tablet, wlr_tool); + wl_container_of(wlr_dev->tablet, tablet, wlr_tablet); struct tablet_tool_list_elem *pos; struct tablet_tool_list_elem *tmp; @@ -313,7 +314,7 @@ void handle_tablet_tool_tip(struct libinput_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_tool); + ensure_tool_reference(tool, wlr_dev->tablet); wlr_event.device = wlr_dev; wlr_event.tool = &tool->wlr_tool; @@ -327,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, @@ -344,7 +345,7 @@ void handle_tablet_tool_button(struct libinput_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_tool); + ensure_tool_reference(tool, wlr_dev->tablet); wlr_event.device = wlr_dev; wlr_event.tool = &tool->wlr_tool; @@ -359,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/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/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 -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_tablet_tool.h b/include/wlr/types/wlr_tablet_tool.h index 0a92ffe2..bfa2e1f7 100644 --- a/include/wlr/types/wlr_tablet_tool.h +++ b/include/wlr/types/wlr_tablet_tool.h @@ -15,13 +15,13 @@ enum wlr_tablet_tool_type { 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 */ + 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_tool { +struct wlr_tablet_tool { enum wlr_tablet_tool_type type; uint64_t hardware_serial; uint64_t hardware_wacom; @@ -41,10 +41,10 @@ struct wlr_tablet_tool_tool { void *data; }; -struct wlr_tablet_tool_impl; +struct wlr_tablet_impl; -struct wlr_tablet_tool { - struct wlr_tablet_tool_impl *impl; +struct wlr_tablet { + struct wlr_tablet_impl *impl; struct { struct wl_signal axis; @@ -73,7 +73,7 @@ enum wlr_tablet_tool_axes { struct wlr_event_tablet_tool_axis { struct wlr_input_device *device; - struct wlr_tablet_tool_tool *tool; + struct wlr_tablet_tool *tool; uint32_t time_msec; uint32_t updated_axes; @@ -96,7 +96,7 @@ enum wlr_tablet_tool_proximity_state { struct wlr_event_tablet_tool_proximity { struct wlr_input_device *device; - struct wlr_tablet_tool_tool *tool; + struct wlr_tablet_tool *tool; uint32_t time_msec; // From 0..1 double x, y; @@ -110,7 +110,7 @@ enum wlr_tablet_tool_tip_state { struct wlr_event_tablet_tool_tip { struct wlr_input_device *device; - struct wlr_tablet_tool_tool *tool; + struct wlr_tablet_tool *tool; uint32_t time_msec; // From 0..1 double x, y; @@ -119,7 +119,7 @@ struct wlr_event_tablet_tool_tip { struct wlr_event_tablet_tool_button { struct wlr_input_device *device; - struct wlr_tablet_tool_tool *tool; + 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 index 3818132c..bebf8a19 100644 --- a/include/wlr/types/wlr_tablet_v2.h +++ b/include/wlr/types/wlr_tablet_v2.h @@ -26,7 +26,7 @@ struct wlr_tablet_manager_v2 { struct wlr_tablet_v2_tablet { struct wl_list link; // wlr_tablet_seat_v2::tablets - struct wlr_tablet_tool *wlr_tool; + struct wlr_tablet *wlr_tablet; struct wlr_input_device *wlr_device; struct wl_list clients; // wlr_tablet_client_v2::tablet_link @@ -37,7 +37,7 @@ struct wlr_tablet_v2_tablet { struct wlr_tablet_v2_tablet_tool { struct wl_list link; // wlr_tablet_seat_v2::tablets - struct wlr_tablet_tool_tool *wlr_tool; + struct wlr_tablet_tool *wlr_tool; struct wl_list clients; // wlr_tablet_tool_client_v2::tool_link struct wl_listener tool_destroy; @@ -105,7 +105,7 @@ struct wlr_tablet_v2_tablet_pad *wlr_tablet_pad_create( 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_tool *wlr_tool); + 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); diff --git a/rootston/seat.c b/rootston/seat.c index 5bd6e752..89a32fa9 100644 --- a/rootston/seat.c +++ b/rootston/seat.c @@ -103,7 +103,7 @@ static void handle_touch_motion(struct wl_listener *listener, void *data) { static void handle_tablet_tool_position(struct roots_cursor *cursor, struct roots_tablet_tool *tool, - struct wlr_tablet_tool_tool *tool_tool, + struct wlr_tablet_tool *tool_tool, bool change_x, bool change_y, double x, double y, double dx, double dy) { if (!change_x && !change_y) { @@ -264,7 +264,7 @@ static void handle_tool_proximity(struct wl_listener *listener, void *data) { wlr_idle_notify_activity(desktop->idle, cursor->seat->seat); struct wlr_event_tablet_tool_proximity *event = data; - struct wlr_tablet_tool_tool *tool = event->tool; + struct wlr_tablet_tool *tool = event->tool; if (!tool->data) { struct roots_tablet_tool_tool *roots_tool = calloc(1, sizeof(struct roots_tablet_tool_tool)); diff --git a/types/tablet_v2/wlr_tablet_v2_tablet.c b/types/tablet_v2/wlr_tablet_v2_tablet.c index d3ef4de0..0d1b5aa3 100644 --- a/types/tablet_v2/wlr_tablet_v2_tablet.c +++ b/types/tablet_v2/wlr_tablet_v2_tablet.c @@ -59,13 +59,13 @@ struct wlr_tablet_v2_tablet *wlr_tablet_create( if (!seat) { return NULL; } - struct wlr_tablet_tool *tool = wlr_device->tablet_tool; + 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_tool = tool; + tablet->wlr_tablet = wlr_tablet; tablet->wlr_device = wlr_device; wl_list_init(&tablet->clients); @@ -107,14 +107,15 @@ void add_tablet_client(struct wlr_tablet_seat_client_v2 *seat, zwp_tablet_seat_v2_send_tablet_added(seat->resource, client->resource); // Send the expected events - if (tablet->wlr_tool->name) { - zwp_tablet_v2_send_name(client->resource, tablet->wlr_tool->name); + 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_tool->paths.length; ++i) { + for (size_t i = 0; i < tablet->wlr_tablet->paths.length; ++i) { zwp_tablet_v2_send_path(client->resource, - tablet->wlr_tool->paths.items[i]); + tablet->wlr_tablet->paths.items[i]); } zwp_tablet_v2_send_done(client->resource); diff --git a/types/tablet_v2/wlr_tablet_v2_tool.c b/types/tablet_v2/wlr_tablet_v2_tool.c index 9eefaad7..d254f21a 100644 --- a/types/tablet_v2/wlr_tablet_v2_tool.c +++ b/types/tablet_v2/wlr_tablet_v2_tool.c @@ -192,7 +192,7 @@ static void handle_wlr_tablet_tool_destroy(struct wl_listener *listener, void *d 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_tool *wlr_tool) { + struct wlr_tablet_tool *wlr_tool) { struct wlr_tablet_seat_v2 *seat = get_or_create_tablet_seat(manager, wlr_seat); if (!seat) { return NULL; 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_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_tablet_tool.c b/types/wlr_tablet_tool.c index 85a13832..ca92d4e2 100644 --- a/types/wlr_tablet_tool.c +++ b/types/wlr_tablet_tool.c @@ -4,26 +4,26 @@ #include #include -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; } - wlr_list_for_each(&tool->paths, free); - wlr_list_finish(&tool->paths); + wlr_list_for_each(&tablet->paths, free); + wlr_list_finish(&tablet->paths); - if (tool->impl && tool->impl->destroy) { - tool->impl->destroy(tool); + if (tablet->impl && tablet->impl->destroy) { + tablet->impl->destroy(tablet); } else { - free(tool); + free(tablet); } } -- cgit v1.2.3 From 36955204cf87f723de1deb32da4b774d56bed478 Mon Sep 17 00:00:00 2001 From: Markus Ongyerth Date: Mon, 18 Jun 2018 09:30:24 +0200 Subject: Remove last remnant of tool_tool in libinput --- backend/libinput/tablet_tool.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'backend/libinput/tablet_tool.c') diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index 563338b8..adfc6221 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -43,7 +43,7 @@ struct wlr_libinput_tablet { struct wl_list tools; // tablet_tool_list_elem::link }; -static void destroy_tool_tool(struct wlr_libinput_tablet_tool *tool) { +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); @@ -64,7 +64,7 @@ static void destroy_tablet(struct wlr_tablet *wlr_tablet) { free(pos); if (--tool->pad_refs == 0) { - destroy_tool_tool(tool); + destroy_tool(tool); } } @@ -296,7 +296,7 @@ void handle_tablet_tool_proximity(struct libinput_event *event, } } - destroy_tool_tool(tool); + destroy_tool(tool); } } -- cgit v1.2.3