xf86-input-libinput 0.7.0

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

Makefile.am

@@ -21,9 +21,12 @@
 
 DISTCHECK_CONFIGURE_FLAGS = --with-sdkdir='$${includedir}/xorg'
 
-SUBDIRS = src man
+SUBDIRS = src include man
 MAINTAINERCLEANFILES = ChangeLog INSTALL
 
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = xorg-libinput.pc
+
 .PHONY: ChangeLog INSTALL
 
 INSTALL:

autogen.sh

@@ -0,0 +1,14 @@
+#! /bin/sh
+
+srcdir=`dirname $0`
+test -z "$srcdir" && srcdir=.
+
+ORIGDIR=`pwd`
+cd $srcdir
+
+autoreconf -v --install || exit 1
+cd $ORIGDIR || exit $?
+
+if test -z "$NOCONFIGURE"; then
+    exec $srcdir/configure "$@"
+fi

configure.ac

@@ -23,7 +23,7 @@
 # Initialize Autoconf
 AC_PREREQ([2.60])
 AC_INIT([xf86-input-libinput],
-        [0.4.0],
+        [0.7.0],
         [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg],
         [xf86-input-libinput])
 AC_CONFIG_SRCDIR([Makefile.am])
@@ -45,7 +45,7 @@ XORG_DEFAULT_OPTIONS
 
 # Obtain compiler/linker options from server and required extensions
 PKG_CHECK_MODULES(XORG, [xorg-server >= 1.10] xproto [inputproto >= 2.2])
-PKG_CHECK_MODULES(LIBINPUT, [libinput >= 0.7.0])
+PKG_CHECK_MODULES(LIBINPUT, [libinput >= 0.8.0])
 
 # Define a configure option for an alternate input module directory
 AC_ARG_WITH(xorg-module-dir,
@@ -68,6 +68,8 @@ DRIVER_NAME=libinput
 AC_SUBST([DRIVER_NAME])
 
 AC_CONFIG_FILES([Makefile
+		 include/Makefile
 		 src/Makefile
-		 man/Makefile])
+		 man/Makefile
+		 xorg-libinput.pc])
 AC_OUTPUT

include/Makefile.am

@@ -0,0 +1 @@
+sdk_HEADERS = libinput-properties.h

include/libinput-properties.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2015 Red Hat, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of Red Hat
+ * not be used in advertising or publicity pertaining to distribution
+ * of the software without specific, written prior permission.  Red
+ * Hat makes no representations about the suitability of this software
+ * for any purpose.  It is provided "as is" without express or implied
+ * warranty.
+ *
+ * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _LIBINPUT_PROPERTIES_H_
+#define _LIBINPUT_PROPERTIES_H_
+
+/* Tapping enabled/disabled: BOOL, 1 value */
+#define LIBINPUT_PROP_TAP "libinput Tapping Enabled"
+
+/* Calibration matrix: FLOAT, 9 values of a 3x3 matrix, in rows */
+#define LIBINPUT_PROP_CALIBRATION "libinput Calibration Matrix"
+
+/* Pointer accel speed: FLOAT, 1 value, 32 bit */
+#define LIBINPUT_PROP_ACCEL "libinput Accel Speed"
+
+/* Natural scrolling: BOOL, 1 value */
+#define LIBINPUT_PROP_NATURAL_SCROLL "libinput Natural Scrolling Enabled"
+
+/* Send-events mode: BOOL read-only, 2 values in order disabled,
+   disabled-on-external-mouse */
+#define LIBINPUT_PROP_SENDEVENTS_AVAILABLE "libinput Send Events Modes Available"
+
+/* Send-events mode: BOOL, 2 values in order disabled,
+   disabled-on-external-mouse */
+#define LIBINPUT_PROP_SENDEVENTS_ENABLED "libinput Send Events Mode Enabled"
+
+/* Left-handed enabled/disabled: BOOL, 1 value */
+#define LIBINPUT_PROP_LEFT_HANDED "libinput Left Handed Enabled"
+
+/* Scroll method: BOOL read-only, 3 values in order 2fg, edge, button.
+   shows available scroll methods */
+#define LIBINPUT_PROP_SCROLL_METHODS_AVAILABLE "libinput Scroll Methods Available"
+
+/* Scroll method: BOOL, 3 values in order 2fg, edge, button
+   only one is enabled at a time at max */
+#define LIBINPUT_PROP_SCROLL_METHOD_ENABLED "libinput Scroll Method Enabled"
+
+/* Scroll button for button scrolling: 32-bit int, 1 value */
+#define LIBINPUT_PROP_SCROLL_BUTTON "libinput Button Scrolling Button"
+
+#endif /* _LIBINPUT_PROPERTIES_H_ */

