configure.ac: libinput 1.6.1

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>

configure.ac

@@ -2,7 +2,7 @@ AC_PREREQ([2.64])
 
 m4_define([libinput_major_version], [1])
 m4_define([libinput_minor_version], [6])
-m4_define([libinput_micro_version], [0])
+m4_define([libinput_micro_version], [1])
 m4_define([libinput_version],
           [libinput_major_version.libinput_minor_version.libinput_micro_version])
 
@@ -35,7 +35,7 @@ AM_INIT_AUTOMAKE([1.11 foreign no-dist-gzip dist-xz])
 # b) If interfaces have been changed or added, but binary compatibility has
 #    been preserved, change to C+1:0:A+1
 # c) If the interface is the same as the previous version, change to C:R+1:A
-LIBINPUT_LT_VERSION=21:2:11
+LIBINPUT_LT_VERSION=21:3:11
 AC_SUBST(LIBINPUT_LT_VERSION)
 
 AM_SILENT_RULES([yes])
@@ -232,7 +232,7 @@ AC_ARG_ENABLE(libwacom,
 	      [use_libwacom="$enableval"],
 	      [use_libwacom="yes"])
 if test "x$use_libwacom" = "xyes"; then
-	PKG_CHECK_MODULES(LIBWACOM, [libwacom >= 0.12], [HAVE_LIBWACOM="yes"])
+	PKG_CHECK_MODULES(LIBWACOM, [libwacom >= 0.20], [HAVE_LIBWACOM="yes"])
 	AC_DEFINE(HAVE_LIBWACOM, 1, [Build with libwacom])
 
 	OLD_LIBS=$LIBS

doc/faqs.dox

@@ -3,6 +3,8 @@
 
 Frequently asked questions about libinput.
 
+@tableofcontents
+
 @section faq_fast_mouse My mouse moves too fast, even at the slowest setting
 
 This is a symptom of high-dpi mice (greater than 1000dpi). These devices
@@ -40,12 +42,20 @@ manage these and decide which configuration option to apply to each device.
 This must be done at startup, after a resume and whenever a new device is
 detected.
 
-In a GNOME X.Org stack a user would usually toggle an option in
-the gnome-control-center which adjusts a gsettings entry. That change is
-picked up by gnome-settings-daemon and applied to the device by adjusting
-input device properties that the xf86-input-libinput driver provides.
-The input device property changes map to the respective libinput
-configuration options.
+One commonly used way to configure libinput is to have the Wayland
+compositor expose a compositor-specific configuration option. For example,
+in a GNOME stack, the gnome-control-center modifies dconf entries. These
+changes are read by mutter and applied to libinput. Changing these entries
+via the gsettings commandline tool has the same effect.
+
+Another commonly used way to configure libinput is to have xorg.conf.d
+snippets. When libinput is used with the xf86-input-libinput driver in an
+X.Org stack, these options are read on startup and apply to each device.
+Changing properties at runtime with the xinput commandline tool has the same
+effect.
+
+In both cases, the selection of available options and how they are exposed
+depends on the libinput caller (e.g. mutter or xf86-input-libinput).
 
 @dotfile libinput-stack-gnome.gv
 

src/evdev-mt-touchpad-tap.c

@@ -33,7 +33,6 @@
 
 #include "evdev-mt-touchpad.h"
 
-#define DEFAULT_TAP_INITIAL_TIMEOUT_PERIOD ms2us(100)
 #define DEFAULT_TAP_TIMEOUT_PERIOD ms2us(180)
 #define DEFAULT_DRAG_TIMEOUT_PERIOD ms2us(300)
 #define DEFAULT_TAP_MOVE_THRESHOLD TP_MM_TO_DPI_NORMALIZED(1.3)
@@ -127,13 +126,6 @@ tp_tap_notify(struct tp_dispatch *tp,
 				    state);
 }
 
