weston-info: Add support for tablet-unstable-v2

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@ongy.net>
Acked-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>
Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>

2 files changed, 854 insertions, 5 deletions

diff --git a/Makefile.am b/Makefile.am
index 64a8006c..d9c03fef 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -825,11 +825,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)
 
@@ -889,6 +891,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);