src/libinput.c

@@ -31,6 +31,7 @@
 #include <time.h>
 #include <unistd.h>
 #include <xorg-server.h>
+#include <list.h>
 #include <exevents.h>
 #include <xkbsrv.h>
 #include <xf86Xinput.h>
@@ -40,6 +41,12 @@
 
 #include <X11/Xatom.h>
 
+#include "libinput-properties.h"
+
+#ifndef XI86_SERVER_FD
+#define XI86_SERVER_FD 0x20
+#endif
+
 #define TOUCHPAD_NUM_AXES 4 /* x, y, hscroll, vscroll */
 #define TOUCH_MAX_SLOTS 15
 #define XORG_KEYCODE_OFFSET 8
@@ -52,15 +59,10 @@
  */
 #define TOUCH_AXIS_MAX 0xffff
 
-/*
-   libinput scales wheel events by DEFAULT_AXIS_STEP_DISTANCE, which is
-   currently 10.
- */
-#define DEFAULT_LIBINPUT_AXIS_STEP_DISTANCE 10
-
 struct xf86libinput_driver {
 	struct libinput *libinput;
 	int device_enabled_count;
+	struct xorg_list server_fds;
 };
 
 static struct xf86libinput_driver driver_context;
@@ -95,6 +97,80 @@ struct xf86libinput {
 	} options;
 };
 
+/*
+   libinput provides a userdata for the context, but not per path device. so
+   the open_restricted call has the libinput context, but no reference to
+   the pInfo->fd that we actually need to return.
+   To avoid this, we store each path/fd combination during pre_init in the
+   context, then return that during open_restricted. If a device is added
+   twice with two different fds this may give us the wrong fd but why are
+   you doing that anyway.
+ */
+struct serverfd {
+	struct xorg_list node;
+	int fd;
+	char *path;
+};
+
+static inline int
+use_server_fd(const InputInfoPtr pInfo) {
+	return pInfo->fd > -1 && (pInfo->flags & XI86_SERVER_FD);
+}
+
+static inline void
+fd_push(struct xf86libinput_driver *context,
+	int fd,
+	const char *path)
+{
+	struct serverfd *sfd = xnfcalloc(1, sizeof(*sfd));
+
+	sfd->fd = fd;
+	sfd->path = xnfstrdup(path);
+	xorg_list_add(&sfd->node, &context->server_fds);
+}
+
+static inline int
+fd_get(struct xf86libinput_driver *context,
+       const char *path)
+{
+	struct serverfd *sfd;
+
+	xorg_list_for_each_entry(sfd, &context->server_fds, node) {
+		if (strcmp(path, sfd->path) == 0)
+			return sfd->fd;
+	}
+
+	return -1;
+}
+
+static inline void
+fd_pop(struct xf86libinput_driver *context, int fd)
+{
+	struct serverfd *sfd;
+
+	xorg_list_for_each_entry(sfd, &context->server_fds, node) {
+		if (fd != sfd->fd)
+			continue;
+
+		xorg_list_del(&sfd->node);
+		free(sfd->path);
+		free(sfd);
+		break;
+	}
+}
+
+static inline int
+fd_find(struct xf86libinput_driver *context, int fd)
+{
+	struct serverfd *sfd;
+
+	xorg_list_for_each_entry(sfd, &context->server_fds, node) {
+		if (fd == sfd->fd)
+			return fd;
+	}
+	return -1;
+}
+
 static inline unsigned int
 btn_linux2xorg(unsigned int b)
 {
@@ -183,8 +259,9 @@ LibinputApplyConfig(DeviceIntPtr dev)
 			    driver_data->options.matrix[6], driver_data->options.matrix[7],
 			    driver_data->options.matrix[8]);
 
