From 3f7ba6739773f43a3ad2a5d26cb8c3365f77cc00 Mon Sep 17 00:00:00 2001

From: Rui Matos <tiagomatos@gmail.com>

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

Subject: [PATCH 1/3] 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 051a1c605..887bc8b42 100644

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

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

@@ -630,6 +630,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.21.0

From 717561b28f35e05d40fb941baba781436a0abf68 Mon Sep 17 00:00:00 2001

From: Rui Matos <tiagomatos@gmail.com>

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

Subject: [PATCH 2/3] 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 887bc8b42..12a592c75 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/meta-logical-monitor.h"

 #include "backends/x11/meta-backend-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,

@@ -337,6 +342,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,

@@ -461,6 +567,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.21.0

From 0afa6d0940ca4f5ffafd24effd2c414963a44277 Mon Sep 17 00:00:00 2001

From: Rui Matos <tiagomatos@gmail.com>

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

Subject: [PATCH 3/3] 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 | 97 +++++++++++++++++-----

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

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

index 12a592c75..80e5ed10e 100644

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

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

@@ -182,36 +182,36 @@ 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 ();

   MetaX11Display *x11_display = display ? display->x11_display : NULL;

   MetaBackend *backend = meta_get_backend ();

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

   XDevice *xdevice;

-  guchar *tap_action, *buttons;

+  guchar *buttons;

   guint buttons_capacity = 16, n_buttons;

   xdevice = XOpenDevice(xdisplay, clutter_input_device_get_device_id (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);

-

   if (x11_display)

     meta_x11_error_trap_push (x11_display);

   buttons = g_new (guchar, buttons_capacity);

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

   if (x11_display && meta_x11_error_trap_pop_with_return (x11_display))

     {

-      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);

 }

 static void

-change_synaptics_speed (ClutterInputDevice *device,

-                        gdouble             speed)

+change_synaptics_tap_left_handed (ClutterInputDevice *device,

+                                  gboolean            tap_enabled,

+                                  gboolean            left_handed)

+{

+  guchar *tap_action;

+

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

+                             XA_INTEGER, 8, 7);

+  if (!tap_action)

+    return;

+

+  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);

+

+  change_x_device_left_handed (device, left_handed);

+}

+

+static void

+change_x_device_speed (ClutterInputDevice *device,

+                       gdouble             speed)

 {

   MetaDisplay *display = meta_get_display ();

   MetaX11Display *x11_display = display ? display->x11_display : NULL;

@@ -342,6 +364,23 @@ change_synaptics_speed (ClutterInputDevice *device,

   XCloseDevice (xdisplay, xdevice);

 }

+static void

+change_x_device_scroll_button (ClutterInputDevice *device,

+                               guint               button)

+{

+  guchar value;

+

+  value = button > 0 ? 1 : 0;

+  change_property (device, "Evdev Wheel Emulation",

+                   XA_INTEGER, 8, &value, 1);

+  if (button > 0)

+    {

+      value = button;

+      change_property (device, "Evdev Wheel Emulation Button",

+                       XA_INTEGER, 8, &value, 1);

+    }

+}

+

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

  * them */

 static void

@@ -510,9 +549,10 @@ 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))

+  if (is_device_synaptics (device) ||

+      !is_device_libinput (device))

     {

-      change_synaptics_speed (device, speed);

+      change_x_device_speed (device, speed);

       return;

     }

@@ -554,6 +594,11 @@ meta_input_settings_x11_set_left_handed (MetaInputSettings  *settings,

           g_object_unref (settings);

           return;

         }

+      else if (!is_device_libinput (device) && device_type != CLUTTER_PAD_DEVICE)

+        {

+          change_x_device_left_handed (device, enabled);

+          return;

+        }

       change_property (device, "libinput Left Handed Enabled",

                        XA_INTEGER, 8, &value, 1);

@@ -767,6 +812,12 @@ meta_input_settings_x11_set_scroll_button (MetaInputSettings  *settings,

                                            ClutterInputDevice *device,

                                            guint               button)

 {

+  if (!is_device_libinput (device))

+    {

+      change_x_device_scroll_button (device, button);

+      return;

+    }

+

   change_property (device, "libinput Button Scrolling Button",

                    XA_INTEGER, 32, &button, 1);

 }

-- 

2.21.0