Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
openSUSE:Leap:42.3:Rings:2-TestDVD
gnome-settings-daemon
gnome-settings-daemon-revert-libinput-mandatory...
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File gnome-settings-daemon-revert-libinput-mandatory.patch of Package gnome-settings-daemon
From f5aa66f135c9e7e9c57363c8933e6a87d0900112 Mon Sep 17 00:00:00 2001 From: Frederic Crozat <fcrozat@suse.com> Date: Fri, 4 Mar 2016 15:47:30 +0100 Subject: [PATCH 1/3] Revert "mouse: Remove support for non-libinput mouse configurations" This reverts commit 66c211ff24bec6a938d6a6a0dd8730f4689ef383. --- plugins/mouse/gsd-mouse-manager.c | 1255 ++++++++++++++++++++++++++++++++++++- 1 file changed, 1252 insertions(+), 3 deletions(-) diff --git a/plugins/mouse/gsd-mouse-manager.c b/plugins/mouse/gsd-mouse-manager.c index cf2c28c..da7b378 100644 --- a/plugins/mouse/gsd-mouse-manager.c +++ b/plugins/mouse/gsd-mouse-manager.c @@ -19,17 +19,39 @@ #include "config.h" +#include <sys/types.h> +#include <sys/wait.h> +#include <stdlib.h> +#include <stdio.h> +#include <unistd.h> +#include <string.h> +#include <errno.h> +#include <math.h> +#ifdef __linux +#include <sys/prctl.h> +#endif + #include <locale.h> #include <glib.h> #include <glib/gi18n.h> #include <gio/gio.h> +#include <gtk/gtk.h> +#include <gdk/gdk.h> +#include <gdk/gdkx.h> +#include <gdk/gdkkeysyms.h> +#include <X11/keysym.h> +#include <X11/Xatom.h> #include <gdesktop-enums.h> +#include <X11/extensions/XInput.h> +#include <X11/extensions/XIproto.h> + #include "gnome-settings-bus.h" #include "gnome-settings-profile.h" #include "gsd-mouse-manager.h" +#include "gsd-input-helper.h" #include "gsd-enums.h" #include "gsd-settings-migrate.h" @@ -38,20 +60,42 @@ #define GSD_SETTINGS_MOUSE_SCHEMA "org.gnome.settings-daemon.peripherals.mouse" #define GSETTINGS_MOUSE_SCHEMA "org.gnome.desktop.peripherals.mouse" #define GSETTINGS_TOUCHPAD_SCHEMA "org.gnome.desktop.peripherals.touchpad" +#define GSETTINGS_TRACKBALL_SCHEMA "org.gnome.desktop.peripherals.trackball" + +/* Keys for both touchpad and mouse */ +#define KEY_LEFT_HANDED "left-handed" /* a boolean for mouse, an enum for touchpad */ +#define KEY_SPEED "speed" + +/* Touchpad settings */ +#define KEY_EDGE_SCROLLING_ENABLED "edge-scrolling-enabled" +#define KEY_TAP_TO_CLICK "tap-to-click" +#define KEY_SEND_EVENTS "send-events" +#define KEY_NATURAL_SCROLL_ENABLED "natural-scroll" /* Mouse settings */ #define KEY_LOCATE_POINTER "locate-pointer" #define KEY_DWELL_CLICK_ENABLED "dwell-click-enabled" #define KEY_SECONDARY_CLICK_ENABLED "secondary-click-enabled" +/* Trackball settings */ +#define KEY_SCROLL_WHEEL_BUTTON "scroll-wheel-emulation-button" + struct GsdMouseManagerPrivate { guint start_idle_id; GSettings *touchpad_settings; - GSettings *mouse_a11y_settings; GSettings *mouse_settings; + GSettings *mouse_a11y_settings; + GSettings *trackball_settings; GSettings *gsd_mouse_settings; + GdkDeviceManager *device_manager; + guint device_added_id; + guint device_removed_id; + GHashTable *blacklist; + gboolean mousetweaks_daemon_running; + gboolean syndaemon_spawned; + GPid syndaemon_pid; gboolean locate_pointer_spawned; GPid locate_pointer_pid; }; @@ -59,6 +103,12 @@ struct GsdMouseManagerPrivate static void gsd_mouse_manager_class_init (GsdMouseManagerClass *klass); static void gsd_mouse_manager_init (GsdMouseManager *mouse_manager); static void gsd_mouse_manager_finalize (GObject *object); +static void set_tap_to_click (GdkDevice *device, + gboolean state, + gboolean left_handed); +static void ensure_touchpad_active (GsdMouseManager *manager); +static gboolean get_touchpad_enabled (GsdMouseManager *manager); + G_DEFINE_TYPE (GsdMouseManager, gsd_mouse_manager, G_TYPE_OBJECT) @@ -76,6 +126,775 @@ gsd_mouse_manager_class_init (GsdMouseManagerClass *klass) g_type_class_add_private (klass, sizeof (GsdMouseManagerPrivate)); } +static XDevice * +open_gdk_device (GdkDevice *device) +{ + XDevice *xdevice; + int id; + + g_object_get (G_OBJECT (device), "device-id", &id, NULL); + + gdk_error_trap_push (); + + xdevice = XOpenDevice (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), id); + + if (gdk_error_trap_pop () != 0) + return NULL; + + return xdevice; +} + +static gboolean +device_info_is_trackball (XDeviceInfo *device_info) +{ + gboolean retval; + + retval = (device_info->type == XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), XI_TRACKBALL, False)); + if (retval == FALSE && + device_info->name != NULL) { + char *lowercase; + + lowercase = g_ascii_strdown (device_info->name, -1); + retval = strstr (lowercase, "trackball") != NULL; + g_free (lowercase); + } + + return retval; +} + +static gboolean +device_is_trackball (GdkDevice *device) +{ + XDeviceInfo *device_info; + gboolean retval = FALSE; + gint n_devices; + guint i; + int id; + + g_object_get (G_OBJECT (device), "device-id", &id, NULL); + + gdk_error_trap_push (); + + device_info = XListInputDevices (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), &n_devices); + if (device_info == NULL) + return retval; + + for (i = 0; i < n_devices; i++) { + if (device_info[i].id != id) + continue; + + retval = device_info_is_trackball (&device_info[i]); + break; + } + XFreeDeviceList (device_info); + + if (gdk_error_trap_pop () != 0) + return FALSE; + + return retval; +} + +static gboolean +device_is_blacklisted (GsdMouseManager *manager, + GdkDevice *device) +{ + int id; + g_object_get (G_OBJECT (device), "device-id", &id, NULL); + if (g_hash_table_lookup (manager->priv->blacklist, GINT_TO_POINTER (id)) != NULL) { + g_debug ("device %s (%d) is blacklisted", gdk_device_get_name (device), id); + return TRUE; + } + return FALSE; +} + +static gboolean +device_is_ignored (GsdMouseManager *manager, + GdkDevice *device) +{ + GdkInputSource source; + const char *name; + + if (device_is_blacklisted (manager, device)) + return TRUE; + + source = gdk_device_get_source (device); + if (source != GDK_SOURCE_MOUSE && + source != GDK_SOURCE_TOUCHPAD && + source != GDK_SOURCE_CURSOR) + return TRUE; + + name = gdk_device_get_name (device); + if (name != NULL && g_str_equal ("Virtual core XTEST pointer", name)) + return TRUE; + + return FALSE; +} + +static void +configure_button_layout (guchar *buttons, + gint n_buttons, + gboolean left_handed) +{ + const gint left_button = 1; + gint right_button; + gint i; + + /* if the button is higher than 2 (3rd button) then it's + * probably one direction of a scroll wheel or something else + * uninteresting + */ + right_button = MIN (n_buttons, 3); + + /* If we change things we need to make sure we only swap buttons. + * If we end up with multiple physical buttons assigned to the same + * logical button the server will complain. This code assumes physical + * button 0 is the physical left mouse button, and that the physical + * button other than 0 currently assigned left_button or right_button + * is the physical right mouse button. + */ + + /* check if the current mapping satisfies the above assumptions */ + if (buttons[left_button - 1] != left_button && + buttons[left_button - 1] != right_button) + /* The current mapping is weird. Swapping buttons is probably not a + * good idea. + */ + return; + + /* check if we are left_handed and currently not swapped */ + if (left_handed && buttons[left_button - 1] == left_button) { + /* find the right button */ + for (i = 0; i < n_buttons; i++) { + if (buttons[i] == right_button) { + buttons[i] = left_button; + break; + } + } + /* swap the buttons */ + buttons[left_button - 1] = right_button; + } + /* check if we are not left_handed but are swapped */ + else if (!left_handed && buttons[left_button - 1] == right_button) { + /* find the right button */ + for (i = 0; i < n_buttons; i++) { + if (buttons[i] == left_button) { + buttons[i] = right_button; + break; + } + } + /* swap the buttons */ + buttons[left_button - 1] = left_button; + } +} + +static gboolean +xinput_device_has_buttons (GdkDevice *device) +{ + int i; + XAnyClassInfo *class_info; + + /* FIXME can we use the XDevice's classes here instead? */ + XDeviceInfo *device_info, *info; + gint n_devices; + int id; + + /* Find the XDeviceInfo for the GdkDevice */ + g_object_get (G_OBJECT (device), "device-id", &id, NULL); + + device_info = XListInputDevices (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), &n_devices); + if (device_info == NULL) + return FALSE; + + info = NULL; + for (i = 0; i < n_devices; i++) { + if (device_info[i].id == id) { + info = &device_info[i]; + break; + } + } + if (info == NULL) + goto bail; + + class_info = info->inputclassinfo; + for (i = 0; i < info->num_classes; i++) { + if (class_info->class == ButtonClass) { + XButtonInfo *button_info; + + button_info = (XButtonInfo *) class_info; + if (button_info->num_buttons > 0) { + XFreeDeviceList (device_info); + return TRUE; + } + } + + class_info = (XAnyClassInfo *) (((guchar *) class_info) + + class_info->length); + } + +bail: + XFreeDeviceList (device_info); + + return FALSE; +} + +static gboolean +touchpad_has_single_button (XDevice *device) +{ + Atom type, prop; + int format; + unsigned long nitems, bytes_after; + unsigned char *data; + gboolean is_single_button = FALSE; + int rc; + + prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Capabilities", False); + if (!prop) + return FALSE; + + gdk_error_trap_push (); + rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), device, prop, 0, 1, False, + XA_INTEGER, &type, &format, &nitems, + &bytes_after, &data); + if (rc == Success && type == XA_INTEGER && format == 8 && nitems >= 3) + is_single_button = (data[0] == 1 && data[1] == 0 && data[2] == 0); + + if (rc == Success) + XFree (data); + + gdk_error_trap_pop_ignored (); + + return is_single_button; +} + +static void +set_left_handed (GsdMouseManager *manager, + GdkDevice *device, + gboolean mouse_left_handed, + gboolean touchpad_left_handed) +{ + XDevice *xdevice; + guchar *buttons; + gsize buttons_capacity = 16; + gboolean left_handed; + gint n_buttons; + + if (!xinput_device_has_buttons (device)) + return; + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + return; + + xdevice = open_gdk_device (device); + if (xdevice == NULL) + return; + + g_debug ("setting handedness on %s", gdk_device_get_name (device)); + + buttons = g_new (guchar, buttons_capacity); + + /* If the device is a touchpad, swap tap buttons + * around too, otherwise a tap would be a right-click */ + if (xdevice_is_synaptics (xdevice)) { + gboolean tap = g_settings_get_boolean (manager->priv->touchpad_settings, KEY_TAP_TO_CLICK); + gboolean single_button = touchpad_has_single_button (xdevice); + + left_handed = touchpad_left_handed; + + if (tap && !single_button) + set_tap_to_click (device, tap, left_handed); + + if (single_button) + goto out; + } else { + left_handed = mouse_left_handed; + } + + gdk_error_trap_push (); + + n_buttons = XGetDeviceButtonMapping (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), 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 (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + buttons, + buttons_capacity); + } + + configure_button_layout (buttons, n_buttons, left_handed); + + XSetDeviceButtonMapping (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, buttons, n_buttons); + gdk_error_trap_pop_ignored (); + +out: + xdevice_close (xdevice); + g_free (buttons); +} + +static void +set_motion (GsdMouseManager *manager, + GdkDevice *device) +{ + XDevice *xdevice; + XPtrFeedbackControl feedback; + XFeedbackState *states, *state; + int num_feedbacks; + int numerator, denominator; + gfloat motion_acceleration; + int motion_threshold; + GSettings *settings; + gdouble speed; + guint i; + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + return; + + xdevice = open_gdk_device (device); + if (xdevice == NULL) + return; + + g_debug ("setting motion on %s", gdk_device_get_name (device)); + + if (xdevice_is_synaptics (xdevice)) + settings = manager->priv->touchpad_settings; + else + settings = manager->priv->mouse_settings; + + speed = g_settings_get_double (settings, KEY_SPEED); + + /* 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; + } + + gdk_error_trap_push (); + + /* Get the list of feedbacks for the device */ + states = XGetFeedbackControl (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, &num_feedbacks); + if (states == NULL) + goto out; + 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; + + g_debug ("Setting accel %d/%d, threshold %d for device '%s'", + numerator, denominator, motion_threshold, gdk_device_get_name (device)); + + XChangeFeedbackControl (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), + xdevice, + DvAccelNum | DvAccelDenom | DvThreshold, + (XFeedbackControl *) &feedback); + + break; + } + state = (XFeedbackState *) ((char *) state + state->length); + } + + if (gdk_error_trap_pop ()) + g_warning ("Error setting acceleration on \"%s\"", gdk_device_get_name (device)); + + XFreeFeedbackList (states); + + out: + + xdevice_close (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) +{ + GsdMouseManager *manager = GSD_MOUSE_MANAGER (user_data); + + g_debug ("syndaemon stopped with status %i", status); + g_spawn_close_pid (pid); + manager->priv->syndaemon_spawned = FALSE; +} + +static int +set_disable_w_typing (GsdMouseManager *manager, gboolean state) +{ + if (state && synaptics_is_present ()) { + GError *error = NULL; + GPtrArray *args; + + if (manager->priv->syndaemon_spawned) + return 0; + + if (!have_program_in_path ("syndaemon")) + return 0; + + args = g_ptr_array_new (); + + g_ptr_array_add (args, "syndaemon"); + g_ptr_array_add (args, "-i"); + g_ptr_array_add (args, "1.0"); + g_ptr_array_add (args, "-t"); + g_ptr_array_add (args, "-K"); + g_ptr_array_add (args, "-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, + &manager->priv->syndaemon_pid, &error); + + manager->priv->syndaemon_spawned = (error == NULL); + g_ptr_array_free (args, FALSE); + + if (error) { + g_warning ("Failed to launch syndaemon: %s", error->message); + g_error_free (error); + } else { + g_child_watch_add (manager->priv->syndaemon_pid, syndaemon_died, manager); + g_debug ("Launched syndaemon"); + } + } else if (manager->priv->syndaemon_spawned) { + kill (manager->priv->syndaemon_pid, SIGHUP); + g_spawn_close_pid (manager->priv->syndaemon_pid); + manager->priv->syndaemon_spawned = FALSE; + g_debug ("Killed syndaemon"); + } + + return 0; +} + +static void +set_tap_to_click (GdkDevice *device, + gboolean state, + gboolean left_handed) +{ + int format, rc; + unsigned long nitems, bytes_after; + XDevice *xdevice; + unsigned char* data; + Atom prop_capabilities, prop, type; + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + return; + + prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Tap Action", False); + prop_capabilities = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Capabilities", False); + if (!prop || !prop_capabilities) + return; + + xdevice = open_gdk_device (device); + if (xdevice == NULL) + return; + + if (!xdevice_is_synaptics (xdevice)) { + xdevice_close (xdevice); + return; + } + + g_debug ("setting tap to click on %s", gdk_device_get_name (device)); + + gdk_error_trap_push (); + rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, prop_capabilities, 0, 1, + False, XA_INTEGER, &type, &format, &nitems, &bytes_after, &data); + if (rc == Success && type == XA_INTEGER && format == 8 && nitems >= 1) { + if (!(data[0])) { + g_debug ("No hardware buttons, enabling tap to click on %s", gdk_device_get_name (device)); + state = TRUE; + } + + XFree (data); + } + + rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, prop, 0, 2, + False, XA_INTEGER, &type, &format, &nitems, + &bytes_after, &data); + + if (rc == Success && type == XA_INTEGER && format == 8 && nitems >= 7) { + /* Set RLM mapping for 1/2/3 fingers*/ + data[4] = (state) ? ((left_handed) ? 3 : 1) : 0; + data[5] = (state) ? ((left_handed) ? 1 : 3) : 0; + data[6] = (state) ? 2 : 0; + XChangeDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, prop, XA_INTEGER, 8, + PropModeReplace, data, nitems); + } + + if (rc == Success) + XFree (data); + + if (gdk_error_trap_pop ()) + g_warning ("Error in setting tap to click on \"%s\"", gdk_device_get_name (device)); + + xdevice_close (xdevice); +} + +static void +set_horiz_scroll (GdkDevice *device, + gboolean state) +{ + int rc; + XDevice *xdevice; + Atom act_type, prop_edge, prop_twofinger; + int act_format; + unsigned long nitems, bytes_after; + unsigned char *data; + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + return; + + prop_edge = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Edge Scrolling", False); + prop_twofinger = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Two-Finger Scrolling", False); + + if (!prop_edge || !prop_twofinger) + return; + + xdevice = open_gdk_device (device); + if (xdevice == NULL) + return; + + if (!xdevice_is_synaptics (xdevice)) { + xdevice_close (xdevice); + return; + } + + g_debug ("setting horiz scroll on %s", gdk_device_get_name (device)); + + gdk_error_trap_push (); + rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + prop_edge, 0, 1, False, + XA_INTEGER, &act_type, &act_format, &nitems, + &bytes_after, &data); + if (rc == Success && act_type == XA_INTEGER && + act_format == 8 && nitems >= 2) { + data[1] = (state && data[0]); + XChangeDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + prop_edge, XA_INTEGER, 8, + PropModeReplace, data, nitems); + } + + XFree (data); + + rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + prop_twofinger, 0, 1, False, + XA_INTEGER, &act_type, &act_format, &nitems, + &bytes_after, &data); + if (rc == Success && act_type == XA_INTEGER && + act_format == 8 && nitems >= 2) { + data[1] = (state && data[0]); + XChangeDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + prop_twofinger, XA_INTEGER, 8, + PropModeReplace, data, nitems); + } + + if (gdk_error_trap_pop ()) + g_warning ("Error in setting horiz scroll on \"%s\"", gdk_device_get_name (device)); + + if (rc == Success) + XFree (data); + + xdevice_close (xdevice); + +} + +static void +set_edge_scrolling_enabled (GsdMouseManager *manager, + GdkDevice *device, + gboolean enabled) +{ + int rc; + XDevice *xdevice; + Atom act_type, prop, prop_edge, prop_twofinger; + int act_format; + unsigned long nitems, bytes_after; + unsigned char *data; + GsdTouchpadScrollMethod method; + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + return; + + prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Capabilities", True); + prop_edge = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Edge Scrolling", False); + prop_twofinger = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Two-Finger Scrolling", False); + + if (!prop_edge || !prop_twofinger || !prop) + return; + + xdevice = open_gdk_device (device); + if (xdevice == NULL) + return; + + if (!xdevice_is_synaptics (xdevice)) { + xdevice_close (xdevice); + return; + } + + g_debug ("setting edge scroll on %s", gdk_device_get_name (device)); + + gdk_error_trap_push (); + rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + prop, 0, 2, False, + XA_INTEGER, &act_type, &act_format, &nitems, + &bytes_after, &data); + if (rc == Success && act_type != None) { + /* Two-finger scrolling is supported, so enable it */ + if (data[3]) + method = GSD_TOUCHPAD_SCROLL_METHOD_TWO_FINGER_SCROLLING; + + XFree (data); + } + + if (enabled && method != GSD_TOUCHPAD_SCROLL_METHOD_TWO_FINGER_SCROLLING) + method = GSD_TOUCHPAD_SCROLL_METHOD_EDGE_SCROLLING; + else + method = GSD_TOUCHPAD_SCROLL_METHOD_DISABLED; + + rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + prop_edge, 0, 1, False, + XA_INTEGER, &act_type, &act_format, &nitems, + &bytes_after, &data); + if (rc == Success && act_type == XA_INTEGER && + act_format == 8 && nitems >= 2) { + data[0] = (method == GSD_TOUCHPAD_SCROLL_METHOD_EDGE_SCROLLING) ? 1 : 0; + XChangeDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + prop_edge, XA_INTEGER, 8, + PropModeReplace, data, nitems); + } + + XFree (data); + + rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + prop_twofinger, 0, 1, False, + XA_INTEGER, &act_type, &act_format, &nitems, + &bytes_after, &data); + if (rc == Success && act_type == XA_INTEGER && + act_format == 8 && nitems >= 2) { + data[0] = (method == GSD_TOUCHPAD_SCROLL_METHOD_TWO_FINGER_SCROLLING) ? 1 : 0; + XChangeDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + prop_twofinger, XA_INTEGER, 8, + PropModeReplace, data, nitems); + } + + if (gdk_error_trap_pop ()) + g_warning ("Error in setting edge scroll on \"%s\"", gdk_device_get_name (device)); + + if (rc == Success) + XFree (data); + + xdevice_close (xdevice); +} + +static void +set_touchpad_disabled (GdkDevice *device) +{ + int id; + XDevice *xdevice; + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + return; + + g_object_get (G_OBJECT (device), "device-id", &id, NULL); + + g_debug ("Trying to set device disabled for \"%s\" (%d)", gdk_device_get_name (device), id); + + xdevice = open_gdk_device (device); + if (xdevice == NULL) + return; + + if (!xdevice_is_synaptics (xdevice)) { + xdevice_close (xdevice); + return; + } + + if (set_synaptics_device_enabled (id, FALSE) == FALSE) + g_warning ("Error disabling device \"%s\" (%d)", gdk_device_get_name (device), id); + else + g_debug ("Disabled device \"%s\" (%d)", gdk_device_get_name (device), id); + + xdevice_close (xdevice); +} + +static void +set_touchpad_enabled (int id) +{ + XDevice *xdevice; + + if (xdevice_is_libinput (id)) + return; + + g_debug ("Trying to set device enabled for %d", id); + + gdk_error_trap_push (); + xdevice = XOpenDevice (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), id); + if (gdk_error_trap_pop () != 0) + return; + + if (!xdevice_is_synaptics (xdevice)) { + xdevice_close (xdevice); + return; + } + + if (set_synaptics_device_enabled (id, TRUE) == FALSE) + g_warning ("Error enabling device \"%d\"", id); + else + g_debug ("Enabled device %d", id); + + xdevice_close (xdevice); +} + static void set_locate_pointer (GsdMouseManager *manager, gboolean state) @@ -143,32 +962,418 @@ set_mousetweaks_daemon (GsdMouseManager *manager, g_free (comm); } +static gboolean +get_touchpad_handedness (GsdMouseManager *manager, gboolean mouse_left_handed) +{ + switch (g_settings_get_enum (manager->priv->touchpad_settings, KEY_LEFT_HANDED)) { + case GSD_TOUCHPAD_HANDEDNESS_RIGHT: + return FALSE; + case GSD_TOUCHPAD_HANDEDNESS_LEFT: + return TRUE; + case GSD_TOUCHPAD_HANDEDNESS_MOUSE: + return mouse_left_handed; + default: + g_assert_not_reached (); + } +} + +static void +set_natural_scroll (GsdMouseManager *manager, + GdkDevice *device, + gboolean natural_scroll) +{ + XDevice *xdevice; + Atom scrolling_distance, act_type; + int rc, act_format; + unsigned long nitems, bytes_after; + unsigned char *data; + glong *ptr; + + xdevice = open_gdk_device (device); + if (xdevice == NULL) + return; + + if (!xdevice_is_synaptics (xdevice)) { + xdevice_close (xdevice); + return; + } + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + return; + + g_debug ("Trying to set %s for \"%s\"", + natural_scroll ? "natural (reverse) scroll" : "normal scroll", + gdk_device_get_name (device)); + + scrolling_distance = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), + "Synaptics Scrolling Distance", False); + + gdk_error_trap_push (); + rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + scrolling_distance, 0, 2, False, + XA_INTEGER, &act_type, &act_format, &nitems, + &bytes_after, &data); + + if (rc == Success && act_type == XA_INTEGER && act_format == 32 && nitems >= 2) { + ptr = (glong *) data; + + if (natural_scroll) { + ptr[0] = -abs(ptr[0]); + ptr[1] = -abs(ptr[1]); + } else { + ptr[0] = abs(ptr[0]); + ptr[1] = abs(ptr[1]); + } + + XChangeDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, + scrolling_distance, XA_INTEGER, act_format, + PropModeReplace, data, nitems); + } + + if (gdk_error_trap_pop ()) + g_warning ("Error setting %s for \"%s\"", + natural_scroll ? "natural (reverse) scroll" : "normal scroll", + gdk_device_get_name (device)); + + if (rc == Success) + XFree (data); + + xdevice_close (xdevice); +} + +static void +set_scroll_wheel_button (GsdMouseManager *manager, + GdkDevice *device) +{ + Atom wheel_prop, button_prop; + XDevice *xdevice; + Atom type; + int format; + unsigned long nitems, bytes_after; + unsigned char *data = NULL; + int button; + int rc; + + if (!device_is_trackball (device)) + return; + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + return; + + xdevice = open_gdk_device (device); + if (xdevice == NULL) + return; + + wheel_prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), + "Evdev Wheel Emulation", True); + button_prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), + "Evdev Wheel Emulation Button", True); + + if (!wheel_prop || !button_prop) { + xdevice_close (xdevice); + return; + } + + g_debug ("setting scroll wheel emulation on %s", gdk_device_get_name (device)); + + gdk_error_trap_push (); + + button = g_settings_get_int (manager->priv->trackball_settings, KEY_SCROLL_WHEEL_BUTTON); + + /* Whether scroll wheel emulation is enabled */ + rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), + xdevice, wheel_prop, 0, 1, False, XA_INTEGER, &type, &format, + &nitems, &bytes_after, &data); + + if (rc == Success && format == 8 && type == XA_INTEGER && nitems == 1) { + data[0] = button > 0 ? 1 : 0; + + XChangeDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), + xdevice, wheel_prop, type, format, PropModeReplace, data, nitems); + } + + if (data) { + XFree (data); + data = NULL; + } + + /* Which button is used for the emulation */ + if (button > 0) { + rc = XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), + xdevice, button_prop, 0, 1, False, XA_INTEGER, &type, &format, + &nitems, &bytes_after, &data); + + if (rc == Success && format == 8 && type == XA_INTEGER && nitems == 1) { + data[0] = button; + + XChangeDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), + xdevice, button_prop, type, format, PropModeReplace, data, nitems); + } + + if (data) + XFree (data); + } + + if (gdk_error_trap_pop ()) + g_warning ("Error in setting scroll wheel emulation on \"%s\"", gdk_device_get_name (device)); + + xdevice_close (xdevice); +} + +static gboolean +get_touchpad_enabled (GsdMouseManager *manager) +{ + GDesktopDeviceSendEvents send_events; + + send_events = g_settings_get_enum (manager->priv->touchpad_settings, KEY_SEND_EVENTS); + + if (send_events == G_DESKTOP_DEVICE_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE) { + /* FIXME: mouse_is_present() also finds internal ones... */ + return (!mouse_is_present () && !trackball_is_present ()); + + } + + return send_events == G_DESKTOP_DEVICE_SEND_EVENTS_ENABLED ? TRUE : FALSE; +} + +static void +set_mouse_settings (GsdMouseManager *manager, + GdkDevice *device) +{ + gboolean mouse_left_handed, touchpad_left_handed; + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + return; + + mouse_left_handed = g_settings_get_boolean (manager->priv->mouse_settings, KEY_LEFT_HANDED); + touchpad_left_handed = get_touchpad_handedness (manager, mouse_left_handed); + set_left_handed (manager, device, mouse_left_handed, touchpad_left_handed); + + set_motion (manager, device); + + set_tap_to_click (device, g_settings_get_boolean (manager->priv->touchpad_settings, KEY_TAP_TO_CLICK), touchpad_left_handed); + set_edge_scrolling_enabled (manager, device, g_settings_get_boolean (manager->priv->touchpad_settings, KEY_EDGE_SCROLLING_ENABLED)); + set_horiz_scroll (device, TRUE); + set_natural_scroll (manager, device, g_settings_get_boolean (manager->priv->touchpad_settings, KEY_NATURAL_SCROLL_ENABLED)); + + set_scroll_wheel_button (manager, device); +} + static void mouse_callback (GSettings *settings, const gchar *key, GsdMouseManager *manager) { + GList *devices, *l; + if (g_str_equal (key, KEY_DWELL_CLICK_ENABLED) || g_str_equal (key, KEY_SECONDARY_CLICK_ENABLED)) { set_mousetweaks_daemon (manager, g_settings_get_boolean (settings, KEY_DWELL_CLICK_ENABLED), g_settings_get_boolean (settings, KEY_SECONDARY_CLICK_ENABLED)); + return; } else if (g_str_equal (key, KEY_LOCATE_POINTER)) { set_locate_pointer (manager, g_settings_get_boolean (settings, KEY_LOCATE_POINTER)); + return; } + + devices = gdk_device_manager_list_devices (manager->priv->device_manager, GDK_DEVICE_TYPE_SLAVE); + + for (l = devices; l != NULL; l = l->next) { + GdkDevice *device = l->data; + + if (device_is_ignored (manager, device)) + continue; + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + continue; + + if (g_str_equal (key, KEY_LEFT_HANDED)) { + gboolean mouse_left_handed; + mouse_left_handed = g_settings_get_boolean (settings, KEY_LEFT_HANDED); + set_left_handed (manager, device, mouse_left_handed, get_touchpad_handedness (manager, mouse_left_handed)); + } else if (g_str_equal (key, KEY_SPEED)) { + set_motion (manager, device); + } + } + g_list_free (devices); +} + +static void +touchpad_callback (GSettings *settings, + const gchar *key, + GsdMouseManager *manager) +{ + GList *devices, *l; + + devices = gdk_device_manager_list_devices (manager->priv->device_manager, GDK_DEVICE_TYPE_SLAVE); + + for (l = devices; l != NULL; l = l->next) { + GdkDevice *device = l->data; + + if (device_is_ignored (manager, device)) + continue; + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + continue; + + if (g_str_equal (key, KEY_TAP_TO_CLICK)) { + gboolean mouse_left_handed; + mouse_left_handed = g_settings_get_boolean (manager->priv->mouse_settings, KEY_LEFT_HANDED); + set_tap_to_click (device, g_settings_get_boolean (settings, key), + get_touchpad_handedness (manager, mouse_left_handed)); + } else if (g_str_equal (key, KEY_EDGE_SCROLLING_ENABLED)) { + set_edge_scrolling_enabled (manager, device, g_settings_get_boolean (settings, key)); + set_horiz_scroll (device, TRUE); + } else if (g_str_equal (key, KEY_SPEED)) { + set_motion (manager, device); + } else if (g_str_equal (key, KEY_LEFT_HANDED)) { + gboolean mouse_left_handed; + mouse_left_handed = g_settings_get_boolean (manager->priv->mouse_settings, KEY_LEFT_HANDED); + set_left_handed (manager, device, mouse_left_handed, get_touchpad_handedness (manager, mouse_left_handed)); + } else if (g_str_equal (key, KEY_NATURAL_SCROLL_ENABLED)) { + set_natural_scroll (manager, device, g_settings_get_boolean (settings, key)); + } + } + g_list_free (devices); + + if (g_str_equal (key, KEY_SEND_EVENTS)) { + ensure_touchpad_active (manager); + } +} + +static void +trackball_callback (GSettings *settings, + const gchar *key, + GsdMouseManager *manager) +{ + GList *devices, *l; + + devices = gdk_device_manager_list_devices (manager->priv->device_manager, GDK_DEVICE_TYPE_SLAVE); + + for (l = devices; l != NULL; l = l->next) { + GdkDevice *device = l->data; + + if (device_is_ignored (manager, device)) + continue; + + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + return; + + set_scroll_wheel_button (manager, device); + } + g_list_free (devices); +} + +/* Re-enable touchpad when any other pointing device isn't present. */ +static void +ensure_touchpad_active (GsdMouseManager *manager) +{ + GList *devices, *l; + gboolean state; + + state = get_touchpad_enabled (manager); + if (state) { + devices = get_disabled_synaptics (); + for (l = devices; l != NULL; l = l->next) { + int device_id; + + device_id = GPOINTER_TO_INT (l->data); + set_touchpad_enabled (device_id); + } + g_list_free (devices); + } else { + devices = gdk_device_manager_list_devices (manager->priv->device_manager, + GDK_DEVICE_TYPE_SLAVE); + + for (l = devices; l != NULL; l = l->next) { + GdkDevice *device = l->data; + + if (device_is_ignored (manager, device)) + continue; + if (xdevice_is_libinput (gdk_x11_device_get_id (device))) + continue; + if (gdk_device_get_source (device) != GDK_SOURCE_TOUCHPAD) + continue; + + set_touchpad_disabled (device); + } + + g_list_free (devices); + } + + set_disable_w_typing (manager, state); +} + +static void +device_added_cb (GdkDeviceManager *device_manager, + GdkDevice *device, + GsdMouseManager *manager) +{ + if (device_is_ignored (manager, device) == FALSE) { + if (run_custom_command (device, COMMAND_DEVICE_ADDED) == FALSE) { + set_mouse_settings (manager, device); + } else { + int id; + g_object_get (G_OBJECT (device), "device-id", &id, NULL); + g_hash_table_insert (manager->priv->blacklist, + GINT_TO_POINTER (id), GINT_TO_POINTER (1)); + } + + ensure_touchpad_active (manager); + } +} + +static void +device_removed_cb (GdkDeviceManager *device_manager, + GdkDevice *device, + GsdMouseManager *manager) +{ + int id; + + /* Remove the device from the hash table so that + * device_is_ignored () doesn't check for blacklisted devices */ + g_object_get (G_OBJECT (device), "device-id", &id, NULL); + g_hash_table_remove (manager->priv->blacklist, + GINT_TO_POINTER (id)); + + if (device_is_ignored (manager, device) == FALSE) { + run_custom_command (device, COMMAND_DEVICE_REMOVED); + + ensure_touchpad_active (manager); + } +} + +static void +set_devicepresence_handler (GsdMouseManager *manager) +{ + GdkDeviceManager *device_manager; + + device_manager = gdk_display_get_device_manager (gdk_display_get_default ()); + + manager->priv->device_added_id = g_signal_connect (G_OBJECT (device_manager), "device-added", + G_CALLBACK (device_added_cb), manager); + manager->priv->device_removed_id = g_signal_connect (G_OBJECT (device_manager), "device-removed", + G_CALLBACK (device_removed_cb), manager); + manager->priv->device_manager = device_manager; } static void gsd_mouse_manager_init (GsdMouseManager *manager) { manager->priv = GSD_MOUSE_MANAGER_GET_PRIVATE (manager); + manager->priv->blacklist = g_hash_table_new (g_direct_hash, g_direct_equal); } static gboolean gsd_mouse_manager_idle_cb (GsdMouseManager *manager) { + GList *devices, *l; + gnome_settings_profile_start (NULL); + set_devicepresence_handler (manager); + manager->priv->gsd_mouse_settings = g_settings_new (GSD_SETTINGS_MOUSE_SCHEMA); g_signal_connect (manager->priv->gsd_mouse_settings, "changed", G_CALLBACK (mouse_callback), manager); @@ -176,17 +1381,46 @@ gsd_mouse_manager_idle_cb (GsdMouseManager *manager) manager->priv->mouse_a11y_settings = g_settings_new ("org.gnome.desktop.a11y.mouse"); g_signal_connect (manager->priv->mouse_a11y_settings, "changed", G_CALLBACK (mouse_callback), manager); -#if 0 + manager->priv->mouse_settings = g_settings_new (GSETTINGS_MOUSE_SCHEMA); g_signal_connect (manager->priv->mouse_settings, "changed", G_CALLBACK (mouse_callback), manager); -#endif + + manager->priv->touchpad_settings = g_settings_new (GSETTINGS_TOUCHPAD_SCHEMA); + g_signal_connect (manager->priv->touchpad_settings, "changed", + G_CALLBACK (touchpad_callback), manager); + + manager->priv->trackball_settings = g_settings_new (GSETTINGS_TRACKBALL_SCHEMA); + g_signal_connect (manager->priv->trackball_settings, "changed", + G_CALLBACK (trackball_callback), manager); + + manager->priv->syndaemon_spawned = FALSE; set_locate_pointer (manager, g_settings_get_boolean (manager->priv->gsd_mouse_settings, KEY_LOCATE_POINTER)); set_mousetweaks_daemon (manager, g_settings_get_boolean (manager->priv->mouse_a11y_settings, KEY_DWELL_CLICK_ENABLED), g_settings_get_boolean (manager->priv->mouse_a11y_settings, KEY_SECONDARY_CLICK_ENABLED)); + devices = gdk_device_manager_list_devices (manager->priv->device_manager, GDK_DEVICE_TYPE_SLAVE); + for (l = devices; l != NULL; l = l->next) { + GdkDevice *device = l->data; + + if (device_is_ignored (manager, device)) + continue; + + if (run_custom_command (device, COMMAND_DEVICE_PRESENT) == FALSE) { + set_mouse_settings (manager, device); + } else { + int id; + g_object_get (G_OBJECT (device), "device-id", &id, NULL); + g_hash_table_insert (manager->priv->blacklist, + GINT_TO_POINTER (id), GINT_TO_POINTER (1)); + } + } + g_list_free (devices); + + ensure_touchpad_active (manager); + gnome_settings_profile_end (NULL); manager->priv->start_idle_id = 0; @@ -202,6 +1436,11 @@ gsd_mouse_manager_start (GsdMouseManager *manager, migrate_mouse_settings (); + if (!supports_xinput_devices ()) { + g_debug ("XInput is not supported, not applying any settings"); + return TRUE; + } + if (gnome_settings_is_wayland ()) return TRUE; @@ -225,9 +1464,16 @@ gsd_mouse_manager_stop (GsdMouseManager *manager) manager->priv->start_idle_id = 0; } + if (p->device_manager != NULL) { + g_signal_handler_disconnect (p->device_manager, p->device_added_id); + g_signal_handler_disconnect (p->device_manager, p->device_removed_id); + p->device_manager = NULL; + } + g_clear_object (&p->mouse_a11y_settings); g_clear_object (&p->mouse_settings); g_clear_object (&p->touchpad_settings); + g_clear_object (&p->trackball_settings); g_clear_object (&p->gsd_mouse_settings); set_locate_pointer (manager, FALSE); @@ -247,6 +1493,9 @@ gsd_mouse_manager_finalize (GObject *object) gsd_mouse_manager_stop (mouse_manager); + if (mouse_manager->priv->blacklist != NULL) + g_hash_table_destroy (mouse_manager->priv->blacklist); + G_OBJECT_CLASS (gsd_mouse_manager_parent_class)->finalize (object); } -- 2.6.2 From 4b1ed6c7aec9dea2b70fe19c0156fed72899eba6 Mon Sep 17 00:00:00 2001 From: Frederic Crozat <fcrozat@suse.com> Date: Fri, 4 Mar 2016 15:49:20 +0100 Subject: [PATCH 2/3] Revert "common: Remove unused functions" This reverts commit 9287ef9ac5b119abdcbbabd920c19f353e577f90. --- plugins/common/gsd-input-helper.c | 279 +++++++++++++++++++++++++++++++++++++ plugins/common/gsd-input-helper.h | 15 ++ plugins/common/test-input-helper.c | 5 +- 3 files changed, 298 insertions(+), 1 deletion(-) diff --git a/plugins/common/gsd-input-helper.c b/plugins/common/gsd-input-helper.c index 077ff1c..4dca795 100644 --- a/plugins/common/gsd-input-helper.c +++ b/plugins/common/gsd-input-helper.c @@ -115,6 +115,12 @@ supports_xinput_devices_with_opcode (int *opcode) } gboolean +supports_xinput_devices (void) +{ + return supports_xinput_devices_with_opcode (NULL); +} + +gboolean supports_xtest (void) { gint op_code, event, error; @@ -154,6 +160,66 @@ supports_xinput2_devices (int *opcode) return TRUE; } +gboolean +xdevice_is_synaptics (XDevice *xdevice) +{ + Atom realtype, prop; + int realformat; + unsigned long nitems, bytes_after; + unsigned char *data; + + /* we don't check on the type being XI_TOUCHPAD here, + * but having a "Synaptics Off" property should be enough */ + + prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Off", False); + if (!prop) + return FALSE; + + gdk_error_trap_push (); + if ((XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xdevice, prop, 0, 1, False, + XA_INTEGER, &realtype, &realformat, &nitems, + &bytes_after, &data) == Success) && (realtype != None)) { + gdk_error_trap_pop_ignored (); + XFree (data); + return TRUE; + } + gdk_error_trap_pop_ignored (); + + return FALSE; +} + +gboolean +synaptics_is_present (void) +{ + XDeviceInfo *device_info; + gint n_devices; + guint i; + gboolean retval; + + retval = FALSE; + + device_info = XListInputDevices (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), &n_devices); + if (device_info == NULL) + return FALSE; + + for (i = 0; i < n_devices; i++) { + XDevice *device; + + gdk_error_trap_push (); + device = XOpenDevice (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), device_info[i].id); + if (gdk_error_trap_pop () || (device == NULL)) + continue; + + retval = xdevice_is_synaptics (device); + xdevice_close (device); + if (retval) + break; + } + XFreeDeviceList (device_info); + + return retval; +} + static gboolean device_type_is_present (GsdDeviceType type) { @@ -181,6 +247,29 @@ mouse_is_present (void) return device_type_is_present (GSD_DEVICE_TYPE_MOUSE); } +gboolean +trackball_is_present (void) +{ + gboolean retval = FALSE; + GList *l, *mice = gsd_device_manager_list_devices (gsd_device_manager_get (), + GSD_DEVICE_TYPE_MOUSE); + if (mice == NULL) + return FALSE; + + for (l = mice; l != NULL; l = l->next) { + gchar *lowercase; + const gchar *name = gsd_device_get_name (l->data); + if (!name) + continue; + lowercase = g_ascii_strdown (name, -1); + retval = strstr (lowercase, "trackball") != NULL; + g_free (lowercase); + } + + g_list_free (mice); + return retval; +} + char * xdevice_get_device_node (int deviceid) { @@ -339,6 +428,172 @@ set_device_enabled (int device_id, return TRUE; } +gboolean +set_synaptics_device_enabled (int device_id, + gboolean enabled) +{ + Atom prop; + guchar value; + + prop = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Off", False); + if (!prop) + return FALSE; + + gdk_error_trap_push (); + + value = enabled ? 0 : 1; + XIChangeProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), + device_id, prop, XA_INTEGER, 8, PropModeReplace, &value, 1); + + if (gdk_error_trap_pop ()) + return FALSE; + + return TRUE; +} + +static const char * +custom_command_to_string (CustomCommand command) +{ + switch (command) { + case COMMAND_DEVICE_ADDED: + return "added"; + case COMMAND_DEVICE_REMOVED: + return "removed"; + case COMMAND_DEVICE_PRESENT: + return "present"; + default: + g_assert_not_reached (); + } +} + +/* Run a custom command on device presence events. Parameters passed into + * the custom command are: + * command -t [added|removed|present] -i <device ID> <device name> + * Type 'added' and 'removed' signal 'device added' and 'device removed', + * respectively. Type 'present' signals 'device present at + * gnome-settings-daemon init'. + * + * The script is expected to run synchronously, and an exit value + * of "1" means that no other settings will be applied to this + * particular device. + * + * More options may be added in the future. + * + * This function returns TRUE if we should not apply any more settings + * to the device. + */ +gboolean +run_custom_command (GdkDevice *device, + CustomCommand command) +{ + GSettings *settings; + GError *error = NULL; + char *cmd; + char *argv[7]; + int exit_status; + gboolean rc; + int id; + char *out; + + settings = g_settings_new (INPUT_DEVICES_SCHEMA); + cmd = g_settings_get_string (settings, KEY_HOTPLUG_COMMAND); + g_object_unref (settings); + + if (!cmd || cmd[0] == '\0') { + g_free (cmd); + return FALSE; + } + + /* Easter egg! */ + g_object_get (device, "device-id", &id, NULL); + + argv[0] = cmd; + argv[1] = "-t"; + argv[2] = (char *) custom_command_to_string (command); + argv[3] = "-i"; + argv[4] = g_strdup_printf ("%d", id); + argv[5] = (char*) gdk_device_get_name (device); + argv[6] = NULL; + + out = g_strjoinv (" ", argv); + g_debug ("About to launch command: %s", out); + g_free (out); + + rc = g_spawn_sync (g_get_home_dir (), argv, NULL, G_SPAWN_SEARCH_PATH, + NULL, NULL, NULL, NULL, &exit_status, &error); + + if (rc == FALSE) { + g_warning ("Couldn't execute command '%s', verify that this is a valid command: %s", cmd, error->message); + g_clear_error (&error); + } + + g_free (argv[0]); + g_free (argv[4]); + + if (!g_spawn_check_exit_status (exit_status, &error)) { + if (g_error_matches (error, G_SPAWN_EXIT_ERROR, 1)) { + g_clear_error (&error); + return TRUE; + } + g_clear_error (&error); + } + + return FALSE; +} + +GList * +get_disabled_synaptics (void) +{ + GdkDisplay *display; + XDeviceInfo *device_info; + gint n_devices, act_format, rc; + guint i; + GList *ret; + Atom prop, act_type; + unsigned long nitems, bytes_after; + unsigned char *data; + + ret = NULL; + + display = gdk_display_get_default (); + prop = gdk_x11_get_xatom_by_name ("Synaptics Off"); + + gdk_error_trap_push (); + + device_info = XListInputDevices (GDK_DISPLAY_XDISPLAY (display), &n_devices); + if (device_info == NULL) { + gdk_error_trap_pop_ignored (); + + return ret; + } + + for (i = 0; i < n_devices; i++) { + rc = XIGetProperty (GDK_DISPLAY_XDISPLAY (display), + device_info[i].id, prop, 0, 1, False, + XA_INTEGER, &act_type, &act_format, + &nitems, &bytes_after, &data); + + if (rc != Success || act_type != XA_INTEGER || + act_format != 8 || nitems < 1) + continue; + + if (!(data[0])) { + XFree (data); + continue; + } + + XFree (data); + + ret = g_list_prepend (ret, GINT_TO_POINTER (device_info[i].id)); + } + + gdk_error_trap_pop_ignored (); + + XFreeDeviceList (device_info); + + return ret; +} + const char * xdevice_get_wacom_tool_type (int deviceid) { @@ -425,3 +680,27 @@ xdevice_get_dimensions (int deviceid, return (w != 0 && h != 0); } + +gboolean +xdevice_is_libinput (gint deviceid) +{ + GdkDisplay *display = gdk_display_get_default (); + gulong nitems, bytes_after; + gint rc, format; + guchar *data; + Atom type; + + gdk_error_trap_push (); + + /* Lookup a libinput driver specific property */ + rc = XIGetProperty (GDK_DISPLAY_XDISPLAY (display), deviceid, + gdk_x11_get_xatom_by_name ("libinput Send Events Mode Enabled"), + 0, 1, False, XA_INTEGER, &type, &format, &nitems, &bytes_after, &data); + + if (rc == Success) + XFree (data); + + gdk_error_trap_pop_ignored (); + + return rc == Success && nitems > 0; +} diff --git a/plugins/common/gsd-input-helper.h b/plugins/common/gsd-input-helper.h index 31e2e47..85e6d07 100644 --- a/plugins/common/gsd-input-helper.h +++ b/plugins/common/gsd-input-helper.h @@ -44,20 +44,32 @@ typedef struct { } data; } PropertyHelper; +gboolean supports_xinput_devices (void); gboolean supports_xinput2_devices (int *opcode); gboolean supports_xtest (void); gboolean set_device_enabled (int device_id, gboolean enabled); +gboolean set_synaptics_device_enabled (int device_id, + gboolean enabled); + +gboolean xdevice_is_synaptics (XDevice *xdevice); + +gboolean synaptics_is_present (void); gboolean touchpad_is_present (void); gboolean touchscreen_is_present (void); gboolean mouse_is_present (void); +gboolean trackball_is_present (void); gboolean device_set_property (XDevice *xdevice, const char *device_name, PropertyHelper *property); +gboolean run_custom_command (GdkDevice *device, + CustomCommand command); + +GList * get_disabled_synaptics (void); char * xdevice_get_device_node (int deviceid); int xdevice_get_last_tool_id (int deviceid); gboolean xdevice_get_dimensions (int deviceid, @@ -67,6 +79,9 @@ void xdevice_close (XDevice *xdevice); const char * xdevice_get_wacom_tool_type (int deviceid); +gboolean xdevice_is_libinput (gint deviceid); + + G_END_DECLS #endif /* __GSD_INPUT_HELPER_H */ diff --git a/plugins/common/test-input-helper.c b/plugins/common/test-input-helper.c index 954ac30..e78f463 100644 --- a/plugins/common/test-input-helper.c +++ b/plugins/common/test-input-helper.c @@ -32,7 +32,7 @@ int main (int argc, char **argv) { GList *devices, *l; - gboolean has_touchpad, has_touchscreen; + gboolean has_touchpad, has_touchscreen, has_trackball; gtk_init (&argc, &argv); @@ -42,6 +42,9 @@ int main (int argc, char **argv) has_touchscreen = touchscreen_is_present (); g_print ("Has touchscreen:\t\t\t%s\n", has_touchscreen ? "yes" : "no"); + has_trackball = trackball_is_present (); + g_print ("Has trackball:\t\t\t\t%s\n", has_trackball ? "yes" : "no"); + devices = gsd_device_manager_list_devices (gsd_device_manager_get (), GSD_DEVICE_TYPE_MOUSE); for (l = devices; l != NULL; l = l->next) g_print ("Device '%s' is a mouse\n", gsd_device_get_name (l->data)); -- 2.6.2 From 2e27aeec3c5bcb9fe398bd3835226f261b60baf1 Mon Sep 17 00:00:00 2001 From: Frederic Crozat <fcrozat@suse.com> Date: Fri, 4 Mar 2016 15:51:23 +0100 Subject: [PATCH 3/3] Revert "common: Remove "hotplug-command" helper" This reverts commit c50ceb880e928506d987747f9e554079ad3d9826. --- ...e.settings-daemon.peripherals.gschema.xml.in.in | 8 +++ plugins/common/Makefile.am | 3 + plugins/common/gsd-input-helper.c | 3 + plugins/common/gsd-input-helper.h | 6 ++ plugins/common/input-device-example.sh | 69 ++++++++++++++++++++++ plugins/keyboard/gsd-keyboard-manager.c | 18 ++++++ 6 files changed, 107 insertions(+) create mode 100644 plugins/common/input-device-example.sh diff --git a/data/org.gnome.settings-daemon.peripherals.gschema.xml.in.in b/data/org.gnome.settings-daemon.peripherals.gschema.xml.in.in index f4120e9..6a65f08 100644 --- a/data/org.gnome.settings-daemon.peripherals.gschema.xml.in.in +++ b/data/org.gnome.settings-daemon.peripherals.gschema.xml.in.in @@ -4,6 +4,7 @@ <child name="keyboard" schema="org.gnome.settings-daemon.peripherals.keyboard"/> <child name="mouse" schema="org.gnome.settings-daemon.peripherals.mouse"/> <child name="touchscreen" schema="org.gnome.settings-daemon.peripherals.touchscreen"/> + <child name="input-devices" schema="org.gnome.settings-daemon.peripherals.input-devices"/> </schema> <schema gettext-domain="@GETTEXT_PACKAGE@" id="org.gnome.settings-daemon.peripherals.smartcard" path="/org/gnome/settings-daemon/peripherals/smartcard/"> <key name="removal-action" enum="org.gnome.settings-daemon.GsdSmartcardRemovalAction"> @@ -67,6 +68,13 @@ <_summary>Whether the tablet's orientation is locked, or rotated automatically.</_summary> </key> </schema> + <schema gettext-domain="@GETTEXT_PACKAGE@" id="org.gnome.settings-daemon.peripherals.input-devices" path="/org/gnome/settings-daemon/peripherals/input-devices/"> + <key name="hotplug-command" type="s"> + <default>''</default> + <_summary>Device hotplug custom command</_summary> + <_description>Command to be run when a device is added or removed. An exit value of 1 means that the device will not be handled further by gnome-settings-daemon.</_description> + </key> + </schema> <!-- Deprecated schemas/keys --> <schema id="org.gnome.settings-daemon.peripherals.mouse.deprecated"> diff --git a/plugins/common/Makefile.am b/plugins/common/Makefile.am index 0331226..0f85351 100644 --- a/plugins/common/Makefile.am +++ b/plugins/common/Makefile.am @@ -82,6 +82,9 @@ test_egg_key_parsing_SOURCES = test-egg-key-parsing.c test_egg_key_parsing_LDADD = libcommon.la $(COMMON_LIBS) test_egg_key_parsing_CFLAGS = $(libcommon_la_CFLAGS) +scriptsdir = $(datadir)/gnome-settings-daemon-@GSD_API_VERSION@ +scripts_DATA = input-device-example.sh + EXTRA_DIST = $(scripts_DATA) test-plugin.h CLEANFILES = \ diff --git a/plugins/common/gsd-input-helper.c b/plugins/common/gsd-input-helper.c index 4dca795..e3fe2d8 100644 --- a/plugins/common/gsd-input-helper.c +++ b/plugins/common/gsd-input-helper.c @@ -31,6 +31,9 @@ #include "gsd-input-helper.h" #include "gsd-device-manager.h" +#define INPUT_DEVICES_SCHEMA "org.gnome.settings-daemon.peripherals.input-devices" +#define KEY_HOTPLUG_COMMAND "hotplug-command" + #define ABS_MT_X "Abs MT Position X" #define ABS_MT_Y "Abs MT Position Y" #define ABS_X "Abs X" diff --git a/plugins/common/gsd-input-helper.h b/plugins/common/gsd-input-helper.h index 85e6d07..aadd790 100644 --- a/plugins/common/gsd-input-helper.h +++ b/plugins/common/gsd-input-helper.h @@ -28,6 +28,12 @@ G_BEGIN_DECLS #define WACOM_SERIAL_IDS_PROP "Wacom Serial IDs" +typedef enum { + COMMAND_DEVICE_ADDED, + COMMAND_DEVICE_REMOVED, + COMMAND_DEVICE_PRESENT +} CustomCommand; + /* Generic property setting code. Fill up the struct property with the property * data and pass it into device_set_property together with the device to be * changed. Note: doesn't cater for non-zero offsets yet, but we don't have diff --git a/plugins/common/input-device-example.sh b/plugins/common/input-device-example.sh new file mode 100644 index 0000000..235cdc4 --- /dev/null +++ b/plugins/common/input-device-example.sh @@ -0,0 +1,69 @@ +#!/bin/sh +# +# This script is an example hotplug script for use with the various +# input devices plugins. +# +# The script is called with the arguments: +# -t [added|present|removed] <device name> +# added ... device was just plugged in +# present.. device was present at gnome-settings-daemon startup +# removed.. device was just removed +# -i <device ID> +# device ID being the XInput device ID +# <device name> The name of the device +# +# The script should return 1 if the device is to be +# ignored from future configuration. +# +# Set the script to be used with: +# gsettings set org.gnome.settings-daemon.peripherals.input-devices hotplug-command /path/to/script/input-devices.sh +# + +args=`getopt "t:i:" $*` + +set -- $args + +while [ $# -gt 0 ] +do + case $1 in + -t) + shift; + type="$1" + ;; + -i) + shift; + id="$1" + ;; + --) + shift; + device="$@" + break; + ;; + *) + echo "Unknown option $1"; + exit 1 + ;; + esac + shift +done + +retval=0 + +case $type in + added) + echo "Device '$device' (ID=$id) was added" + ;; + present) + echo "Device '$device' (ID=$id) was already present at startup" + ;; + removed) + echo "Device '$device' (ID=$id) was removed" + ;; + *) + echo "Unknown operation" + retval=1 + ;; +esac + +# All further processing will be disabled if $retval == 1 +exit $retval diff --git a/plugins/keyboard/gsd-keyboard-manager.c b/plugins/keyboard/gsd-keyboard-manager.c index ddeeee6..eb75c92 100644 --- a/plugins/keyboard/gsd-keyboard-manager.c +++ b/plugins/keyboard/gsd-keyboard-manager.c @@ -90,6 +90,7 @@ struct GsdKeyboardManagerPrivate GsdNumLockState old_state; GdkDeviceManager *device_manager; guint device_added_id; + guint device_removed_id; }; static void gsd_keyboard_manager_class_init (GsdKeyboardManagerClass *klass); @@ -363,6 +364,20 @@ device_added_cb (GdkDeviceManager *device_manager, if (source == GDK_SOURCE_KEYBOARD) { g_debug ("New keyboard plugged in, applying all settings"); apply_numlock (manager); + run_custom_command (device, COMMAND_DEVICE_ADDED); + } +} + +static void +device_removed_cb (GdkDeviceManager *device_manager, + GdkDevice *device, + GsdKeyboardManager *manager) +{ + GdkInputSource source; + + source = gdk_device_get_source (device); + if (source == GDK_SOURCE_KEYBOARD) { + run_custom_command (device, COMMAND_DEVICE_REMOVED); } } @@ -378,6 +393,8 @@ set_devicepresence_handler (GsdKeyboardManager *manager) manager->priv->device_added_id = g_signal_connect (G_OBJECT (device_manager), "device-added", G_CALLBACK (device_added_cb), manager); + manager->priv->device_removed_id = g_signal_connect (G_OBJECT (device_manager), "device-removed", + G_CALLBACK (device_removed_cb), manager); manager->priv->device_manager = device_manager; } @@ -758,6 +775,7 @@ gsd_keyboard_manager_stop (GsdKeyboardManager *manager) if (p->device_manager != NULL) { g_signal_handler_disconnect (p->device_manager, p->device_added_id); + g_signal_handler_disconnect (p->device_manager, p->device_removed_id); p->device_manager = NULL; } -- 2.6.2
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
