From 22fe64732e11199901d4a35f9d3c63d5d6deb3a3 Mon Sep 17 00:00:00 2001

From: Carlos Garnacho <carlosg@gnome.org>

Date: Tue, 1 Jun 2021 11:44:20 +0200

Subject: [PATCH 1/6] backends/x11: Support synaptics configuration

The code is taken mostly as-is from g-s-d, so we can drag the

dead horse a bit longer.

---

 src/backends/x11/meta-input-settings-x11.c | 274 +++++++++++++++++++++

 1 file changed, 274 insertions(+)

diff --git a/src/backends/x11/meta-input-settings-x11.c b/src/backends/x11/meta-input-settings-x11.c

index 371e2f60e..426056390 100644

--- a/src/backends/x11/meta-input-settings-x11.c

+++ b/src/backends/x11/meta-input-settings-x11.c

@@ -26,6 +26,7 @@

 #include "backends/x11/meta-input-settings-x11.h"

 #include <gdk/gdkx.h>

+#include <stdlib.h>

 #include <string.h>

 #include <X11/Xatom.h>

 #include <X11/extensions/XInput2.h>

@@ -165,6 +166,183 @@ change_property (ClutterInputDevice *device,

   meta_XFree (data_ret);

 }

+static gboolean

+is_device_synaptics (ClutterInputDevice *device)

+{

+  guchar *has_setting;

+

+  /* We just need looking for a synaptics-specific property */

+  has_setting = get_property (device, "Synaptics Off", XA_INTEGER, 8, 1);

+  if (!has_setting)

+    return FALSE;

+

+  meta_XFree (has_setting);

+  return TRUE;

+}

+

+static void

+change_synaptics_tap_left_handed (ClutterInputDevice *device,

+                                  gboolean            tap_enabled,

+                                  gboolean            left_handed)

+{

+  MetaDisplay *display = meta_get_display ();

+  MetaBackend *backend = meta_get_backend ();

+  Display *xdisplay = meta_backend_x11_get_xdisplay (META_BACKEND_X11 (backend));

+  int device_id;

+  XDevice *xdevice;

+  guchar *tap_action, *buttons;

+  guint buttons_capacity = 16, n_buttons;

+

+  device_id = meta_input_device_x11_get_device_id (device);

+  xdevice = XOpenDevice (xdisplay, device_id);

+  if (!xdevice)

+    return;

+

+  tap_action = get_property (device, "Synaptics Tap Action",

+                             XA_INTEGER, 8, 7);

+  if (!tap_action)

+    goto out;

+

+  tap_action[4] = tap_enabled ? (left_handed ? 3 : 1) : 0;

+  tap_action[5] = tap_enabled ? (left_handed ? 1 : 3) : 0;

+  tap_action[6] = tap_enabled ? 2 : 0;

+

+  change_property (device, "Synaptics Tap Action",

+                   XA_INTEGER, 8, tap_action, 7);

+  meta_XFree (tap_action);

+

+  clutter_x11_trap_x_errors();

+  buttons = g_new (guchar, buttons_capacity);

+  n_buttons = XGetDeviceButtonMapping (xdisplay, xdevice,

+                                       buttons, buttons_capacity);

+

+  while (n_buttons > buttons_capacity)

+    {

+      buttons_capacity = n_buttons;

+      buttons = (guchar *) g_realloc (buttons,

+                                      buttons_capacity * sizeof (guchar));

+

+      n_buttons = XGetDeviceButtonMapping (xdisplay, xdevice,

+                                           buttons, buttons_capacity);

+    }

+

+  buttons[0] = left_handed ? 3 : 1;

+  buttons[2] = left_handed ? 1 : 3;

+  XSetDeviceButtonMapping (xdisplay, xdevice, buttons, n_buttons);

+  g_free (buttons);

+

+  if (clutter_x11_untrap_x_errors())

+    {

+      g_warning ("Could not set synaptics touchpad left-handed for %s",

+                 clutter_input_device_get_device_name (device));

+    }

+

+ out:

+  XCloseDevice (xdisplay, xdevice);

+}

