From 705818340dec181335b48ab73d6411e639daaeae Mon Sep 17 00:00:00 2001 From: Carlos Garnacho 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 | 275 +++++++++++++++++++++ 1 file changed, 275 insertions(+) diff --git a/src/backends/x11/meta-input-settings-x11.c b/src/backends/x11/meta-input-settings-x11.c index 96390285a6..0631fd2fee 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 +#include #include #include #include @@ -165,6 +166,184 @@ 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 (); + MetaX11Display *x11_display = display ? display->x11_display : NULL; + 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); + + if (x11_display) + meta_x11_error_trap_push (x11_display); + 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 (x11_display && meta_x11_error_trap_pop_with_return (x11_display)) + { + 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 (); + MetaX11Display *x11_display = display ? display->x11_display : NULL; + 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 */ + states = XGetFeedbackControl (xdisplay, xdevice, &num_feedbacks); + 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; + } + + if (x11_display) + meta_x11_error_trap_push (x11_display); + + 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 (x11_display && meta_x11_error_trap_pop_with_return (x11_display)) + { + 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 +352,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 +411,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 +443,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 +479,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 +526,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 +560,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.31.1 From 50c4733acf56b3b67a2706d32f5c455cb51f9458 Mon Sep 17 00:00:00 2001 From: Carlos Garnacho 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 d43834bd7b..73938e22e0 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.31.1 From 307970305d11cdca1b97c53c85bda8b809ff4f0f Mon Sep 17 00:00:00 2001 From: Rui Matos 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 0631fd2fee..2ac080127c 100644 --- a/src/backends/x11/meta-input-settings-x11.c +++ b/src/backends/x11/meta-input-settings-x11.c @@ -638,6 +638,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.31.1 From cba31f88ddbfb7355de1daa34397aba8e8607765 Mon Sep 17 00:00:00 2001 From: Rui Matos 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 2ac080127c..2658b82172 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 #endif +#ifdef __linux +#include +#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, @@ -344,6 +349,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, @@ -468,6 +574,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.31.1 From 354d34263534d0c7a5c7f7169d8b4a3dba79491c Mon Sep 17 00:00:00 2001 From: Carlos Garnacho 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 73938e22e0..6d2c7d3740 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.31.1 From b7f94b5dd09953d5a4c8aee1b79491d71f8c1e0e Mon Sep 17 00:00:00 2001 From: Rui Matos 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 2658b82172..80bc33c6b5 100644 --- a/src/backends/x11/meta-input-settings-x11.c +++ b/src/backends/x11/meta-input-settings-x11.c @@ -185,10 +185,23 @@ 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; @@ -196,7 +209,7 @@ change_synaptics_tap_left_handed (ClutterInputDevice *device, 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); @@ -204,19 +217,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); - if (x11_display) meta_x11_error_trap_push (x11_display); buttons = g_new (guchar, buttons_capacity); @@ -240,17 +240,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; @@ -349,6 +371,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 @@ -517,9 +556,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; } @@ -561,6 +601,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); @@ -778,7 +823,14 @@ meta_input_settings_x11_set_scroll_button (MetaInputSettings *settings, { gchar lock = button_lock; + if (!is_device_libinput (device)) + { + change_x_device_scroll_button (device, button); + return; + } + change_scroll_method (device, SCROLL_METHOD_FIELD_BUTTON, button != 0); + change_property (device, "libinput Button Scrolling Button", XA_CARDINAL, 32, &button, 1); change_property (device, "libinput Button Scrolling Button Lock Enabled", -- 2.31.1