-	if (libinput_device_config_buttons_set_left_handed(device,
-							   driver_data->options.left_handed) != LIBINPUT_CONFIG_STATUS_SUCCESS)
+	if (libinput_device_config_left_handed_is_available(device) &&
+	    libinput_device_config_left_handed_set(device,
+						   driver_data->options.left_handed) != LIBINPUT_CONFIG_STATUS_SUCCESS)
 		xf86IDrvMsg(pInfo, X_ERROR,
 			    "Failed to set LeftHanded to %d\n",
 			    driver_data->options.left_handed);
@@ -207,11 +284,13 @@ LibinputApplyConfig(DeviceIntPtr dev)
 			    method);
 	}
 
-	scroll_button = btn_xorg2linux(driver_data->options.scroll_button);
-	if (libinput_device_config_scroll_set_button(device, scroll_button) != LIBINPUT_CONFIG_STATUS_SUCCESS)
-		xf86IDrvMsg(pInfo, X_ERROR,
-			    "Failed to set ScrollButton to %d\n",
-			    driver_data->options.scroll_button);
+	if (libinput_device_config_scroll_get_methods(device) & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN) {
+		scroll_button = btn_xorg2linux(driver_data->options.scroll_button);
+		if (libinput_device_config_scroll_set_button(device, scroll_button) != LIBINPUT_CONFIG_STATUS_SUCCESS)
+			xf86IDrvMsg(pInfo, X_ERROR,
+				    "Failed to set ScrollButton to %d\n",
+				    driver_data->options.scroll_button);
+	}
 }
 
 static int
@@ -222,13 +301,24 @@ xf86libinput_on(DeviceIntPtr dev)
 	struct libinput *libinput = driver_context.libinput;
 	struct libinput_device *device = driver_data->device;
 
+	if (use_server_fd(pInfo)) {
+		char *path = xf86SetStrOption(pInfo->options, "Device", NULL);
+		fd_push(&driver_context, pInfo->fd, path);
+		free(path);
+	}
+
 	device = libinput_path_add_device(libinput, driver_data->path);
 	if (!device)
 		return !Success;
+
 	libinput_device_ref(device);
 	libinput_device_set_user_data(device, pInfo);
 	driver_data->device = device;
 
+	/* if we use server fds, overwrite the fd with the one from
+	   libinput nonetheless, otherwise the server won't call ReadInput
+	   for our device. This must be swapped back to the real fd in
+	   DEVICE_OFF so systemd-logind closes the right fd */
 	pInfo->fd = libinput_get_fd(libinput);
 
 	if (driver_context.device_enabled_count == 0) {
@@ -239,6 +329,8 @@ xf86libinput_on(DeviceIntPtr dev)
 	driver_context.device_enabled_count++;
 	dev->public.on = TRUE;
 
+	LibinputApplyConfig(dev);
+
 	return Success;
 }
 
@@ -252,7 +344,13 @@ xf86libinput_off(DeviceIntPtr dev)
 		RemoveEnabledDevice(pInfo->fd);
 	}
 
-	pInfo->fd = -1;
+	if (use_server_fd(pInfo)) {
+		fd_pop(&driver_context, pInfo->fd);
+		pInfo->fd = xf86SetIntOption(pInfo->options, "fd", -1);
+	} else {
+		pInfo->fd = -1;
+	}
+
 	dev->public.on = FALSE;
 
 	libinput_device_set_user_data(driver_data->device, NULL);
@@ -293,8 +391,8 @@ init_button_labels(Atom *labels, size_t size)
 	labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT);
 	labels[7] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_SIDE);
 	labels[8] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_EXTRA);
-	labels[9] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_BACK);
-	labels[10] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_FORWARD);
+	labels[9] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_FORWARD);
+	labels[10] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_BACK);
 }
 
 static void
