[PATCH v3 1/2] weston-info: Add support for tablet-unstable-v2

Peter Hutterer peter.hutterer at who-t.net
Mon May 21 03:27:14 UTC 2018


On Mon, Apr 30, 2018 at 11:35:49AM +0200, wl at ongy.net wrote:
> From: Markus Ongyerth <wl at ongy.net>
> 
> This now prints each tablet seat with at least one tablet/pad/tool
> attached.
> For each tablet seat, each tablet, pad and tool is printed with as much
> detail about the device as the protocol provides.
> Seat info is stored to be referenced, because the protocol requires to
> request a tablet_seat for each wl_seat and it's not guaranteed that the
> tablet_v2_manager is available when seats are advertised.
> 
> Signed-off-by: Markus Ongyerth <wl at ongy.net>
> Acked-by: Pekka Paalanen <pekka.paalanen at collabora.co.uk>

Reviewed-by: Peter Hutterer <peter.hutterer at who-t.net>

Cheers,
   Peter

> ---
>  Makefile.am           |  14 +-
>  clients/weston-info.c | 845 ++++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 854 insertions(+), 5 deletions(-)
> 
> diff --git a/Makefile.am b/Makefile.am
> index 69ca6cba..ac0f5471 100644
> --- a/Makefile.am
> +++ b/Makefile.am
> @@ -824,11 +824,13 @@ weston_simple_im_CFLAGS = $(AM_CFLAGS) $(CLIENT_CFLAGS)
>  weston_info_SOURCES = 					\
>  	clients/weston-info.c				\
>  	shared/helpers.h
> -nodist_weston_info_SOURCES =				\
> -	protocol/presentation-time-protocol.c		\
> -	protocol/presentation-time-client-protocol.h	\
> -	protocol/linux-dmabuf-unstable-v1-protocol.c	\
> -	protocol/linux-dmabuf-unstable-v1-client-protocol.h
> +nodist_weston_info_SOURCES =					\
> +	protocol/presentation-time-protocol.c			\
> +	protocol/presentation-time-client-protocol.h		\
> +	protocol/linux-dmabuf-unstable-v1-protocol.c		\
> +	protocol/linux-dmabuf-unstable-v1-client-protocol.h	\
> +	protocol/tablet-unstable-v2-protocol.c			\
> +	protocol/tablet-unstable-v2-client-protocol.h
>  weston_info_LDADD = $(WESTON_INFO_LIBS) libshared.la
>  weston_info_CFLAGS = $(AM_CFLAGS) $(CLIENT_CFLAGS)
>  
> @@ -888,6 +890,8 @@ BUILT_SOURCES +=					\
>  	protocol/ivi-application-client-protocol.h	\
>  	protocol/linux-dmabuf-unstable-v1-protocol.c	\
>  	protocol/linux-dmabuf-unstable-v1-client-protocol.h		\
> +	protocol/tablet-unstable-v2-protocol.c		\
> +	protocol/tablet-unstable-v2-client-protocol.h			\
>  	protocol/input-timestamps-unstable-v1-protocol.c		\
>  	protocol/input-timestamps-unstable-v1-client-protocol.h
>  
> diff --git a/clients/weston-info.c b/clients/weston-info.c
> index 386bd412..6606117a 100644
> --- a/clients/weston-info.c
> +++ b/clients/weston-info.c
> @@ -41,6 +41,7 @@
>  #include "shared/zalloc.h"
>  #include "presentation-time-client-protocol.h"
>  #include "linux-dmabuf-unstable-v1-client-protocol.h"
> +#include "tablet-unstable-v2-client-protocol.h"
>  
>  typedef void (*print_info_t)(void *info);
>  typedef void (*destroy_info_t)(void *info);
> @@ -113,6 +114,7 @@ struct linux_dmabuf_info {
>  
>  struct seat_info {
>  	struct global_info global;
> +	struct wl_list global_link;
>  	struct wl_seat *seat;
>  	struct weston_info *info;
>  
> @@ -123,6 +125,75 @@ struct seat_info {
>  	int32_t repeat_delay;
>  };
>  
> +struct tablet_v2_path {
> +	struct wl_list link;
> +	char *path;
> +};
> +
> +struct tablet_tool_info {
> +	struct wl_list link;
> +	struct zwp_tablet_tool_v2 *tool;
> +
> +	uint64_t hardware_serial;
> +	uint64_t hardware_id_wacom;
> +	enum zwp_tablet_tool_v2_type type;
> +	
> +	bool has_tilt;
> +	bool has_pressure;
> +	bool has_distance;
> +	bool has_rotation;
> +	bool has_slider;
> +	bool has_wheel;
> +};
> +
> +struct tablet_pad_group_info {
> +	struct wl_list link;
> +	struct zwp_tablet_pad_group_v2 *group;
> +
> +	uint32_t modes;
> +	size_t button_count;
> +	int *buttons;
> +	size_t strips;
> +	size_t rings;
> +};
> +
> +struct tablet_pad_info {
> +	struct wl_list link;
> +	struct zwp_tablet_pad_v2 *pad;
> +
> +	uint32_t buttons;
> +	struct wl_list paths;
> +	struct wl_list groups;
> +};
> +
> +struct tablet_info {
> +	struct wl_list link;
> +	struct zwp_tablet_v2 *tablet;
> +
> +	char *name;
> +	uint32_t vid, pid;
> +	struct wl_list paths;
> +};
> +
> +struct tablet_seat_info {
> +	struct wl_list link;
> +
> +	struct zwp_tablet_seat_v2 *seat;
> +	struct seat_info *seat_info;
> +
> +	struct wl_list tablets;
> +	struct wl_list tools;
> +	struct wl_list pads;
> +};
> +
> +struct tablet_v2_info {
> +	struct global_info global;
> +	struct zwp_tablet_manager_v2 *manager;
> +	struct weston_info *info;
> +
> +	struct wl_list seats;
> +};
> +
>  struct presentation_info {
>  	struct global_info global;
>  	struct wp_presentation *presentation;
> @@ -136,6 +207,10 @@ struct weston_info {
>  
>  	struct wl_list infos;
>  	bool roundtrip_needed;
> +
> +	/* required for tablet-unstable-v2 */
> +	struct wl_list seats;
> +	struct tablet_v2_info *tablet_info;
>  };
>  
>  static void
> @@ -455,6 +530,767 @@ destroy_seat_info(void *data)
>  
>  	if (seat->name != NULL)
>  		free(seat->name);
> +
> +	wl_list_remove(&seat->global_link);
> +}
> +
> +static const char *
> +tablet_tool_type_to_str(enum zwp_tablet_tool_v2_type type)
> +{
> +	switch (type) {
> +	case ZWP_TABLET_TOOL_V2_TYPE_PEN:
> +		return "pen";
> +	case ZWP_TABLET_TOOL_V2_TYPE_ERASER:
> +		return "eraser";
> +	case ZWP_TABLET_TOOL_V2_TYPE_BRUSH:
> +		return "brush";
> +	case ZWP_TABLET_TOOL_V2_TYPE_PENCIL:
> +		return "pencil";
> +	case ZWP_TABLET_TOOL_V2_TYPE_AIRBRUSH:
> +		return "airbrush";
> +	case ZWP_TABLET_TOOL_V2_TYPE_FINGER:
> +		return "finger";
> +	case ZWP_TABLET_TOOL_V2_TYPE_MOUSE:
> +		return "mouse";
> +	case ZWP_TABLET_TOOL_V2_TYPE_LENS:
> +		return "lens";
> +	}
> +
> +	return "Unknown type";
> +}
> +
> +static void
> +print_tablet_tool_info(const struct tablet_tool_info *info)
> +{
> +	printf("\t\ttablet_tool: %s\n", tablet_tool_type_to_str(info->type));
> +	if (info->hardware_serial) {
> +		printf("\t\t\thardware serial: %lx\n", info->hardware_serial);
> +	}
> +	if (info->hardware_id_wacom) {
> +		printf("\t\t\thardware wacom: %lx\n", info->hardware_id_wacom);
> +	}
> +
> +	printf("\t\t\tcapabilities:");
> +
> +	if (info->has_tilt) {
> +		printf(" tilt");
> +	}
> +	if (info->has_pressure) {
> +		printf(" pressure");
> +	}
> +	if (info->has_distance) {
> +		printf(" distance");
> +	}
> +	if (info->has_rotation) {
> +		printf(" rotation");
> +	}
> +	if (info->has_slider) {
> +		printf(" slider");
> +	}
> +	if (info->has_wheel) {
> +		printf(" wheel");
> +	}
> +	printf("\n");
> +}
> +
> +static void
> +destroy_tablet_tool_info(struct tablet_tool_info *info)
> +{
> +	wl_list_remove(&info->link);
> +	zwp_tablet_tool_v2_destroy(info->tool);
> +	free(info);
> +}
> +
> +static void
> +print_tablet_pad_group_info(const struct tablet_pad_group_info *info)
> +{
> +	size_t i;
> +	printf("\t\t\tgroup:\n");
> +	printf("\t\t\t\tmodes: %u\n", info->modes);
> +	printf("\t\t\t\tstrips: %zu\n", info->strips);
> +	printf("\t\t\t\trings: %zu\n", info->rings);
> +	printf("\t\t\t\tbuttons:");
> +
> +	for (i = 0; i < info->button_count; ++i) {
> +		printf(" %d", info->buttons[i]);
> +	}
> +
> +	printf("\n");
> +}
> +
> +static void
> +destroy_tablet_pad_group_info(struct tablet_pad_group_info *info)
> +{
> +	wl_list_remove(&info->link);
> +	zwp_tablet_pad_group_v2_destroy(info->group);
> +
> +	if (info->buttons) {
> +		free(info->buttons);
> +	}
> +	free(info);
> +}
> +
> +static void
> +print_tablet_pad_info(const struct tablet_pad_info *info)
> +{
> +	const struct tablet_v2_path *path;
> +	const struct tablet_pad_group_info *group;
> +
> +	printf("\t\tpad:\n");
> +	printf("\t\t\tbuttons: %u\n", info->buttons);
> +
> +	wl_list_for_each(path, &info->paths, link) {
> +		printf("\t\t\tpath: %s\n", path->path);
> +	}
> +
> +	wl_list_for_each(group, &info->groups, link) {
> +		print_tablet_pad_group_info(group);
> +	}
> +}
> +
> +static void
> +destroy_tablet_pad_info(struct tablet_pad_info *info)
> +{
> +	struct tablet_v2_path *path;
> +	struct tablet_v2_path *tmp_path;
> +	struct tablet_pad_group_info *group;
> +	struct tablet_pad_group_info *tmp_group;
> +
> +	wl_list_remove(&info->link);
> +	zwp_tablet_pad_v2_destroy(info->pad);
> +
> +	wl_list_for_each_safe(path, tmp_path, &info->paths, link) {
> +		wl_list_remove(&path->link);
> +		free(path->path);
> +		free(path);
> +	}
> +
> +	wl_list_for_each_safe(group, tmp_group, &info->groups, link) {
> +		destroy_tablet_pad_group_info(group);
> +	}
> +
> +	free(info);
> +}
> +
> +static void
> +print_tablet_info(const struct tablet_info *info)
> +{
> +	const struct tablet_v2_path *path;
> +
> +	printf("\t\ttablet: %s\n", info->name);
> +	printf("\t\t\tvendor: %u\n", info->vid);
> +	printf("\t\t\tproduct: %u\n", info->pid);
> +
> +	wl_list_for_each(path, &info->paths, link) {
> +		printf("\t\t\tpath: %s\n", path->path);
> +	}
> +}
> +
> +static void
> +destroy_tablet_info(struct tablet_info *info)
> +{
> +	struct tablet_v2_path *path;
> +	struct tablet_v2_path *tmp;
> +
> +	wl_list_remove(&info->link);
> +	zwp_tablet_v2_destroy(info->tablet);
> +
> +	if (info->name) {
> +		free(info->name);
> +	}
> +
> +	wl_list_for_each_safe(path, tmp, &info->paths, link) {
> +		wl_list_remove(&path->link);
> +		free(path->path);
> +		free(path);
> +	}
> +
> +	free(info);
> +}
> +
> +static void
> +print_tablet_seat_info(const struct tablet_seat_info *info)
> +{
> +	const struct tablet_info *tablet;
> +	const struct tablet_pad_info *pad;
> +	const struct tablet_tool_info *tool;
> +
> +	printf("\ttablet_seat: %s\n", info->seat_info->name);
> +
> +	wl_list_for_each(tablet, &info->tablets, link) {
> +		print_tablet_info(tablet);
> +	}
> +
> +	wl_list_for_each(pad, &info->pads, link) {
> +		print_tablet_pad_info(pad);
> +	}
> +
> +	wl_list_for_each(tool, &info->tools, link) {
> +		print_tablet_tool_info(tool);
> +	}
> +}
> +
> +static void
> +destroy_tablet_seat_info(struct tablet_seat_info *info)
> +{
> +	struct tablet_info *tablet;
> +	struct tablet_info *tmp_tablet;
> +	struct tablet_pad_info *pad;
> +	struct tablet_pad_info *tmp_pad;
> +	struct tablet_tool_info *tool;
> +	struct tablet_tool_info *tmp_tool;
> +
> +	wl_list_remove(&info->link);
> +	zwp_tablet_seat_v2_destroy(info->seat);
> +
> +	wl_list_for_each_safe(tablet, tmp_tablet, &info->tablets, link) {
> +		destroy_tablet_info(tablet);
> +	}
> +
> +	wl_list_for_each_safe(pad, tmp_pad, &info->pads, link) {
> +		destroy_tablet_pad_info(pad);
> +	}
> +
> +	wl_list_for_each_safe(tool, tmp_tool, &info->tools, link) {
> +		destroy_tablet_tool_info(tool);
> +	}
> +
> +	free(info);
> +}
> +
> +static void
> +print_tablet_v2_info(void *data)
> +{
> +	struct tablet_v2_info *info = data;
> +	struct tablet_seat_info *seat;
> +	print_global_info(data);
> +
> +	wl_list_for_each(seat, &info->seats, link) {
> +		/* Skip tablet_seats without a tablet, they are irrelevant */
> +		if (wl_list_empty(&seat->pads) &&
> +		    wl_list_empty(&seat->tablets) &&
> +		    wl_list_empty(&seat->tools)) {
> +			continue;
> +		}
> +
> +		print_tablet_seat_info(seat);
> +	}
> +}
> +
> +static void
> +destroy_tablet_v2_info(void *data)
> +{
> +	struct tablet_v2_info *info = data;
> +	struct tablet_seat_info *seat;
> +	struct tablet_seat_info *tmp;
> +
> +	zwp_tablet_manager_v2_destroy(info->manager);
> +
> +	wl_list_for_each_safe(seat, tmp, &info->seats, link) {
> +		destroy_tablet_seat_info(seat);
> +	}
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_done(void *data, struct zwp_tablet_tool_v2 *tool)
> +{
> +	/* don't bother waiting for this; there's no good reason a
> +	 * compositor will wait more than one roundtrip before sending
> +	 * these initial events. */
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_removed(void *data, struct zwp_tablet_tool_v2 *tool)
> +{
> +	/* don't bother waiting for this; we never make any request either way. */
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_type(void *data, struct zwp_tablet_tool_v2 *tool,
> +                                  uint32_t tool_type)
> +{
> +	struct tablet_tool_info *info = data;
> +	info->type = tool_type;
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_hardware_serial(void *data,
> +                                             struct zwp_tablet_tool_v2 *tool,
> +                                             uint32_t serial_hi,
> +                                             uint32_t serial_lo)
> +{
> +	struct tablet_tool_info *info = data;
> +
> +	info->hardware_serial = ((uint64_t) serial_hi) << 32 |
> +		(uint64_t) serial_lo;
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_hardware_id_wacom(void *data,
> +                                               struct zwp_tablet_tool_v2 *tool,
> +                                               uint32_t id_hi, uint32_t id_lo)
> +{
> +	struct tablet_tool_info *info = data;
> +
> +	info->hardware_id_wacom = ((uint64_t) id_hi) << 32 | (uint64_t) id_lo;
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_capability(void *data,
> +                                        struct zwp_tablet_tool_v2 *tool,
> +                                        uint32_t capability)
> +{
> +	struct tablet_tool_info *info = data;
> +	enum zwp_tablet_tool_v2_capability cap = capability;
> +	
> +	switch(cap) {
> +	case ZWP_TABLET_TOOL_V2_CAPABILITY_TILT:
> +		info->has_tilt = true;
> +		break;
> +	case ZWP_TABLET_TOOL_V2_CAPABILITY_PRESSURE:
> +		info->has_pressure = true;
> +		break;
> +	case ZWP_TABLET_TOOL_V2_CAPABILITY_DISTANCE:
> +		info->has_distance = true;
> +		break;
> +	case ZWP_TABLET_TOOL_V2_CAPABILITY_ROTATION:
> +		info->has_rotation = true;
> +		break;
> +	case ZWP_TABLET_TOOL_V2_CAPABILITY_SLIDER:
> +		info->has_slider = true;
> +		break;
> +	case ZWP_TABLET_TOOL_V2_CAPABILITY_WHEEL:
> +		info->has_wheel = true;
> +		break;
> +	}
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_proximity_in(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
> +                                 uint32_t serial, struct zwp_tablet_v2 *tablet,
> +                                 struct wl_surface *surface)
> +{
> +
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_proximity_out(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2)
> +{
> +
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_down(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
> +                                 uint32_t serial)
> +{
> +
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_up(void *data,
> +                                struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2)
> +{
> +
> +}
> +
> +
> +static void
> +handle_tablet_v2_tablet_tool_motion(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
> +                                 wl_fixed_t x,
> +                                 wl_fixed_t y)
> +{
> +
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_pressure(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
> +                                 uint32_t pressure)
> +{
> +
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_distance(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
> +                                 uint32_t distance)
> +{
> +
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_tilt(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
> +                                 wl_fixed_t tilt_x,
> +                                 wl_fixed_t tilt_y)
> +{
> +
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_rotation(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
> +                                 wl_fixed_t degrees)
> +{
> +
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_slider(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
> +                                 int32_t position)
> +{
> +
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_wheel(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
> +                                 wl_fixed_t degrees,
> +                                 int32_t clicks)
> +{
> +
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_button(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
> +                                 uint32_t serial,
> +                                 uint32_t button,
> +                                 uint32_t state)
> +{
> +
> +}
> +
> +static void
> +handle_tablet_v2_tablet_tool_frame(void *data,
> +                                 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
> +                                 uint32_t time)
> +{
> +
> +}
> +
> +static const struct zwp_tablet_tool_v2_listener tablet_tool_listener = {
> +	.removed = handle_tablet_v2_tablet_tool_removed,
> +	.done = handle_tablet_v2_tablet_tool_done,
> +	.type = handle_tablet_v2_tablet_tool_type,
> +	.hardware_serial = handle_tablet_v2_tablet_tool_hardware_serial,
> +	.hardware_id_wacom = handle_tablet_v2_tablet_tool_hardware_id_wacom,
> +	.capability = handle_tablet_v2_tablet_tool_capability,
> +
> +	.proximity_in = handle_tablet_v2_tablet_tool_proximity_in,
> +	.proximity_out = handle_tablet_v2_tablet_tool_proximity_out,
> +	.down = handle_tablet_v2_tablet_tool_down,
> +	.up = handle_tablet_v2_tablet_tool_up,
> +
> +	.motion = handle_tablet_v2_tablet_tool_motion,
> +	.pressure = handle_tablet_v2_tablet_tool_pressure,
> +	.distance = handle_tablet_v2_tablet_tool_distance,
> +	.tilt = handle_tablet_v2_tablet_tool_tilt,
> +	.rotation = handle_tablet_v2_tablet_tool_rotation,
> +	.slider = handle_tablet_v2_tablet_tool_slider,
> +	.wheel = handle_tablet_v2_tablet_tool_wheel,
> +	.button = handle_tablet_v2_tablet_tool_button,
> +	.frame = handle_tablet_v2_tablet_tool_frame,
> +};
> +
> +static void add_tablet_v2_tablet_tool_info(void *data,
> +                                     struct zwp_tablet_seat_v2 *tablet_seat_v2,
> +                                     struct zwp_tablet_tool_v2 *tool)
> +{
> +	struct tablet_seat_info *tablet_seat = data;
> +	struct tablet_tool_info *tool_info = xzalloc(sizeof *tool_info);
> +
> +	tool_info->tool = tool;
> +	wl_list_insert(&tablet_seat->tools, &tool_info->link);
> +
> +	zwp_tablet_tool_v2_add_listener(tool, &tablet_tool_listener, tool_info);
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_group_mode_switch(void *data,
> +                       struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2,
> +                       uint32_t time, uint32_t serial, uint32_t mode)
> +{
> +	/* This shouldn't ever happen  */
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_group_done(void *data,
> +                                       struct zwp_tablet_pad_group_v2 *group)
> +{
> +	/* don't bother waiting for this; there's no good reason a
> +	 * compositor will wait more than one roundtrip before sending
> +	 * these initial events. */
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_group_modes(void *data,
> +                                        struct zwp_tablet_pad_group_v2 *group,
> +                                        uint32_t modes)
> +{
> +	struct tablet_pad_group_info *info = data;
> +	info->modes = modes;
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_group_buttons(void *data,
> +                                          struct zwp_tablet_pad_group_v2 *group,
> +                                          struct wl_array *buttons)
> +{
> +	struct tablet_pad_group_info *info = data;
> +
> +	info->button_count = buttons->size / sizeof(int);
> +	info->buttons = xzalloc(buttons->size);
> +	memcpy(info->buttons, buttons->data, buttons->size);
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_group_ring(void *data,
> +                                       struct zwp_tablet_pad_group_v2 *group,
> +                                       struct zwp_tablet_pad_ring_v2 *ring)
> +{
> +	struct tablet_pad_group_info *info = data;
> +	++info->rings;
> +
> +	zwp_tablet_pad_ring_v2_destroy(ring);
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_group_strip(void *data,
> +                                        struct zwp_tablet_pad_group_v2 *group,
> +                                        struct zwp_tablet_pad_strip_v2 *strip)
> +{
> +	struct tablet_pad_group_info *info = data;
> +	++info->strips;
> +
> +	zwp_tablet_pad_strip_v2_destroy(strip);
> +}
> +
> +static const struct zwp_tablet_pad_group_v2_listener tablet_pad_group_listener = {
> +	.buttons = handle_tablet_v2_tablet_pad_group_buttons,
> +	.modes = handle_tablet_v2_tablet_pad_group_modes,
> +	.ring = handle_tablet_v2_tablet_pad_group_ring,
> +	.strip = handle_tablet_v2_tablet_pad_group_strip,
> +	.done = handle_tablet_v2_tablet_pad_group_done,
> +	.mode_switch = handle_tablet_v2_tablet_pad_group_mode_switch,
> +};
> +
> +static void
> +handle_tablet_v2_tablet_pad_group(void *data,
> +                                  struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
> +                                  struct zwp_tablet_pad_group_v2 *pad_group)
> +{
> +	struct tablet_pad_info *pad_info = data;
> +	struct tablet_pad_group_info *group = xzalloc(sizeof *group);
> +
> +	wl_list_insert(&pad_info->groups, &group->link);
> +	group->group = pad_group;
> +	zwp_tablet_pad_group_v2_add_listener(pad_group,
> +	                                     &tablet_pad_group_listener, group);
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_path(void *data, struct zwp_tablet_pad_v2 *pad,
> +                                 const char *path)
> +{
> +	struct tablet_pad_info *pad_info = data;
> +	struct tablet_v2_path *path_elem = xzalloc(sizeof *path_elem);
> +	path_elem->path = xstrdup(path);
> +
> +	wl_list_insert(&pad_info->paths, &path_elem->link);
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_buttons(void *data, struct zwp_tablet_pad_v2 *pad,
> +                                    uint32_t buttons)
> +{
> +	struct tablet_pad_info *pad_info = data;
> +
> +	pad_info->buttons = buttons;
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_done(void *data, struct zwp_tablet_pad_v2 *pad)
> +{
> +	/* don't bother waiting for this; there's no good reason a
> +	 * compositor will wait more than one roundtrip before sending
> +	 * these initial events. */
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_removed(void *data, struct zwp_tablet_pad_v2 *pad)
> +{
> +	/* don't bother waiting for this; We never make any request that's not
> +	 * allowed to be issued either way. */
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_button(void *data, struct zwp_tablet_pad_v2 *pad,
> +                                   uint32_t time, uint32_t button, uint32_t state)
> +{
> +	/* we don't have a surface, so this can't ever happen */
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_enter(void *data, struct zwp_tablet_pad_v2 *pad,
> +                                  uint32_t serial,
> +                                  struct zwp_tablet_v2 *tablet,
> +                                  struct wl_surface *surface)
> +{
> +	/* we don't have a surface, so this can't ever happen */
> +}
> +
> +static void
> +handle_tablet_v2_tablet_pad_leave(void *data, struct zwp_tablet_pad_v2 *pad,
> +		uint32_t serial, struct wl_surface *surface)
> +{
> +	/* we don't have a surface, so this can't ever happen */
> +}
> +
> +static const struct zwp_tablet_pad_v2_listener tablet_pad_listener = {
> +	.group = handle_tablet_v2_tablet_pad_group,
> +	.path = handle_tablet_v2_tablet_pad_path,
> +	.buttons = handle_tablet_v2_tablet_pad_buttons,
> +	.done = handle_tablet_v2_tablet_pad_done,
> +	.removed = handle_tablet_v2_tablet_pad_removed,
> +	.button = handle_tablet_v2_tablet_pad_button,
> +	.enter = handle_tablet_v2_tablet_pad_enter,
> +	.leave = handle_tablet_v2_tablet_pad_leave,
> +};
> +
> +static void add_tablet_v2_tablet_pad_info(void *data,
> +                                     struct zwp_tablet_seat_v2 *tablet_seat_v2,
> +                                     struct zwp_tablet_pad_v2 *pad)
> +{
> +	struct tablet_seat_info *tablet_seat = data;
> +	struct tablet_pad_info *pad_info = xzalloc(sizeof *pad_info);
> +
> +	wl_list_init(&pad_info->paths);
> +	wl_list_init(&pad_info->groups);
> +	pad_info->pad = pad;
> +	wl_list_insert(&tablet_seat->pads, &pad_info->link);
> +
> +	zwp_tablet_pad_v2_add_listener(pad, &tablet_pad_listener, pad_info);
> +}
> +
> +static void
> +handle_tablet_v2_tablet_name(void *data, struct zwp_tablet_v2 *zwp_tablet_v2,
> +                             const char *name)
> +{
> +	struct tablet_info *tablet_info = data;
> +	tablet_info->name = xstrdup(name);
> +}
> +
> +static void
> +handle_tablet_v2_tablet_path(void *data, struct zwp_tablet_v2 *zwp_tablet_v2,
> +                             const char *path)
> +{
> +	struct tablet_info *tablet_info = data;
> +	struct tablet_v2_path *path_elem = xzalloc(sizeof *path_elem);
> +	path_elem->path = xstrdup(path);
> +
> +	wl_list_insert(&tablet_info->paths, &path_elem->link);
> +}
> +
> +static void
> +handle_tablet_v2_tablet_id(void *data, struct zwp_tablet_v2 *zwp_tablet_v2,
> +                           uint32_t vid, uint32_t pid)
> +{
> +	struct tablet_info *tablet_info = data;
> +
> +	tablet_info->vid = vid;
> +	tablet_info->pid = pid;
> +}
> +
> +static void
> +handle_tablet_v2_tablet_done(void *data, struct zwp_tablet_v2 *zwp_tablet_v2)
> +{
> +	/* don't bother waiting for this; there's no good reason a
> +	 * compositor will wait more than one roundtrip before sending
> +	 * these initial events. */
> +}
> +
> +static void
> +handle_tablet_v2_tablet_removed(void *data, struct zwp_tablet_v2 *zwp_tablet_v2)
> +{
> +	/* don't bother waiting for this; We never make any request that's not
> +	 * allowed to be issued either way. */
> +}
> +
> +static const struct zwp_tablet_v2_listener tablet_listener = {
> +	.name = handle_tablet_v2_tablet_name,
> +	.id = handle_tablet_v2_tablet_id,
> +	.path = handle_tablet_v2_tablet_path,
> +	.done = handle_tablet_v2_tablet_done,
> +	.removed = handle_tablet_v2_tablet_removed
> +};
> +
> +static void
> +add_tablet_v2_tablet_info(void *data, struct zwp_tablet_seat_v2 *tablet_seat_v2,
> +                          struct zwp_tablet_v2 *tablet)
> +{
> +	struct tablet_seat_info *tablet_seat = data;
> +	struct tablet_info *tablet_info = xzalloc(sizeof *tablet_info);
> +
> +	wl_list_init(&tablet_info->paths);
> +	tablet_info->tablet = tablet;
> +	wl_list_insert(&tablet_seat->tablets, &tablet_info->link);
> +
> +	zwp_tablet_v2_add_listener(tablet, &tablet_listener, tablet_info);
> +}
> +
> +static const struct zwp_tablet_seat_v2_listener tablet_seat_listener =  {
> +	.tablet_added = add_tablet_v2_tablet_info,
> +	.pad_added = add_tablet_v2_tablet_pad_info,
> +	.tool_added = add_tablet_v2_tablet_tool_info,
> +};
> +
> +static void
> +add_tablet_seat_info(struct tablet_v2_info *tablet_info, struct seat_info *seat)
> +{
> +	struct tablet_seat_info *tablet_seat = xzalloc(sizeof *tablet_seat);
> +
> +	wl_list_insert(&tablet_info->seats, &tablet_seat->link);
> +	tablet_seat->seat = zwp_tablet_manager_v2_get_tablet_seat(
> +		tablet_info->manager, seat->seat);
> +	zwp_tablet_seat_v2_add_listener(tablet_seat->seat,
> +		&tablet_seat_listener, tablet_seat);
> +
> +	wl_list_init(&tablet_seat->pads);
> +	wl_list_init(&tablet_seat->tablets);
> +	wl_list_init(&tablet_seat->tools);
> +	tablet_seat->seat_info = seat;
> +
> +	tablet_info->info->roundtrip_needed = true;
> +}
> +
> +static void
> +add_tablet_v2_info(struct weston_info *info, uint32_t id, uint32_t version)
> +{
> +	struct seat_info *seat;
> +	struct tablet_v2_info *tablet = xzalloc(sizeof *tablet);
> +
> +	wl_list_init(&tablet->seats);
> +	tablet->info = info;
> +
> +	init_global_info(info, &tablet->global, id,
> +		zwp_tablet_manager_v2_interface.name, version);
> +	tablet->global.print = print_tablet_v2_info;
> +	tablet->global.destroy = destroy_tablet_v2_info;
> +
> +	tablet->manager = wl_registry_bind(info->registry,
> +		id, &zwp_tablet_manager_v2_interface, 1);
> +
> +	wl_list_for_each(seat, &info->seats, global_link) {
> +		add_tablet_seat_info(tablet, seat);
> +	}
> +
> +	info->tablet_info = tablet;
>  }
>  
>  static void
> @@ -477,6 +1313,11 @@ add_seat_info(struct weston_info *info, uint32_t id, uint32_t version)
>  	seat->repeat_rate = seat->repeat_delay = -1;
>  
>  	info->roundtrip_needed = true;
> +	wl_list_insert(&info->seats, &seat->global_link);
> +
> +	if (info->tablet_info) {
> +		add_tablet_seat_info(info->tablet_info, seat);
> +	}
>  }
>  
>  static void
> @@ -784,6 +1625,8 @@ global_handler(void *data, struct wl_registry *registry, uint32_t id,
>  		add_output_info(info, id, version);
>  	else if (!strcmp(interface, wp_presentation_interface.name))
>  		add_presentation_info(info, id, version);
> +	else if (!strcmp(interface, zwp_tablet_manager_v2_interface.name))
> +		add_tablet_v2_info(info, id, version);
>  	else
>  		add_global_info(info, id, interface, version);
>  }
> @@ -837,7 +1680,9 @@ main(int argc, char **argv)
>  		return -1;
>  	}
>  
> +	info.tablet_info = NULL;
>  	wl_list_init(&info.infos);
> +	wl_list_init(&info.seats);
>  
>  	info.registry = wl_display_get_registry(info.display);
>  	wl_registry_add_listener(info.registry, &registry_listener, &info);
> -- 
> 2.17.0
> 
> _______________________________________________
> wayland-devel mailing list
> wayland-devel at lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/wayland-devel
> 


More information about the wayland-devel mailing list