+

+static void

+change_synaptics_speed (ClutterInputDevice *device,

+                        gdouble             speed)

+{

+  MetaDisplay *display = meta_get_display ();

+  MetaBackend *backend = meta_get_backend ();

+  Display *xdisplay = meta_backend_x11_get_xdisplay (META_BACKEND_X11 (backend));

+  int device_id;

+  XDevice *xdevice;

+  XPtrFeedbackControl feedback;

+  XFeedbackState *states, *state;

+  int i, num_feedbacks, motion_threshold, numerator, denominator;

+  gfloat motion_acceleration;

+

+  device_id = meta_input_device_x11_get_device_id (device);

+  xdevice = XOpenDevice (xdisplay, device_id);

+  if (!xdevice)

+    return;

+  /* Get the list of feedbacks for the device */

+  clutter_x11_trap_x_errors();

+  states = XGetFeedbackControl (xdisplay, xdevice, &num_feedbacks);

+  if (clutter_x11_untrap_x_errors())

+    return;

+  if (!states)

+    return;

+

+  /* Calculate acceleration and threshold */

+  motion_acceleration = (speed + 1) * 5; /* speed is [-1..1], map to [0..10] */

+  motion_threshold = CLAMP (10 - floor (motion_acceleration), 1, 10);

+

+  if (motion_acceleration >= 1.0)

+    {

+      /* we want to get the acceleration, with a resolution of 0.5

+       */

+      if ((motion_acceleration - floor (motion_acceleration)) < 0.25)

+        {

+          numerator = floor (motion_acceleration);

+          denominator = 1;

+        }

+      else if ((motion_acceleration - floor (motion_acceleration)) < 0.5)

+        {

+          numerator = ceil (2.0 * motion_acceleration);

+          denominator = 2;

+        }

+      else if ((motion_acceleration - floor (motion_acceleration)) < 0.75)

+        {

+          numerator = floor (2.0 *motion_acceleration);

+          denominator = 2;

+        }

+      else

+        {

+          numerator = ceil (motion_acceleration);

+          denominator = 1;

+        }

+    }

+  else if (motion_acceleration < 1.0 && motion_acceleration > 0)

+    {

+      /* This we do to 1/10ths */

+      numerator = floor (motion_acceleration * 10) + 1;

+      denominator= 10;

+    }

+  else

+    {

+      numerator = -1;

+      denominator = -1;

+    }

+

+  clutter_x11_trap_x_errors();

+

+  state = (XFeedbackState *) states;

+

+  for (i = 0; i < num_feedbacks; i++)

+    {

+      if (state->class == PtrFeedbackClass)

+        {

+          /* And tell the device */

+          feedback.class      = PtrFeedbackClass;

+          feedback.length     = sizeof (XPtrFeedbackControl);

+          feedback.id         = state->id;

+          feedback.threshold  = motion_threshold;

+          feedback.accelNum   = numerator;

+          feedback.accelDenom = denominator;

+

+          XChangeFeedbackControl (xdisplay, xdevice,

+                                  DvAccelNum | DvAccelDenom | DvThreshold,

+                                  (XFeedbackControl *) &feedback);

+          break;

+        }

+

+      state = (XFeedbackState *) ((char *) state + state->length);

+    }

+

+  if (clutter_x11_untrap_x_errors())

+    {

+      g_warning ("Could not set synaptics touchpad acceleration for %s",

+                 clutter_input_device_get_device_name (device));

+    }

+

+  XFreeFeedbackList (states);

+  XCloseDevice (xdisplay, xdevice);

+}