-static void
-tp_tap_set_initial_timer(struct tp_dispatch *tp, uint64_t time)
-{
-	libinput_timer_set(&tp->tap.timer,
-			   time + DEFAULT_TAP_INITIAL_TIMEOUT_PERIOD);
-}
-
 static void
 tp_tap_set_timer(struct tp_dispatch *tp, uint64_t time)
 {
@@ -163,7 +155,7 @@ tp_tap_idle_handle_event(struct tp_dispatch *tp,
 	case TAP_EVENT_TOUCH:
 		tp->tap.state = TAP_STATE_TOUCH;
 		tp->tap.first_press_time = time;
-		tp_tap_set_initial_timer(tp, time);
+		tp_tap_set_timer(tp, time);
 		break;
 	case TAP_EVENT_RELEASE:
 		break;

src/evdev-tablet-pad-leds.c

@@ -29,14 +29,143 @@
 
 #include "evdev-tablet-pad.h"
 
+#if HAVE_LIBWACOM
+#include <libwacom/libwacom.h>
+#endif
+
 struct pad_led_group {
 	struct libinput_tablet_pad_mode_group base;
+	struct list led_list;
+	struct list toggle_button_list;
 };
 
+struct pad_mode_toggle_button {
+	struct list link;
+	unsigned int button_index;
+};
+
+struct pad_mode_led {
+	struct list link;
+	/* /sys/devices/..../input1235/input1235::wacom-led_0.1/brightness */
+	int brightness_fd;
+	int mode_idx;
+};
+
+static inline struct pad_mode_toggle_button *
+pad_mode_toggle_button_new(struct pad_dispatch *pad,
+			   struct libinput_tablet_pad_mode_group *group,
+			   unsigned int button_index)
+{
+	struct pad_mode_toggle_button *button;
+
+	button = zalloc(sizeof *button);
+	if (!button)
+		return NULL;
+
+	button->button_index = button_index;
+
+	return button;
+}
+
+static inline void
+pad_mode_toggle_button_destroy(struct pad_mode_toggle_button* button)
+{
+	list_remove(&button->link);
+	free(button);
+}
+
+static inline int
+pad_led_group_get_mode(struct pad_led_group *group)
+{
+	char buf[4] = {0};
+	int rc;
+	unsigned int brightness;
+	struct pad_mode_led *led;
+
+	list_for_each(led, &group->led_list, link) {
+		rc = lseek(led->brightness_fd, 0, SEEK_SET);
+		if (rc == -1)
+			return -errno;
+
+		rc = read(led->brightness_fd, buf, sizeof(buf) - 1);
+		if (rc == -1)
+			return -errno;
+
+		rc = sscanf(buf, "%u\n", &brightness);
+		if (rc != 1)
+			return -EINVAL;
+
+		/* Assumption: only one LED lit up at any time */
+		if (brightness != 0)
+			return led->mode_idx;
+	}
+
+	return -EINVAL;
+}
+
+static inline void
+pad_led_destroy(struct libinput *libinput,
+		struct pad_mode_led *led)
+{
+	list_remove(&led->link);
+	if (led->brightness_fd != -1)
+		close_restricted(libinput, led->brightness_fd);
+	free(led);
+}
+
+static inline struct pad_mode_led *
+pad_led_new(struct libinput *libinput, const char *prefix, int group, int mode)
+{
+	struct pad_mode_led *led;
+	char path[PATH_MAX];
+	int rc, fd;
+
+	led = zalloc(sizeof *led);
+	if (!led)
+		return NULL;
+
+	led->brightness_fd = -1;
+	led->mode_idx = mode;
+	list_init(&led->link);
+
+	/* /sys/devices/..../input1235/input1235::wacom-0.1/brightness,
+	 * where 0 and 1 are group and mode index. */
+	rc = snprintf(path,
+		      sizeof(path),
+		      "%s%d.%d/brightness",
+		      prefix,
+		      group,
+		      mode);
+	if (rc == -1)
+		goto error;
+
+	fd = open_restricted(libinput, path, O_RDONLY);
+	if (fd < 0) {
+		errno = -fd;
+		goto error;
+	}
+
+	led->brightness_fd = fd;
+
+	return led;
+
+error:
+	pad_led_destroy(libinput, led);
+	return NULL;
+}
+
 static void
 pad_led_group_destroy(struct libinput_tablet_pad_mode_group *g)
 {
 	struct pad_led_group *group = (struct pad_led_group *)g;
+	struct pad_mode_toggle_button *button, *tmp;
+	struct pad_mode_led *led, *tmpled;
+
+	list_for_each_safe(button, tmp, &group->toggle_button_list, link)
+		pad_mode_toggle_button_destroy(button);
+
+	list_for_each_safe(led, tmpled, &group->led_list, link)
+		pad_led_destroy(g->device->seat->libinput, led);
 
 	free(group);
 }
@@ -58,10 +187,154 @@ pad_group_new_basic(struct pad_dispatch *pad,
 	group->base.current_mode = 0;
 	group->base.num_modes = nleds;
 	group->base.destroy = pad_led_group_destroy;
+	list_init(&group->toggle_button_list);
+	list_init(&group->led_list);
 
 	return group;
 }
 
+static inline struct pad_led_group *
+pad_group_new(struct pad_dispatch *pad,
+	      unsigned int group_index,
+	      int nleds,
+	      const char *syspath)
+{
+	struct libinput *libinput = pad->device->base.seat->libinput;
+	struct pad_led_group *group;
+	int rc;
+
+	group = pad_group_new_basic(pad, group_index, nleds);
+	if (!group)
+		return NULL;
+
+	while (nleds--) {
+		struct pad_mode_led *led;
+
+		led = pad_led_new(libinput, syspath, group_index, nleds);
+		if (!led)
+			goto error;
+
+		list_insert(&group->led_list, &led->link);
+	}
+
+	rc = pad_led_group_get_mode(group);
+	if (rc < 0) {
+		errno = -rc;
+		goto error;
+	}
+
+	group->base.current_mode = rc;
+
+	return group;
+
+error:
+	log_error(libinput, "Unable to init LED group: %s\n", strerror(errno));
+	pad_led_group_destroy(&group->base);
+
+	return NULL;
+}
+
+static inline bool
+pad_led_get_sysfs_base_path(struct evdev_device *device,
+			    char *path_out,
+			    size_t path_out_sz)
+{
+	struct udev_device *parent, *udev_device;
+	const char *test_path;
+	int rc;
+
+	udev_device = device->udev_device;
+
+	/* For testing purposes only allow for a base path set through a
+	 * udev rule. We still expect the normal directory hierarchy inside */
+	test_path = udev_device_get_property_value(udev_device,
+						   "LIBINPUT_TEST_TABLET_PAD_SYSFS_PATH");
+	if (test_path) {
+		rc = snprintf(path_out, path_out_sz, "%s", test_path);
+		return rc != -1;
+	}
+
+	parent = udev_device_get_parent_with_subsystem_devtype(udev_device,
+							       "input",
+							       NULL);
+	if (!parent)
+		return false;
+
+	rc = snprintf(path_out,
+		      path_out_sz,
+		      "%s/%s::wacom-",
+		      udev_device_get_syspath(parent),
+		      udev_device_get_sysname(parent));
+
+	return rc != -1;
+}
+
+#if HAVE_LIBWACOM
+static int
+pad_init_led_groups(struct pad_dispatch *pad,
+		    struct evdev_device *device,
+		    WacomDevice *wacom)
+{
+	struct libinput *libinput = device->base.seat->libinput;
+	const WacomStatusLEDs *leds;
+	int nleds, nmodes;
+	int i;
+	struct pad_led_group *group;
+	char syspath[PATH_MAX];
+
+	leds = libwacom_get_status_leds(wacom, &nleds);
+	if (nleds == 0)
+		return 1;
+
+	/* syspath is /sys/class/leds/input1234/input12345::wacom-" and
+	   only needs the group + mode appended */
+	if (!pad_led_get_sysfs_base_path(device, syspath, sizeof(syspath)))
+		return 1;
+
+	for (i = 0; i < nleds; i++) {
+		switch(leds[i]) {
+		case WACOM_STATUS_LED_UNAVAILABLE:
+			log_bug_libinput(libinput,
+					 "Invalid led type %d\n",
+					 leds[i]);
+			return 1;
+		case WACOM_STATUS_LED_RING:
+			nmodes = libwacom_get_ring_num_modes(wacom);
+			group = pad_group_new(pad, i, nmodes, syspath);
+			if (!group)
+				return 1;
+			list_insert(&pad->modes.mode_group_list, &group->base.link);
+			break;
+		case WACOM_STATUS_LED_RING2:
+			nmodes = libwacom_get_ring2_num_modes(wacom);
+			group = pad_group_new(pad, i, nmodes, syspath);
+			if (!group)
+				return 1;
+			list_insert(&pad->modes.mode_group_list, &group->base.link);
+			break;
+		case WACOM_STATUS_LED_TOUCHSTRIP:
+			nmodes = libwacom_get_strips_num_modes(wacom);
+			group = pad_group_new(pad, i, nmodes, syspath);
+			if (!group)
+				return 1;
+			list_insert(&pad->modes.mode_group_list, &group->base.link);
+			break;
+		case WACOM_STATUS_LED_TOUCHSTRIP2:
+			/* there is no get_strips2_... */
+			nmodes = libwacom_get_strips_num_modes(wacom);
+			group = pad_group_new(pad, i, nmodes, syspath);
+			if (!group)
+				return 1;
+			list_insert(&pad->modes.mode_group_list, &group->base.link);
+			break;
+		}
+	}
+
+	return 0;
+}
+
+#endif
+
 static inline struct libinput_tablet_pad_mode_group *
 pad_get_mode_group(struct pad_dispatch *pad, unsigned int index)
 {
@@ -75,6 +348,192 @@ pad_get_mode_group(struct pad_dispatch *pad, unsigned int index)
 	return NULL;
 }
 
+#if HAVE_LIBWACOM
+
+static inline int
+pad_find_button_group(WacomDevice *wacom,
+		      int button_index,
+		      WacomButtonFlags button_flags)
+{
+	int i;
+	WacomButtonFlags flags;
+
+	for (i = 0; i < libwacom_get_num_buttons(wacom); i++) {
+		if (i == button_index)
+			continue;
+
+		flags = libwacom_get_button_flag(wacom, 'A' + i);
+		if ((flags & WACOM_BUTTON_MODESWITCH) == 0)
+			continue;
+
+		if ((flags & WACOM_BUTTON_DIRECTION) ==
+			(button_flags & WACOM_BUTTON_DIRECTION))
+			return libwacom_get_button_led_group(wacom, 'A' + i);
+	}
+
+	return -1;
+}
+
+static int
+pad_init_mode_buttons(struct pad_dispatch *pad,
+		      WacomDevice *wacom)
+{
+	struct libinput *libinput = pad_libinput_context(pad);
+	struct libinput_tablet_pad_mode_group *group;
+	unsigned int group_idx;
+	int i;
+	WacomButtonFlags flags;
+
+	/* libwacom numbers buttons as 'A', 'B', etc. We number them with 0,
+	 * 1, ...
+	 */
+	for (i = 0; i < libwacom_get_num_buttons(wacom); i++) {
+		group_idx = libwacom_get_button_led_group(wacom, 'A' + i);
+		flags = libwacom_get_button_flag(wacom, 'A' + i);
+
+		/* If this button is not a mode toggle button, find the mode
+		 * toggle button with the same position flags and take that
+		 * button's group idx */
+		if ((int)group_idx == -1) {
+			group_idx = pad_find_button_group(wacom, i, flags);
+		}
+
+		if ((int)group_idx == -1) {
+			log_bug_libinput(libinput,
+					 "%s: unhandled position for button %i\n",
+					 pad->device->devname,
+					 i);
+			return 1;
+		}
+
+		group = pad_get_mode_group(pad, group_idx);
+		if (!group) {
+			log_bug_libinput(libinput,
+					 "%s: Failed to find group %d for button %i\n",
+					 pad->device->devname,
+					 group_idx,
+					 i);
+			return 1;
+		}
+
+		group->button_mask |= 1 << i;
+
+		if (flags & WACOM_BUTTON_MODESWITCH) {
+			struct pad_mode_toggle_button *b;
+			struct pad_led_group *g;
+
+			b = pad_mode_toggle_button_new(pad, group, i);
+			if (!b)
+				return 1;
+			g = (struct pad_led_group*)group;
+			list_insert(&g->toggle_button_list, &b->link);
+			group->toggle_button_mask |= 1 << i;
+		}
+	}
+
+	return 0;
+}
+
+static void
+pad_init_mode_rings(struct pad_dispatch *pad, WacomDevice *wacom)
+{
+	struct libinput_tablet_pad_mode_group *group;
+	const WacomStatusLEDs *leds;
+	int i, nleds;
+
+	leds = libwacom_get_status_leds(wacom, &nleds);
+	if (nleds == 0)
+		return;
+
+	for (i = 0; i < nleds; i++) {
+		switch(leds[i]) {
+		case WACOM_STATUS_LED_RING:
+			group = pad_get_mode_group(pad, i);
+			group->ring_mask |= 0x1;
+			break;
+		case WACOM_STATUS_LED_RING2:
+			group = pad_get_mode_group(pad, i);
+			group->ring_mask |= 0x2;
+			break;
+		default:
+			break;
+		}
+	}
+}
+
+static void
+pad_init_mode_strips(struct pad_dispatch *pad, WacomDevice *wacom)
+{
+	struct libinput_tablet_pad_mode_group *group;
+	const WacomStatusLEDs *leds;
+	int i, nleds;
+
+	leds = libwacom_get_status_leds(wacom, &nleds);
+	if (nleds == 0)
+		return;
+
+	for (i = 0; i < nleds; i++) {
+		switch(leds[i]) {
+		case WACOM_STATUS_LED_TOUCHSTRIP:
+			group = pad_get_mode_group(pad, i);
+			group->strip_mask |= 0x1;
+			break;
+		case WACOM_STATUS_LED_TOUCHSTRIP2:
+			group = pad_get_mode_group(pad, i);
+			group->strip_mask |= 0x2;
+			break;
+		default:
+			break;
+		}
+	}
+}
+
+static int
+pad_init_leds_from_libwacom(struct pad_dispatch *pad,
+			    struct evdev_device *device)
+{
+	struct libinput *libinput = device->base.seat->libinput;
+	WacomDeviceDatabase *db = NULL;
+	WacomDevice *wacom = NULL;
+	int rc = 1;
+
+	db = libwacom_database_new();
+	if (!db) {
+		log_info(libinput,
+			 "Failed to initialize libwacom context.\n");
+		goto out;
+	}
+
+	wacom = libwacom_new_from_path(db,
+				       udev_device_get_devnode(device->udev_device),
+				       WFALLBACK_NONE,
+				       NULL);
+	if (!wacom)
+		goto out;
+
+	rc = pad_init_led_groups(pad, device, wacom);
+	if (rc != 0)
+		goto out;
+
+	if ((rc = pad_init_mode_buttons(pad, wacom)) != 0)
+		goto out;
+
+	pad_init_mode_rings(pad, wacom);
+	pad_init_mode_strips(pad, wacom);
+
+out:
+	if (wacom)
+		libwacom_destroy(wacom);
+	if (db)
+		libwacom_database_destroy(db);
+
+	if (rc != 0)
+		pad_destroy_leds(pad);
+
+	return rc;
+}
+#endif /* HAVE_LIBWACOM */
+
 static int
 pad_init_fallback_group(struct pad_dispatch *pad)
 {
@@ -112,11 +571,12 @@ pad_init_leds(struct pad_dispatch *pad,
 		return rc;
 	}
 
-	/* Eventually we slot the libwacom-based led detection in here. That
-	 * requires getting the kernel ready first. For now we just init the
-	 * fallback single-mode group.
-	 */
-	rc = pad_init_fallback_group(pad);
+	/* If libwacom fails, we init one fallback group anyway */
+#if HAVE_LIBWACOM
+	rc = pad_init_leds_from_libwacom(pad, device);
+#endif
+	if (rc != 0)
+		rc = pad_init_fallback_group(pad);
 
 	return rc;
 }
@@ -136,6 +596,7 @@ pad_button_update_mode(struct libinput_tablet_pad_mode_group *g,
 		       enum libinput_button_state state)
 {
 	struct pad_led_group *group = (struct pad_led_group*)g;
+	int rc;
 
 	if (state != LIBINPUT_BUTTON_STATE_PRESSED)
 		return;
@@ -143,9 +604,9 @@ pad_button_update_mode(struct libinput_tablet_pad_mode_group *g,
 	if (!libinput_tablet_pad_mode_group_button_is_toggle(g, button_index))
 		return;
 
-	log_bug_libinput(group->base.device->seat->libinput,
-			 "Button %d should not be a toggle button",
-			 button_index);
+	rc = pad_led_group_get_mode(group);
+	if (rc >= 0)
+		group->base.current_mode = rc;
 }
 
 int

src/evdev.c

@@ -2077,7 +2077,7 @@ evdev_read_wheel_click_count_prop(struct evdev_device *device,
 	}
 
 	log_error(evdev_libinput_context(device),
-		  "Mouse wheel click count '%s' is present but invalid, "
+		  "Mouse wheel click count for '%s' is present but invalid, "
 		  "using %d degrees for angle instead instead\n",
 		  device->devname,
 		  DEFAULT_WHEEL_CLICK_ANGLE);

src/evdev.h

@@ -546,7 +546,7 @@ evdev_to_left_handed(struct evdev_device *device,
 
 /**
  * Apply a hysteresis filtering to the coordinate in, based on the current
- * hystersis center and the margin. If 'in' is within 'margin' of center,
+ * hysteresis center and the margin. If 'in' is within 'margin' of center,
  * return the center (and thus filter the motion). If 'in' is outside,
  * return a point on the edge of the new margin. So for a point x in the
  * space outside c + margin we return r:

test/litest-device-mouse-wheel-click-angle.c

@@ -53,7 +53,7 @@ static const char udev_rule[] =
 "KERNEL!=\"event*\", GOTO=\"wheel_click_angle_end\"\n"
 "\n"
 "ATTRS{name}==\"litest Wheel Click Angle Mouse*\",\\\n"
-"    ENV{MOUSE_WHEEL_CLICK_ANGLE}=\"-7\",\n"
+"    ENV{MOUSE_WHEEL_CLICK_ANGLE}=\"-7\",\\\n"
 "    ENV{MOUSE_WHEEL_CLICK_ANGLE_HORIZONTAL}=\"13\"\n"
 "\n"
 "LABEL=\"wheel_click_angle_end\"";

test/litest-device-waltop-tablet.c

@@ -232,7 +232,7 @@ static const char udev_rule[] =
 "ENV{ID_INPUT_TABLET}==\"\", GOTO=\"waltop_end\"\n"
 "\n"
 "ATTRS{name}==\"litest          WALTOP     Batteryless Tablet*\",\\\n"
-"    ENV{LIBINPUT_ATTR_SIZE_HINT}=\"200x200\",\n"
+"    ENV{LIBINPUT_ATTR_SIZE_HINT}=\"200x200\"\n"
 "\n"
 "LABEL=\"touchpad_end\"";
 

test/test-pointer.c

@@ -1062,7 +1062,7 @@ START_TEST(pointer_accel_defaults)
 				    speed);
 	}
 
-	for (speed = 1.2; speed <= -2.0; speed += 0.2) {
+	for (speed = 1.2; speed <= 2.0; speed += 0.2) {
 		status = libinput_device_config_accel_set_speed(device,
 								speed);
 		ck_assert_int_eq(status,