@@ -621,19 +719,38 @@ xf86libinput_handle_axis(InputInfoPtr pInfo, struct libinput_event_pointer *even
 	DeviceIntPtr dev = pInfo->dev;
 	struct xf86libinput *driver_data = pInfo->private;
 	ValuatorMask *mask = driver_data->valuators;
-	int axis;
 	double value;
-
-	if (libinput_event_pointer_get_axis(event) ==
-			LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL)
-		axis = 3;
-	else
-		axis = 2;
-
-	value = libinput_event_pointer_get_axis_value(event) / DEFAULT_LIBINPUT_AXIS_STEP_DISTANCE;
+	enum libinput_pointer_axis axis;
+	enum libinput_pointer_axis_source source;
 
 	valuator_mask_zero(mask);
-	valuator_mask_set_double(mask, axis, value);
+
+	source = libinput_event_pointer_get_axis_source(event);
+	switch(source) {
+		case LIBINPUT_POINTER_AXIS_SOURCE_FINGER:
+		case LIBINPUT_POINTER_AXIS_SOURCE_WHEEL:
+		case LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS:
+			break;
+		default:
+			return;
+	}
+
+	axis = LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL;
+	if (libinput_event_pointer_has_axis(event, axis)) {
+		if (source == LIBINPUT_POINTER_AXIS_SOURCE_WHEEL)
+			value = libinput_event_pointer_get_axis_value_discrete(event, axis);
+		else
+			value = libinput_event_pointer_get_axis_value(event, axis);
+		valuator_mask_set_double(mask, 3, value);
+	}
+	axis = LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL;
+	if (libinput_event_pointer_has_axis(event, axis)) {
+		if (source == LIBINPUT_POINTER_AXIS_SOURCE_WHEEL)
+			value = libinput_event_pointer_get_axis_value_discrete(event, axis);
+		else
+			value = libinput_event_pointer_get_axis_value(event, axis);
+		valuator_mask_set_double(mask, 2, value);
+	}
 
 	xf86PostMotionEventM(dev, Relative, mask);
 }
@@ -763,14 +880,22 @@ xf86libinput_read_input(InputInfoPtr pInfo)
 static int
 open_restricted(const char *path, int flags, void *data)
 {
-	int fd = open(path, flags);
+	struct xf86libinput_driver *context = data;
+	int fd;
+
+	fd = fd_get(context, path);
+	if (fd == -1)
+		fd = open(path, flags);
 	return fd < 0 ? -errno : fd;
 }
 
 static void
 close_restricted(int fd, void *data)
 {
-	close(fd);
+	struct xf86libinput_driver *context = data;
+
+	if (fd_find(context, fd) == -1)
+		close(fd);
 }
 
 const struct libinput_interface interface = {
@@ -931,17 +1056,17 @@ xf86libinput_parse_options(InputInfoPtr pInfo,
 		}
 	}
 