+

 static void

 meta_input_settings_x11_set_send_events (MetaInputSettings        *settings,

                                          ClutterInputDevice       *device,

@@ -173,6 +351,13 @@ meta_input_settings_x11_set_send_events (MetaInputSettings        *settings,

   guchar values[2] = { 0 }; /* disabled, disabled-on-external-mouse */

   guchar *available;

+  if (is_device_synaptics (device))

+    {

+      values[0] = mode != G_DESKTOP_DEVICE_SEND_EVENTS_ENABLED;

+      change_property (device, "Synaptics Off", XA_INTEGER, 8, &values, 1);

+      return;

+    }

+

   available = get_property (device, "libinput Send Events Modes Available",

                             XA_INTEGER, 8, 2);

   if (!available)

@@ -225,6 +410,12 @@ meta_input_settings_x11_set_speed (MetaInputSettings  *settings,

   Display *xdisplay = meta_backend_x11_get_xdisplay (META_BACKEND_X11 (backend));

   gfloat value = speed;

+  if (is_device_synaptics (device))

+    {

+      change_synaptics_speed (device, speed);

+      return;

+    }

+

   change_property (device, "libinput Accel Speed",

                    XInternAtom (xdisplay, "FLOAT", False),

                    32, &value, 1);

@@ -251,6 +442,19 @@ meta_input_settings_x11_set_left_handed (MetaInputSettings  *settings,

   else

     {

       value = enabled ? 1 : 0;

+

+      if (is_device_synaptics (device))

+        {

+          GSettings *settings;

+

+          settings = g_settings_new ("org.gnome.desktop.peripherals.touchpad");

+          change_synaptics_tap_left_handed (device,

+                                            g_settings_get_boolean (settings, "tap-to-click"),

+                                            enabled);

+          g_object_unref (settings);

+          return;

+        }

+

       change_property (device, "libinput Left Handed Enabled",

                        XA_INTEGER, 8, &value, 1);

     }

@@ -274,6 +478,20 @@ meta_input_settings_x11_set_tap_enabled (MetaInputSettings  *settings,

 {

   guchar value = (enabled) ? 1 : 0;

+  if (is_device_synaptics (device))

+    {

+      GDesktopTouchpadHandedness handedness;

+      GSettings *settings;

+

+      settings = g_settings_new ("org.gnome.desktop.peripherals.touchpad");

+      handedness = g_settings_get_enum (settings, "left-handed");

+      g_object_unref (settings);

+

+      change_synaptics_tap_left_handed (device, enabled,

+                                        handedness == G_DESKTOP_TOUCHPAD_HANDEDNESS_LEFT);

+      return;

+    }

+

   change_property (device, "libinput Tapping Enabled",

                    XA_INTEGER, 8, &value, 1);

 }

@@ -307,6 +525,27 @@ meta_input_settings_x11_set_invert_scroll (MetaInputSettings  *settings,

 {

   guchar value = (inverted) ? 1 : 0;

+  if (is_device_synaptics (device))

+    {

+      gint32 *scrolling_distance;

+

+      scrolling_distance = get_property (device, "Synaptics Scrolling Distance",

+                                         XA_INTEGER, 32, 2);

+      if (scrolling_distance)

+        {

+          scrolling_distance[0] = inverted ?

+            -abs (scrolling_distance[0]) : abs (scrolling_distance[0]);

+          scrolling_distance[1] = inverted ?

+            -abs (scrolling_distance[1]) : abs (scrolling_distance[1]);

+

+          change_property (device, "Synaptics Scrolling Distance",

+                           XA_INTEGER, 32, scrolling_distance, 2);

+          meta_XFree (scrolling_distance);

+        }

+

+      return;

+    }

+

   change_property (device, "libinput Natural Scrolling Enabled",

                    XA_INTEGER, 8, &value, 1);

 }

@@ -320,6 +559,41 @@ change_scroll_method (ClutterInputDevice           *device,

   guchar *current = NULL;

   guchar *available = NULL;

+  if (is_device_synaptics (device))

+    {

+      switch (method)

+        {

+        case SCROLL_METHOD_FIELD_EDGE:

+          current = get_property (device, "Synaptics Edge Scrolling",

+                                  XA_INTEGER, 8, 3);

+          if (current)

+            {

+              current[0] = enabled;

+              current[1] = enabled;

+              change_property (device, "Synaptics Edge Scrolling",

+                               XA_INTEGER, 8, current, 3);

+              meta_XFree (current);

+            }

+          break;

+        case SCROLL_METHOD_FIELD_2FG:

+          current = get_property (device, "Synaptics Two-Finger Scrolling",

+                                  XA_INTEGER, 8, 2);

+          if (current)

+            {

+              current[0] = enabled;

+              current[1] = enabled;

+              change_property (device, "Synaptics Two-Finger Scrolling",

+                               XA_INTEGER, 8, current, 2);

+              meta_XFree (current);

+            }

+          break;

+        default:

+          break;

+        }

+

+      return;

+    }

+

   available = get_property (device, "libinput Scroll Methods Available",

                             XA_INTEGER, 8, SCROLL_METHOD_NUM_FIELDS);

   if (!available || !available[method])

-- 

2.36.1

From 963ff120898e7e42d80d5761753e76adcf16c132 Mon Sep 17 00:00:00 2001

From: Carlos Garnacho <carlosg@gnome.org>

Date: Tue, 13 Feb 2018 11:44:40 +0100

Subject: [PATCH 2/6] clutter: Extend touchpad device property check for

 Synaptics

So we reliably get CLUTTER_TOUCHPAD_DEVICE for those. The other heuristics

to get the device type may fall short.

---

 src/backends/x11/meta-seat-x11.c | 17 +++++++++++++++--

 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/backends/x11/meta-seat-x11.c b/src/backends/x11/meta-seat-x11.c

index d43834bd7..73938e22e 100644

--- a/src/backends/x11/meta-seat-x11.c

+++ b/src/backends/x11/meta-seat-x11.c

@@ -246,7 +246,8 @@ is_touch_device (XIAnyClassInfo         **classes,

 }

 static gboolean

-is_touchpad_device (XIDeviceInfo *info)

+query_exists_device_property (XIDeviceInfo *info,

+                              const char   *property)

 {

   gulong nitems, bytes_after;

   uint32_t *data = NULL;

@@ -254,7 +255,7 @@ is_touchpad_device (XIDeviceInfo *info)

   Atom type;

   Atom prop;

-  prop = XInternAtom (clutter_x11_get_default_display (), "libinput Tapping Enabled", True);

+  prop = XInternAtom (clutter_x11_get_default_display (), property, True);

   if (prop == None)

     return FALSE;

@@ -275,6 +276,18 @@ is_touchpad_device (XIDeviceInfo *info)

   return TRUE;

 }

+static gboolean

+is_touchpad_device (XIDeviceInfo *info)

+{

+  if (query_exists_device_property (info, "libinput Tapping Enabled"))

+    return TRUE;

+

+  if (query_exists_device_property (info, "Synaptics Off"))

+    return TRUE;

+

+  return FALSE;

+}

+

 static gboolean

 get_device_ids (XIDeviceInfo  *info,

                 char         **vendor_id,

-- 

2.36.1

From 86cc1b46dae01da619980af826eb9bf81cf31143 Mon Sep 17 00:00:00 2001

From: Rui Matos <tiagomatos@gmail.com>

Date: Mon, 9 Oct 2017 18:39:52 +0200

Subject: [PATCH 3/6] backends/x11: Add a synaptics check for two finger scroll

 availability

Commit "backends/x11: Support synaptics configuration" added support

for synaptics two finger scrolling but didn't add the code to check

that it is available resulting in the upper layer always assuming it

isn't.

---

 src/backends/x11/meta-input-settings-x11.c | 11 +++++++++++

 1 file changed, 11 insertions(+)

diff --git a/src/backends/x11/meta-input-settings-x11.c b/src/backends/x11/meta-input-settings-x11.c

index 426056390..db2b2a4fb 100644

--- a/src/backends/x11/meta-input-settings-x11.c

+++ b/src/backends/x11/meta-input-settings-x11.c

@@ -637,6 +637,17 @@ meta_input_settings_x11_has_two_finger_scroll (MetaInputSettings  *settings,

   guchar *available = NULL;

   gboolean has_two_finger = TRUE;

+  if (is_device_synaptics (device))

+    {

+      available = get_property (device, "Synaptics Capabilities",

+                                XA_INTEGER, 8, 4);

+      if (!available || !available[3])

+          has_two_finger = FALSE;

+

+      meta_XFree (available);

+      return has_two_finger;

+    }

+

   available = get_property (device, "libinput Scroll Methods Available",

                             XA_INTEGER, 8, SCROLL_METHOD_NUM_FIELDS);

   if (!available || !available[SCROLL_METHOD_FIELD_2FG])

-- 

2.36.1

From 32e2da07eeb1f9edcf03751285a756ab1acca6a8 Mon Sep 17 00:00:00 2001

From: Rui Matos <tiagomatos@gmail.com>

Date: Mon, 9 Oct 2017 18:55:56 +0200

Subject: [PATCH 4/6] backends/x11: Add disable while typing support for

 synaptics

This is basically a copy of the old g-s-d mouse plugin code to manage

syndaemon when the synaptics driver is being used.

---

 src/backends/x11/meta-input-settings-x11.c | 112 +++++++++++++++++++++

 1 file changed, 112 insertions(+)

diff --git a/src/backends/x11/meta-input-settings-x11.c b/src/backends/x11/meta-input-settings-x11.c

index db2b2a4fb..bf9d769e9 100644

--- a/src/backends/x11/meta-input-settings-x11.c

+++ b/src/backends/x11/meta-input-settings-x11.c

@@ -35,6 +35,9 @@

 #ifdef HAVE_LIBGUDEV

 #include <gudev/gudev.h>

 #endif

+#ifdef __linux

+#include <sys/prctl.h>

+#endif

 #include "backends/x11/meta-backend-x11.h"

 #include "backends/x11/meta-input-device-x11.h"

@@ -46,6 +49,8 @@ typedef struct _MetaInputSettingsX11Private

 #ifdef HAVE_LIBGUDEV

   GUdevClient *udev_client;

 #endif

+  gboolean syndaemon_spawned;

+  GPid syndaemon_pid;

 } MetaInputSettingsX11Private;

 G_DEFINE_TYPE_WITH_PRIVATE (MetaInputSettingsX11, meta_input_settings_x11,

@@ -343,6 +348,107 @@ change_synaptics_speed (ClutterInputDevice *device,

   XCloseDevice (xdisplay, xdevice);

 }

+/* Ensure that syndaemon dies together with us, to avoid running several of

+ * them */

+static void

+setup_syndaemon (gpointer user_data)

+{

+#ifdef __linux

+  prctl (PR_SET_PDEATHSIG, SIGHUP);

+#endif

+}

+

+static gboolean

+have_program_in_path (const char *name)

+{

+  gchar *path;

+  gboolean result;

+

+  path = g_find_program_in_path (name);

+  result = (path != NULL);

+  g_free (path);

+  return result;

+}

+

+static void

+syndaemon_died (GPid     pid,

+                gint     status,

+                gpointer user_data)

+{

+  MetaInputSettingsX11 *settings_x11 = META_INPUT_SETTINGS_X11 (user_data);

+  MetaInputSettingsX11Private *priv =

+    meta_input_settings_x11_get_instance_private (settings_x11);

+  GError *error = NULL;

+

+  if (!g_spawn_check_exit_status (status, &error))

+    {

+      if ((WIFSIGNALED (status) && WTERMSIG (status) != SIGHUP) ||

+          error->domain == G_SPAWN_EXIT_ERROR)

+        g_warning ("Syndaemon exited unexpectedly: %s", error->message);

+      g_error_free (error);

+    }

+

+  g_spawn_close_pid (pid);

+  priv->syndaemon_spawned = FALSE;

+}

+

+static void

+set_synaptics_disable_w_typing (MetaInputSettings *settings,

+                                gboolean           state)

+{

+  MetaInputSettingsX11 *settings_x11 = META_INPUT_SETTINGS_X11 (settings);

+  MetaInputSettingsX11Private *priv =

+    meta_input_settings_x11_get_instance_private (settings_x11);

+

+  if (state)

+    {

+      GError *error = NULL;

+      GPtrArray *args;

+

+      if (priv->syndaemon_spawned)

+        return;

+

+      if (!have_program_in_path ("syndaemon"))

+        return;

+

+      args = g_ptr_array_new ();

+

+      g_ptr_array_add (args, (gpointer)"syndaemon");

+      g_ptr_array_add (args, (gpointer)"-i");

+      g_ptr_array_add (args, (gpointer)"1.0");

+      g_ptr_array_add (args, (gpointer)"-t");

+      g_ptr_array_add (args, (gpointer)"-K");

+      g_ptr_array_add (args, (gpointer)"-R");

+      g_ptr_array_add (args, NULL);

+

+      /* we must use G_SPAWN_DO_NOT_REAP_CHILD to avoid

+       * double-forking, otherwise syndaemon will immediately get

+       * killed again through (PR_SET_PDEATHSIG when the intermediate

+       * process dies */

+      g_spawn_async (g_get_home_dir (), (char **) args->pdata, NULL,

+                     G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD, setup_syndaemon, NULL,

+                     &priv->syndaemon_pid, &error);

+

+      priv->syndaemon_spawned = (error == NULL);

+      g_ptr_array_free (args, TRUE);

+

+      if (error)

+        {

+          g_warning ("Failed to launch syndaemon: %s", error->message);

+          g_error_free (error);

+        }

+      else

+        {

+          g_child_watch_add (priv->syndaemon_pid, syndaemon_died, settings);

+        }

+    }

+  else if (priv->syndaemon_spawned)

+    {

+      kill (priv->syndaemon_pid, SIGHUP);

+      priv->syndaemon_spawned = FALSE;

+    }

+}

+

 static void

 meta_input_settings_x11_set_send_events (MetaInputSettings        *settings,

                                          ClutterInputDevice       *device,

@@ -467,6 +573,12 @@ meta_input_settings_x11_set_disable_while_typing (MetaInputSettings  *settings,

 {

   guchar value = (enabled) ? 1 : 0;

+  if (is_device_synaptics (device))

+    {

+      set_synaptics_disable_w_typing (settings, enabled);

+      return;

+    }

+

   change_property (device, "libinput Disable While Typing Enabled",

                    XA_INTEGER, 8, &value, 1);

 }

-- 

2.36.1

From 6da0bfe86f416d3cfc5cc6993e8e2f6ca255e85a Mon Sep 17 00:00:00 2001

From: Carlos Garnacho <carlosg@gnome.org>

Date: Wed, 13 Jun 2018 13:48:24 +0200

Subject: [PATCH 5/6] clutter: Only reset scroll axes on slave devices

As a plus, unknown source device IDs will just warn instead of crash.

---

 src/backends/x11/meta-seat-x11.c | 4 +++-

 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/backends/x11/meta-seat-x11.c b/src/backends/x11/meta-seat-x11.c

index 73938e22e..6d2c7d374 100644

--- a/src/backends/x11/meta-seat-x11.c

+++ b/src/backends/x11/meta-seat-x11.c

@@ -2362,7 +2362,9 @@ meta_seat_x11_translate_event (MetaSeatX11  *seat,

               seat->has_pointer_focus = FALSE;

           }

-        meta_input_device_x11_reset_scroll_info (source_device);

+        if (clutter_input_device_get_device_mode (source_device) ==

+            CLUTTER_INPUT_MODE_PHYSICAL)

+          meta_input_device_x11_reset_scroll_info (source_device);

         clutter_event_set_device (event, device);

         clutter_event_set_source_device (event, source_device);

-- 

2.36.1

From da60cf38c7fcec68f8e79a8a3a174e551c07a64a Mon Sep 17 00:00:00 2001

From: Rui Matos <tiagomatos@gmail.com>

Date: Tue, 10 Oct 2017 19:07:27 +0200

Subject: [PATCH 6/6] backends/x11: Support plain old X device configuration

We re-use part of the code added to support synaptics and add a few

bits specific for xorg-x11-drv-evdev devices.

---

 src/backends/x11/meta-input-settings-x11.c | 98 +++++++++++++++++-----

 1 file changed, 75 insertions(+), 23 deletions(-)

diff --git a/src/backends/x11/meta-input-settings-x11.c b/src/backends/x11/meta-input-settings-x11.c

index bf9d769e9..49dcb74f1 100644

--- a/src/backends/x11/meta-input-settings-x11.c

+++ b/src/backends/x11/meta-input-settings-x11.c

@@ -185,17 +185,30 @@ is_device_synaptics (ClutterInputDevice *device)

   return TRUE;

 }

+static gboolean

+is_device_libinput (ClutterInputDevice *device)

+{

+  guchar *has_setting;

+

+  /* We just need looking for a synaptics-specific property */

+  has_setting = get_property (device, "libinput Send Events Modes Available", XA_INTEGER, 8, 2);

+  if (!has_setting)

+    return FALSE;

+

+  meta_XFree (has_setting);

+  return TRUE;

+}

+

 static void

-change_synaptics_tap_left_handed (ClutterInputDevice *device,

-                                  gboolean            tap_enabled,

-                                  gboolean            left_handed)

+change_x_device_left_handed (ClutterInputDevice *device,

+                             gboolean            left_handed)

 {

   MetaDisplay *display = meta_get_display ();

   MetaBackend *backend = meta_get_backend ();

   Display *xdisplay = meta_backend_x11_get_xdisplay (META_BACKEND_X11 (backend));

   int device_id;

   XDevice *xdevice;

-  guchar *tap_action, *buttons;

+  guchar *buttons;

   guint buttons_capacity = 16, n_buttons;

   device_id = meta_input_device_x11_get_device_id (device);

@@ -203,19 +216,6 @@ change_synaptics_tap_left_handed (ClutterInputDevice *device,

   if (!xdevice)

     return;

-  tap_action = get_property (device, "Synaptics Tap Action",

-                             XA_INTEGER, 8, 7);

-  if (!tap_action)

-    goto out;

-

-  tap_action[4] = tap_enabled ? (left_handed ? 3 : 1) : 0;

-  tap_action[5] = tap_enabled ? (left_handed ? 1 : 3) : 0;

-  tap_action[6] = tap_enabled ? 2 : 0;

-

-  change_property (device, "Synaptics Tap Action",

-                   XA_INTEGER, 8, tap_action, 7);

-  meta_XFree (tap_action);

-

   clutter_x11_trap_x_errors();

   buttons = g_new (guchar, buttons_capacity);

   n_buttons = XGetDeviceButtonMapping (xdisplay, xdevice,

@@ -238,17 +238,39 @@ change_synaptics_tap_left_handed (ClutterInputDevice *device,

   if (clutter_x11_untrap_x_errors())

     {

-      g_warning ("Could not set synaptics touchpad left-handed for %s",

+      g_warning ("Could not set left-handed for %s",

                  clutter_input_device_get_device_name (device));

     }

- out:

   XCloseDevice (xdisplay, xdevice);

 }