xf86-input-libinput 0.4.0

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

configure.ac

@@ -23,7 +23,7 @@
 # Initialize Autoconf
 AC_PREREQ([2.60])
 AC_INIT([xf86-input-libinput],
-        [0.3.0],
+        [0.4.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.6.0])
+PKG_CHECK_MODULES(LIBINPUT, [libinput >= 0.7.0])
 
 # Define a configure option for an alternate input module directory
 AC_ARG_WITH(xorg-module-dir,

man/libinput.man

@@ -48,7 +48,7 @@ The mapping from device node to hardware is system-dependent. Property:
 .BI "Option \*qAccelSpeed\*q \*q" float \*q
 Sets the pointer acceleration speed within the range [-1, 1]
 .TP 7
-.BI "Option \*qCalibration\*q \*q" string \*q
+.BI "Option \*qCalibrationMatrix\*q \*q" string \*q
 A string of 9 space-separated floating point numbers.
 Sets the calibration matrix to the 3x3 matrix where the first row is (abc),
 the second row is (def) and the third row is (ghi).

src/libinput.c

@@ -142,6 +142,7 @@ LibinputApplyConfig(DeviceIntPtr dev)
 	InputInfoPtr pInfo = dev->public.devicePrivate;
 	struct xf86libinput *driver_data = pInfo->private;
 	struct libinput_device *device = driver_data->device;
+	unsigned int scroll_button;
 
 	if (libinput_device_config_send_events_get_modes(device) != LIBINPUT_CONFIG_SEND_EVENTS_ENABLED &&
 	    libinput_device_config_send_events_set_mode(device,
@@ -206,8 +207,8 @@ LibinputApplyConfig(DeviceIntPtr dev)
 			    method);
 	}
 
-	if (libinput_device_config_scroll_set_button(device,
-						     btn_xorg2linux(driver_data->options.scroll_button)) != LIBINPUT_CONFIG_STATUS_SUCCESS)
+	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);
@@ -354,6 +355,53 @@ xf86libinput_init_pointer(InputInfoPtr pInfo)
 	return Success;
 }
 