-	if (libinput_device_config_buttons_has_left_handed(device)) {
+	if (libinput_device_config_left_handed_is_available(device)) {
 		BOOL left_handed = xf86SetBoolOption(pInfo->options,
 						     "LeftHanded",
-						     libinput_device_config_buttons_get_left_handed(device));
-		if (libinput_device_config_buttons_set_left_handed(device,
-								   left_handed) !=
+						     libinput_device_config_left_handed_get(device));
+		if (libinput_device_config_left_handed_set(device,
+							   left_handed) !=
 		    LIBINPUT_CONFIG_STATUS_SUCCESS) {
 			xf86IDrvMsg(pInfo, X_ERROR,
 				    "Failed to set LeftHanded to %d\n",
 				    left_handed);
-			left_handed = libinput_device_config_buttons_get_left_handed(device);
+			left_handed = libinput_device_config_left_handed_get(device);
 		}
 		driver_data->options.left_handed = left_handed;
 	}
@@ -995,16 +1120,16 @@ xf86libinput_parse_options(InputInfoPtr pInfo,
 
 }
 
-static int xf86libinput_pre_init(InputDriverPtr drv,
-				 InputInfoPtr pInfo,
-				 int flags)
+static int
+xf86libinput_pre_init(InputDriverPtr drv,
+		      InputInfoPtr pInfo,
+		      int flags)
 {
 	struct xf86libinput *driver_data = NULL;
         struct libinput *libinput = NULL;
 	struct libinput_device *device;
 	char *path;
 
-	pInfo->fd = -1;
 	pInfo->type_name = 0;
 	pInfo->device_control = xf86libinput_device_control;
 	pInfo->read_input = xf86libinput_read_input;
@@ -1033,6 +1158,7 @@ static int xf86libinput_pre_init(InputDriverPtr drv,
 		/* we want all msgs, let the server filter */
 		libinput_log_set_priority(driver_context.libinput,
 					  LIBINPUT_LOG_PRIORITY_DEBUG);
+		xorg_list_init(&driver_context.server_fds);
 	} else {
 		libinput_ref(driver_context.libinput);
 	}
@@ -1044,6 +1170,9 @@ static int xf86libinput_pre_init(InputDriverPtr drv,
 		goto fail;
 	}
 
+	if (use_server_fd(pInfo))
+		fd_push(&driver_context, pInfo->fd, path);
+
 	device = libinput_path_add_device(libinput, path);
 	if (!device) {
 		xf86IDrvMsg(pInfo, X_ERROR, "Failed to create a device for %s\n", path);
@@ -1055,8 +1184,9 @@ static int xf86libinput_pre_init(InputDriverPtr drv,
 	  */
 	libinput_device_ref(device);
 	libinput_path_remove_device(device);
+	if (use_server_fd(pInfo))
+	    fd_pop(&driver_context, pInfo->fd);
 
-	pInfo->fd = -1;
 	pInfo->private = driver_data;
 	driver_data->path = path;
 	driver_data->device = device;
@@ -1081,6 +1211,8 @@ static int xf86libinput_pre_init(InputDriverPtr drv,
 
 	return Success;
 fail:
+	if (use_server_fd(pInfo) && driver_context.libinput != NULL)
+		fd_pop(&driver_context, pInfo->fd);
 	if (driver_data->valuators)
 		valuator_mask_free(&driver_data->valuators);
 	free(path);
@@ -1109,6 +1241,11 @@ InputDriverRec xf86libinput_driver = {
 	.driverName	= "libinput",
 	.PreInit	= xf86libinput_pre_init,
 	.UnInit		= xf86libinput_uninit,
+	.module		= NULL,
+	.default_options= NULL,
+#ifdef XI86_DRV_CAP_SERVER_FD
+	.capabilities	= XI86_DRV_CAP_SERVER_FD
+#endif
 };
 
 static XF86ModuleVersionInfo xf86libinput_version_info = {
@@ -1139,31 +1276,6 @@ _X_EXPORT XF86ModuleData libinputModuleData = {
 
 /* Property support */
 
-/* Tapping enabled/disabled: BOOL, 1 value */
-#define PROP_TAP "libinput Tapping Enabled"
-/* Calibration matrix: FLOAT, 9 values of a 3x3 matrix, in rows */
-#define PROP_CALIBRATION "libinput Calibration Matrix"
-/* Pointer accel speed: FLOAT, 1 value, 32 bit */
-#define PROP_ACCEL "libinput Accel Speed"
-/* Natural scrolling: BOOL, 1 value */
-#define PROP_NATURAL_SCROLL "libinput Natural Scrolling Enabled"
-/* Send-events mode: BOOL read-only, 2 values in order disabled,
-   disabled-on-external-mouse */
-#define PROP_SENDEVENTS_AVAILABLE "libinput Send Events Modes Available"
-/* Send-events mode: BOOL, 2 values in order disabled,
-   disabled-on-external-mouse */
-#define PROP_SENDEVENTS_ENABLED "libinput Send Events Mode Enabled"
-/* Left-handed enabled/disabled: BOOL, 1 value */
-#define PROP_LEFT_HANDED "libinput Left Handed Enabled"
-/* Scroll method: BOOL read-only, 3 values in order 2fg, edge, button.
-   shows available scroll methods */
-#define PROP_SCROLL_METHODS_AVAILABLE "libinput Scroll Methods Available"
-/* Scroll method: BOOL, 3 values in order 2fg, edge, button
-   only one is enabled at a time at max */
-#define PROP_SCROLL_METHOD_ENABLED "libinput Scroll Method Enabled"
-/* Scroll button for button scrolling: 32-bit int, 1 value */
-#define PROP_SCROLL_BUTTON "libinput Button Scrolling Button"
-
 /* libinput-specific properties */
 static Atom prop_tap;
 static Atom prop_calibration;
@@ -1353,7 +1465,7 @@ LibinputSetPropertyLeftHanded(DeviceIntPtr dev,
 	data = (BOOL*)val->data;
 
 	if (checkonly) {
-		int supported = libinput_device_config_buttons_has_left_handed(device);
+		int supported = libinput_device_config_left_handed_is_available(device);
 		int left_handed = *data;
 
 		if (!supported && left_handed)
@@ -1489,7 +1601,7 @@ LibinputInitProperty(DeviceIntPtr dev)
 	if (libinput_device_config_tap_get_finger_count(device) > 0) {
 		BOOL tap = driver_data->options.tapping;
 
-		prop_tap = MakeAtom(PROP_TAP, strlen(PROP_TAP), TRUE);
+		prop_tap = MakeAtom(LIBINPUT_PROP_TAP, strlen(LIBINPUT_PROP_TAP), TRUE);
 		rc = XIChangeDeviceProperty(dev, prop_tap, XA_INTEGER, 8,
 					    PropModeReplace, 1, &tap, FALSE);
 		if (rc != Success)
@@ -1507,8 +1619,8 @@ LibinputInitProperty(DeviceIntPtr dev)
 		calibration[7] = 0;
 		calibration[8] = 1;
 
-		prop_calibration = MakeAtom(PROP_CALIBRATION,
-					    strlen(PROP_CALIBRATION),
+		prop_calibration = MakeAtom(LIBINPUT_PROP_CALIBRATION,
+					    strlen(LIBINPUT_PROP_CALIBRATION),
 					    TRUE);
 
 		rc = XIChangeDeviceProperty(dev, prop_calibration, prop_float, 32,
@@ -1521,7 +1633,7 @@ LibinputInitProperty(DeviceIntPtr dev)
 	if (libinput_device_config_accel_is_available(device)) {
 		float speed = driver_data->options.speed;
 
-		prop_accel = MakeAtom(PROP_ACCEL, strlen(PROP_ACCEL), TRUE);
+		prop_accel = MakeAtom(LIBINPUT_PROP_ACCEL, strlen(LIBINPUT_PROP_ACCEL), TRUE);
 		rc = XIChangeDeviceProperty(dev, prop_accel, prop_float, 32,
 					    PropModeReplace, 1, &speed, FALSE);
 		if (rc != Success)
@@ -1532,8 +1644,8 @@ LibinputInitProperty(DeviceIntPtr dev)
 	if (libinput_device_config_scroll_has_natural_scroll(device)) {
 		BOOL natural_scroll = driver_data->options.natural_scrolling;
 
-		prop_natural_scroll = MakeAtom(PROP_NATURAL_SCROLL,
-					       strlen(PROP_NATURAL_SCROLL),
+		prop_natural_scroll = MakeAtom(LIBINPUT_PROP_NATURAL_SCROLL,
+					       strlen(LIBINPUT_PROP_NATURAL_SCROLL),
 					       TRUE);
 		rc = XIChangeDeviceProperty(dev, prop_natural_scroll, XA_INTEGER, 8,
 					    PropModeReplace, 1, &natural_scroll, FALSE);
@@ -1552,8 +1664,8 @@ LibinputInitProperty(DeviceIntPtr dev)
 		if (sendevent_modes & LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE)
 			modes[1] = TRUE;
 
-		prop_sendevents_available = MakeAtom(PROP_SENDEVENTS_AVAILABLE,
-						     strlen(PROP_SENDEVENTS_AVAILABLE),
+		prop_sendevents_available = MakeAtom(LIBINPUT_PROP_SENDEVENTS_AVAILABLE,
+						     strlen(LIBINPUT_PROP_SENDEVENTS_AVAILABLE),
 						     TRUE);
 		rc = XIChangeDeviceProperty(dev, prop_sendevents_available,
 					    XA_INTEGER, 8,
@@ -1574,8 +1686,8 @@ LibinputInitProperty(DeviceIntPtr dev)
 			break;
 		}
 
-		prop_sendevents_enabled = MakeAtom(PROP_SENDEVENTS_ENABLED,
-						   strlen(PROP_SENDEVENTS_ENABLED),
+		prop_sendevents_enabled = MakeAtom(LIBINPUT_PROP_SENDEVENTS_ENABLED,
+						   strlen(LIBINPUT_PROP_SENDEVENTS_ENABLED),
 						   TRUE);
 		rc = XIChangeDeviceProperty(dev, prop_sendevents_enabled,
 					    XA_INTEGER, 8,
@@ -1586,11 +1698,11 @@ LibinputInitProperty(DeviceIntPtr dev)
 
 	}
 
-	if (libinput_device_config_buttons_has_left_handed(device)) {
+	if (libinput_device_config_left_handed_is_available(device)) {
 		BOOL left_handed = driver_data->options.left_handed;
 
-		prop_left_handed = MakeAtom(PROP_LEFT_HANDED,
-					    strlen(PROP_LEFT_HANDED),
+		prop_left_handed = MakeAtom(LIBINPUT_PROP_LEFT_HANDED,
+					    strlen(LIBINPUT_PROP_LEFT_HANDED),
 					    TRUE);
 		rc = XIChangeDeviceProperty(dev, prop_left_handed,
 					    XA_INTEGER, 8,
@@ -1613,8 +1725,8 @@ LibinputInitProperty(DeviceIntPtr dev)
 			methods[2] = TRUE;
 
 		prop_scroll_methods_available =
-			MakeAtom(PROP_SCROLL_METHODS_AVAILABLE,
-				 strlen(PROP_SCROLL_METHODS_AVAILABLE),
+			MakeAtom(LIBINPUT_PROP_SCROLL_METHODS_AVAILABLE,
+				 strlen(LIBINPUT_PROP_SCROLL_METHODS_AVAILABLE),
 				 TRUE);
 		rc = XIChangeDeviceProperty(dev,
 					    prop_scroll_methods_available,
@@ -1646,8 +1758,8 @@ LibinputInitProperty(DeviceIntPtr dev)
 		}
 
 		prop_scroll_method_enabled =
-			MakeAtom(PROP_SCROLL_METHOD_ENABLED,
-				 strlen(PROP_SCROLL_METHOD_ENABLED),
+			MakeAtom(LIBINPUT_PROP_SCROLL_METHOD_ENABLED,
+				 strlen(LIBINPUT_PROP_SCROLL_METHOD_ENABLED),
 				 TRUE);
 		rc = XIChangeDeviceProperty(dev,
 					    prop_scroll_method_enabled,
@@ -1667,8 +1779,8 @@ LibinputInitProperty(DeviceIntPtr dev)
 	    LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN) {
 		CARD32 scroll_button = driver_data->options.scroll_button;
 
-		prop_scroll_button = MakeAtom(PROP_SCROLL_BUTTON,
-					    strlen(PROP_SCROLL_BUTTON),
+		prop_scroll_button = MakeAtom(LIBINPUT_PROP_SCROLL_BUTTON,
+					    strlen(LIBINPUT_PROP_SCROLL_BUTTON),
 					    TRUE);
 		rc = XIChangeDeviceProperty(dev, prop_scroll_button,
 					    XA_CARDINAL, 32,

xorg-libinput.pc.in

@@ -0,0 +1,6 @@
+sdkdir=@sdkdir@
+
+Name: xorg-libinput
+Description: X.Org libinput input driver.
+Version: @PACKAGE_VERSION@
+Cflags: -I${sdkdir}