+static int
+xf86libinput_init_pointer_absolute(InputInfoPtr pInfo)
+{
+	DeviceIntPtr dev= pInfo->dev;
+	struct xf86libinput *driver_data = pInfo->private;
+	int min, max, res;
+	int nbuttons = 7;
+	int i;
+
+	unsigned char btnmap[MAX_BUTTONS + 1];
+	Atom btnlabels[MAX_BUTTONS];
+	Atom axislabels[TOUCHPAD_NUM_AXES];
+
+	for (i = BTN_BACK; i >= BTN_SIDE; i--) {
+		if (libinput_device_has_button(driver_data->device, i)) {
+			nbuttons += i - BTN_SIDE + 1;
+			break;
+		}
+	}
+
+	init_button_map(btnmap, ARRAY_SIZE(btnmap));
+	init_button_labels(btnlabels, ARRAY_SIZE(btnlabels));
+	init_axis_labels(axislabels, ARRAY_SIZE(axislabels));
+
+	InitPointerDeviceStruct((DevicePtr)dev, btnmap,
+				nbuttons,
+				btnlabels,
+				xf86libinput_ptr_ctl,
+				GetMotionHistorySize(),
+				TOUCHPAD_NUM_AXES,
+				axislabels);
+	min = 0;
+	max = TOUCH_AXIS_MAX;
+	res = 0;
+
+	xf86InitValuatorAxisStruct(dev, 0,
+			           XIGetKnownProperty(AXIS_LABEL_PROP_ABS_X),
+				   min, max, res * 1000, 0, res * 1000, Absolute);
+	xf86InitValuatorAxisStruct(dev, 1,
+			           XIGetKnownProperty(AXIS_LABEL_PROP_ABS_Y),
+				   min, max, res * 1000, 0, res * 1000, Absolute);
+
+	SetScrollValuator(dev, 2, SCROLL_TYPE_HORIZONTAL, driver_data->scroll_hdist, 0);
+	SetScrollValuator(dev, 3, SCROLL_TYPE_VERTICAL, driver_data->scroll_vdist, 0);
+
+	return Success;
+}
 static void
 xf86libinput_kbd_ctrl(DeviceIntPtr device, KeybdCtrl *ctrl)
 {
@@ -387,16 +435,30 @@ xf86libinput_init_keyboard(InputInfoPtr pInfo)
 {
 	DeviceIntPtr dev= pInfo->dev;
 	XkbRMLVOSet rmlvo = {0};
+	XkbRMLVOSet defaults = {0};
 
-	rmlvo.rules = xf86SetStrOption(pInfo->options, "xkb_rules", "evdev");
-	rmlvo.model = xf86SetStrOption(pInfo->options, "xkb_model", "pc104");
-	rmlvo.layout = xf86SetStrOption(pInfo->options, "xkb_layout", "us");
-	rmlvo.variant = xf86SetStrOption(pInfo->options, "xkb_variant", NULL);
-	rmlvo.options = xf86SetStrOption(pInfo->options, "xkb_options", NULL);
+	XkbGetRulesDflts(&defaults);
+
+	rmlvo.rules = xf86SetStrOption(pInfo->options,
+				       "xkb_rules",
+				       defaults.rules);
+	rmlvo.model = xf86SetStrOption(pInfo->options,
+				       "xkb_model",
+				       defaults.model);
+	rmlvo.layout = xf86SetStrOption(pInfo->options,
+					"xkb_layout",
+					defaults.layout);
+	rmlvo.variant = xf86SetStrOption(pInfo->options,
+					 "xkb_variant",
+					 defaults.variant);
+	rmlvo.options = xf86SetStrOption(pInfo->options,
+					 "xkb_options",
+					 defaults.options);
 
 	InitKeyboardDeviceStruct(dev, &rmlvo, NULL,
 				 xf86libinput_kbd_ctrl);
 	XkbFreeRMLVOSet(&rmlvo, FALSE);
+	XkbFreeRMLVOSet(&defaults, FALSE);
 }
 
 static void
@@ -445,8 +507,12 @@ xf86libinput_init(DeviceIntPtr dev)
 
 	if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_KEYBOARD))
 		xf86libinput_init_keyboard(pInfo);
-	if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_POINTER))
-		xf86libinput_init_pointer(pInfo);
+	if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_POINTER)) {
+		if (libinput_device_config_calibration_has_matrix(device))
+			xf86libinput_init_pointer_absolute(pInfo);
+		else
+			xf86libinput_init_pointer(pInfo);
+	}
 	if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TOUCH))
 		xf86libinput_init_touch(pInfo);
 
@@ -506,6 +572,24 @@ xf86libinput_handle_motion(InputInfoPtr pInfo, struct libinput_event_pointer *ev
 	xf86PostMotionEventM(dev, Relative, mask);
 }
 
+static void
+xf86libinput_handle_absmotion(InputInfoPtr pInfo, struct libinput_event_pointer *event)
+{
+	DeviceIntPtr dev = pInfo->dev;
+	struct xf86libinput *driver_data = pInfo->private;
+	ValuatorMask *mask = driver_data->valuators;
+	double x, y;
+
+	x = libinput_event_pointer_get_absolute_x_transformed(event, TOUCH_AXIS_MAX);
+	y = libinput_event_pointer_get_absolute_y_transformed(event, TOUCH_AXIS_MAX);
+
+	valuator_mask_zero(mask);
+	valuator_mask_set_double(mask, 0, x);
+	valuator_mask_set_double(mask, 1, y);
+
+	xf86PostMotionEventM(dev, Absolute, mask);
+}
+
 static void
 xf86libinput_handle_button(InputInfoPtr pInfo, struct libinput_event_pointer *event)
 {
@@ -568,8 +652,8 @@ xf86libinput_handle_touch(InputInfoPtr pInfo,
 
 	/* libinput doesn't give us hw touch ids which X expects, so
 	   emulate them here */
-	static int next_touchid;
-	static int touchids[TOUCH_MAX_SLOTS] = {0};
+	static unsigned int next_touchid;
+	static unsigned int touchids[TOUCH_MAX_SLOTS] = {0};
 
 	slot = libinput_event_touch_get_slot(event);
 
@@ -619,7 +703,8 @@ xf86libinput_handle_event(struct libinput_event *event)
 		case LIBINPUT_EVENT_DEVICE_REMOVED:
 			break;
 		case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE:
-			/* FIXME */
+			xf86libinput_handle_absmotion(pInfo,
+						      libinput_event_get_pointer_event(event));
 			break;
 
 		case LIBINPUT_EVENT_POINTER_MOTION:
@@ -663,7 +748,9 @@ xf86libinput_read_input(InputInfoPtr pInfo)
 		return;
 
 	if (rc < 0) {
-		ErrorFSigSafe("Error reading events: %d\n", -rc);
+		xf86IDrvMsg(pInfo, X_ERROR,
+			    "Error reading events: %s\n",
+			    strerror(-rc));
 		return;
 	}
 
@@ -730,77 +817,13 @@ xf86libinput_log_handler(struct libinput *libinput,
 	LogVMessageVerb(type, verbosity, format, args);
 }
 
-static int xf86libinput_pre_init(InputDriverPtr drv,
-				 InputInfoPtr pInfo,
-				 int flags)
+static void
+xf86libinput_parse_options(InputInfoPtr pInfo,
+			   struct xf86libinput *driver_data,
+			   struct libinput_device *device)
 {
-	struct xf86libinput *driver_data = NULL;
-        struct libinput *libinput = NULL;
-	struct libinput_device *device;
-	char *path;
 	uint32_t scroll_methods;
 
-	pInfo->fd = -1;
-	pInfo->type_name = 0;
-	pInfo->device_control = xf86libinput_device_control;
-	pInfo->read_input = xf86libinput_read_input;
-	pInfo->control_proc = NULL;
-	pInfo->switch_mode = NULL;
-
-	driver_data = calloc(1, sizeof(*driver_data));
-	if (!driver_data)
-		goto fail;
-
-	driver_data->valuators = valuator_mask_new(2);
-	if (!driver_data->valuators)
-		goto fail;
-
-	driver_data->scroll_vdist = 1;
-	driver_data->scroll_hdist = 1;
-
-	path = xf86SetStrOption(pInfo->options, "Device", NULL);
-	if (!path)
-		goto fail;
-
-	if (!driver_context.libinput) {
-		driver_context.libinput = libinput_path_create_context(&interface, &driver_context);
-		libinput_log_set_handler(driver_context.libinput,
-					 xf86libinput_log_handler);
-		/* we want all msgs, let the server filter */
-		libinput_log_set_priority(driver_context.libinput,
-					  LIBINPUT_LOG_PRIORITY_DEBUG);
-	} else {
-		libinput_ref(driver_context.libinput);
-	}
-
-	libinput = driver_context.libinput;
-
-	if (libinput == NULL) {
-		xf86IDrvMsg(pInfo, X_ERROR, "Creating a device for %s failed\n", path);
-		goto fail;
-	}
-
-	device = libinput_path_add_device(libinput, path);
-	if (!device) {
-		xf86IDrvMsg(pInfo, X_ERROR, "Failed to create a device for %s\n", path);
-		goto fail;
-	}
-
-	/* We ref the device but remove it afterwards. The hope is that
-	   between now and DEVICE_INIT/DEVICE_ON, the device doesn't change.
-	  */
-	libinput_device_ref(device);
-	libinput_path_remove_device(device);
-
-	pInfo->fd = -1;
-	pInfo->private = driver_data;
-	driver_data->path = path;
-	driver_data->device = device;
-
-	/* Disable acceleration in the server, libinput does it for us */
-	pInfo->options = xf86ReplaceIntOption(pInfo->options, "AccelerationProfile", -1);
-	pInfo->options = xf86ReplaceStrOption(pInfo->options, "AccelerationScheme", "none");
-
 	if (libinput_device_config_tap_get_finger_count(device) > 0) {
 		BOOL tap = xf86SetBoolOption(pInfo->options,
 					     "Tapping",
@@ -970,6 +993,80 @@ static int xf86libinput_pre_init(InputDriverPtr drv,
 		driver_data->options.scroll_button = scroll_button;
 	}
 
+}
+
+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;
+	pInfo->control_proc = NULL;
+	pInfo->switch_mode = NULL;
+
+	driver_data = calloc(1, sizeof(*driver_data));
+	if (!driver_data)
+		goto fail;
+
+	driver_data->valuators = valuator_mask_new(2);
+	if (!driver_data->valuators)
+		goto fail;
+
+	driver_data->scroll_vdist = 1;
+	driver_data->scroll_hdist = 1;
+
+	path = xf86SetStrOption(pInfo->options, "Device", NULL);
+	if (!path)
+		goto fail;
+
+	if (!driver_context.libinput) {
+		driver_context.libinput = libinput_path_create_context(&interface, &driver_context);
+		libinput_log_set_handler(driver_context.libinput,
+					 xf86libinput_log_handler);
+		/* we want all msgs, let the server filter */
+		libinput_log_set_priority(driver_context.libinput,
+					  LIBINPUT_LOG_PRIORITY_DEBUG);
+	} else {
+		libinput_ref(driver_context.libinput);
+	}
+
+	libinput = driver_context.libinput;
+
+	if (libinput == NULL) {
+		xf86IDrvMsg(pInfo, X_ERROR, "Creating a device for %s failed\n", path);
+		goto fail;
+	}
+
+	device = libinput_path_add_device(libinput, path);
+	if (!device) {
+		xf86IDrvMsg(pInfo, X_ERROR, "Failed to create a device for %s\n", path);
+		goto fail;
+	}
+
+	/* We ref the device but remove it afterwards. The hope is that
+	   between now and DEVICE_INIT/DEVICE_ON, the device doesn't change.
+	  */
+	libinput_device_ref(device);
+	libinput_path_remove_device(device);
+
+	pInfo->fd = -1;
+	pInfo->private = driver_data;
+	driver_data->path = path;
+	driver_data->device = device;
+
+	/* Disable acceleration in the server, libinput does it for us */
+	pInfo->options = xf86ReplaceIntOption(pInfo->options, "AccelerationProfile", -1);
+	pInfo->options = xf86ReplaceStrOption(pInfo->options, "AccelerationScheme", "none");
+
+	xf86libinput_parse_options(pInfo, driver_data, device);
+
 	/* now pick an actual type */
 	if (libinput_device_config_tap_get_finger_count(device) > 0)
 		pInfo->type_name = XI_TOUCHPAD;
@@ -1050,13 +1147,20 @@ _X_EXPORT XF86ModuleData libinputModuleData = {
 #define PROP_ACCEL "libinput Accel Speed"
 /* Natural scrolling: BOOL, 1 value */
 #define PROP_NATURAL_SCROLL "libinput Natural Scrolling Enabled"
-/* Send-events mode: 32-bit int, 1 value */
-#define PROP_SENDEVENTS "libinput Send Events Mode"
+/* 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_METHODS "libinput Scroll Methods"
+#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"
 
@@ -1065,9 +1169,11 @@ static Atom prop_tap;
 static Atom prop_calibration;
 static Atom prop_accel;
 static Atom prop_natural_scroll;
-static Atom prop_sendevents;
+static Atom prop_sendevents_available;
+static Atom prop_sendevents_enabled;
 static Atom prop_left_handed;
-static Atom prop_scroll_methods;
+static Atom prop_scroll_methods_available;
+static Atom prop_scroll_method_enabled;
 static Atom prop_scroll_button;
 
 /* general properties */
@@ -1203,25 +1309,28 @@ LibinputSetPropertySendEvents(DeviceIntPtr dev,
 	InputInfoPtr pInfo = dev->public.devicePrivate;
 	struct xf86libinput *driver_data = pInfo->private;
 	struct libinput_device *device = driver_data->device;
-	CARD32* data;
+	BOOL* data;
+	uint32_t modes = 0;
 
-	if (val->format != 32 || val->size != 1 || val->type != XA_CARDINAL)
+	if (val->format != 8 || val->size != 2 || val->type != XA_INTEGER)
 		return BadMatch;
 
-	data = (CARD32*)val->data;
+	data = (BOOL*)val->data;
+
+	if (data[0])
+		modes |= LIBINPUT_CONFIG_SEND_EVENTS_DISABLED;
+	if (data[1])
+		modes |= LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE;
 
 	if (checkonly) {
-		uint32_t supported = libinput_device_config_send_events_get_modes(device);
-		uint32_t new_mode = *data;
+		uint32_t supported =
+			libinput_device_config_send_events_get_modes(device);
 
-		if ((new_mode | supported) != supported)
+		if ((modes | supported) != supported)
 			return BadValue;
 
-		/* Only one bit must be set */
-		if (new_mode && ((new_mode & (new_mode - 1)) != 0))
-			return BadValue;
 	} else {
-		driver_data->options.sendevents = *data;
+		driver_data->options.sendevents = modes;
 	}
 
 	return Success;
@@ -1286,7 +1395,7 @@ LibinputSetPropertyScrollMethods(DeviceIntPtr dev,
 		if (__builtin_popcount(modes) > 1)
 			return BadValue;
 
-		if ((modes & supported) == 0)
+		if (modes && (modes & supported) == 0)
 			return BadValue;
 	} else {
 		driver_data->options.scroll_method = modes;
@@ -1340,11 +1449,15 @@ LibinputSetProperty(DeviceIntPtr dev, Atom atom, XIPropertyValuePtr val,
 		rc = LibinputSetPropertyAccel(dev, atom, val, checkonly);
 	else if (atom == prop_natural_scroll)
 		rc = LibinputSetPropertyNaturalScroll(dev, atom, val, checkonly);
-	else if (atom == prop_sendevents)
+	else if (atom == prop_sendevents_available)
+		return BadAccess; /* read-only */
+	else if (atom == prop_sendevents_enabled)
 		rc = LibinputSetPropertySendEvents(dev, atom, val, checkonly);
 	else if (atom == prop_left_handed)
 		rc = LibinputSetPropertyLeftHanded(dev, atom, val, checkonly);
-	else if (atom == prop_scroll_methods)
+	else if (atom == prop_scroll_methods_available)
+		return BadAccess; /* read-only */
+	else if (atom == prop_scroll_method_enabled)
 		rc = LibinputSetPropertyScrollMethods(dev, atom, val, checkonly);
 	else if (atom == prop_scroll_button)
 		rc = LibinputSetPropertyScrollButton(dev, atom, val, checkonly);
@@ -1368,6 +1481,7 @@ LibinputInitProperty(DeviceIntPtr dev)
 	const char *device_node;
 	CARD32 product[2];
 	uint32_t scroll_methods;
+	uint32_t sendevent_modes;
 	int rc;
 
 	prop_float = XIGetKnownProperty("FLOAT");
@@ -1428,19 +1542,47 @@ LibinputInitProperty(DeviceIntPtr dev)
 		XISetDevicePropertyDeletable(dev, prop_natural_scroll, FALSE);
 	}
 
-	if (libinput_device_config_send_events_get_modes(device) !=
-		    LIBINPUT_CONFIG_SEND_EVENTS_ENABLED) {
-		uint32_t sendevents = driver_data->options.sendevents;
+	sendevent_modes = libinput_device_config_send_events_get_modes(device);
+	if (sendevent_modes != LIBINPUT_CONFIG_SEND_EVENTS_ENABLED) {
+		uint32_t sendevents;
+		BOOL modes[2] = {FALSE};
 
-		prop_sendevents = MakeAtom(PROP_SENDEVENTS,
-					   strlen(PROP_SENDEVENTS),
-					   TRUE);
-		rc = XIChangeDeviceProperty(dev, prop_sendevents,
-					    XA_CARDINAL, 32,
-					    PropModeReplace, 1, &sendevents, FALSE);
+		if (sendevent_modes & LIBINPUT_CONFIG_SEND_EVENTS_DISABLED)
+			modes[0] = TRUE;
+		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),
+						     TRUE);
+		rc = XIChangeDeviceProperty(dev, prop_sendevents_available,
+					    XA_INTEGER, 8,
+					    PropModeReplace, 2, modes, FALSE);
 		if (rc != Success)
 			return;
-		XISetDevicePropertyDeletable(dev, prop_sendevents, FALSE);
+		XISetDevicePropertyDeletable(dev, prop_sendevents_available, FALSE);
+
+		memset(modes, 0, sizeof(modes));
+		sendevents = driver_data->options.sendevents;
+
+		switch(sendevents) {
+		case LIBINPUT_CONFIG_SEND_EVENTS_DISABLED:
+			modes[0] = TRUE;
+			break;
+		case LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE:
+			modes[1] = TRUE;
+			break;
+		}
+
+		prop_sendevents_enabled = MakeAtom(PROP_SENDEVENTS_ENABLED,
+						   strlen(PROP_SENDEVENTS_ENABLED),
+						   TRUE);
+		rc = XIChangeDeviceProperty(dev, prop_sendevents_enabled,
+					    XA_INTEGER, 8,
+					    PropModeReplace, 2, modes, FALSE);
+		if (rc != Success)
+			return;
+		XISetDevicePropertyDeletable(dev, prop_sendevents_enabled, FALSE);
 
 	}
 
@@ -1463,6 +1605,31 @@ LibinputInitProperty(DeviceIntPtr dev)
 		enum libinput_config_scroll_method method;
 		BOOL methods[3] = {FALSE};
 
+		if (scroll_methods & LIBINPUT_CONFIG_SCROLL_2FG)
+			methods[0] = TRUE;
+		if (scroll_methods & LIBINPUT_CONFIG_SCROLL_EDGE)
+			methods[1] = TRUE;
+		if (scroll_methods & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN)
+			methods[2] = TRUE;
+
+		prop_scroll_methods_available =
+			MakeAtom(PROP_SCROLL_METHODS_AVAILABLE,
+				 strlen(PROP_SCROLL_METHODS_AVAILABLE),
+				 TRUE);
+		rc = XIChangeDeviceProperty(dev,
+					    prop_scroll_methods_available,
+					    XA_INTEGER, 8,
+					    PropModeReplace,
+					    ARRAY_SIZE(methods),
+					    &methods, FALSE);
+		if (rc != Success)
+			return;
+		XISetDevicePropertyDeletable(dev,
+					     prop_scroll_methods_available,
+					     FALSE);
+
+		memset(methods, 0, sizeof(methods));
+
 		method = libinput_device_config_scroll_get_method(device);
 		switch(method) {
 		case LIBINPUT_CONFIG_SCROLL_2FG:
@@ -1478,18 +1645,22 @@ LibinputInitProperty(DeviceIntPtr dev)
 			break;
 		}
 
-		prop_scroll_methods = MakeAtom(PROP_SCROLL_METHODS,
-					       strlen(PROP_SCROLL_METHODS),
-					       TRUE);
+		prop_scroll_method_enabled =
+			MakeAtom(PROP_SCROLL_METHOD_ENABLED,
+				 strlen(PROP_SCROLL_METHOD_ENABLED),
+				 TRUE);
 		rc = XIChangeDeviceProperty(dev,
-					    prop_scroll_methods,
+					    prop_scroll_method_enabled,
 					    XA_INTEGER, 8,
 					    PropModeReplace,
 					    ARRAY_SIZE(methods),
 					    &methods, FALSE);
 		if (rc != Success)
 			return;
-		XISetDevicePropertyDeletable(dev, prop_scroll_methods, FALSE);
+
+		XISetDevicePropertyDeletable(dev,
+					     prop_scroll_method_enabled,
+					     FALSE);
 	}
 
 	if (libinput_device_config_scroll_get_methods(device) &