diff options
Diffstat (limited to 'src/xf86libinput.c')
| -rw-r--r-- | src/xf86libinput.c | 5947 |
1 files changed, 5947 insertions, 0 deletions
diff --git a/src/xf86libinput.c b/src/xf86libinput.c new file mode 100644 index 0000000..b9cd086 --- /dev/null +++ b/src/xf86libinput.c @@ -0,0 +1,5947 @@ +/* + * SPDX-License-Identifier: MIT + * + * Copyright © 2013-2017 Red Hat, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <errno.h> +#include <fcntl.h> +#include <time.h> +#include <unistd.h> +#include <xorg-server.h> +#include <list.h> +#include <exevents.h> +#include <xkbsrv.h> +#include <xf86.h> +#include <xf86Xinput.h> +#include <xf86_OSproc.h> +#include <xserver-properties.h> +#include <libinput.h> +#include <linux/input.h> + +#include <X11/Xatom.h> + +#include "bezier.h" +#include "draglock.h" +#include "libinput-properties.h" + +#define TOUCHPAD_NUM_AXES 4 /* x, y, hscroll, vscroll */ +#define TABLET_NUM_BUTTONS 7 /* we need scroll buttons */ +#define TOUCH_MAX_SLOTS 15 +#define XORG_KEYCODE_OFFSET 8 +#define SCROLL_INCREMENT 15 +#define TOUCHPAD_SCROLL_DIST_MIN 10 /* in libinput pixels */ +#define TOUCHPAD_SCROLL_DIST_MAX 50 /* in libinput pixels */ + +#define streq(a, b) (strcmp(a, b) == 0) +#define strneq(a, b, n) (strncmp(a, b, n) == 0) + +/* + libinput does not provide axis information for absolute devices, instead + it scales into the screen dimensions provided. So we set up the axes with + a fixed range, let libinput scale into that range and then the server + do the scaling it usually does. + */ +#define TOUCH_AXIS_MAX 0xffff +#define TABLET_AXIS_MAX 0xffffff +#define TABLET_PRESSURE_AXIS_MAX 2047 +#define TABLET_TILT_AXIS_MAX 64 +#define TABLET_STRIP_AXIS_MAX 4096 +#define TABLET_RING_AXIS_MAX 71 + +#define CAP_KEYBOARD 0x1 +#define CAP_POINTER 0x2 +#define CAP_TOUCH 0x4 +#define CAP_TABLET 0x8 +#define CAP_TABLET_TOOL 0x10 +#define CAP_TABLET_PAD 0x20 +#define CAP_GESTURE 0x40 + +#if HAVE_INPUTPROTO24 +#if ABI_XINPUT_VERSION >= SET_ABI_VERSION(24, 4) +#define HAVE_GESTURES +#endif +#endif + +struct xf86libinput_driver { + struct libinput *libinput; + int device_enabled_count; + void *registered_InputInfoPtr; +}; + +static struct xf86libinput_driver driver_context; + +struct xf86libinput_device { + int refcount; + int enabled_count; + uint32_t id; + struct libinput_device *device; + struct xorg_list device_list; + int server_fd; + + struct xorg_list unclaimed_tablet_tool_list; +}; + +struct xf86libinput_tablet_tool_queued_event { + struct xorg_list node; + struct libinput_event_tablet_tool *event; +}; + +struct xf86libinput_tablet_tool_event_queue { + bool need_to_queue; + struct xorg_list event_list; +}; + +struct xf86libinput_tablet_tool { + struct xorg_list node; + struct libinput_tablet_tool *tool; +}; + +struct xf86libinput { + InputInfoPtr pInfo; + char *path; + uint32_t capabilities; + + struct { + struct scroll_axis { + int dist; + double fraction; + } v, h; + } scroll; + + struct { + double x; + double y; + double x_remainder; + double y_remainder; + } scale; + + BOOL has_abs; + + ValuatorMask *valuators; + ValuatorMask *valuators_unaccelerated; + + struct options { + BOOL tapping; + BOOL tap_drag; + BOOL tap_drag_lock; + enum libinput_config_tap_button_map tap_button_map; + BOOL natural_scrolling; + BOOL left_handed; + BOOL middle_emulation; + BOOL disable_while_typing; + CARD32 sendevents; + CARD32 scroll_button; /* xorg button number */ + BOOL scroll_buttonlock; + uint32_t scroll_pixel_distance; + float speed; + float matrix[9]; + enum libinput_config_scroll_method scroll_method; + enum libinput_config_click_method click_method; + enum libinput_config_accel_profile accel_profile; + + unsigned char btnmap[MAX_BUTTONS + 1]; + + BOOL horiz_scrolling_enabled; + BOOL hires_scrolling_enabled; + + float rotation_angle; + struct bezier_control_point pressurecurve[4]; + struct ratio { + int x, y; + } area; + } options; + + struct draglock draglock; + + struct xf86libinput_device *shared_device; + struct xorg_list shared_device_link; + + struct libinput_tablet_tool *tablet_tool; + + bool allow_mode_group_updates; + + /* Pre-calculated pressure curve. + In the 0...TABLET_AXIS_MAX range */ + struct { + int *values; + size_t sz; + } pressurecurve; + + struct scale_factor { + double x, y; + } area_scale_factor; +}; + +enum event_handling { + EVENT_QUEUED, + EVENT_HANDLED, +}; + +static void +xf86libinput_create_subdevice(InputInfoPtr pInfo, + uint32_t capabilities, + XF86OptionPtr extra_opts); +static inline void +update_mode_prop(InputInfoPtr pInfo, + struct libinput_event_tablet_pad *event); + +static enum event_handling +xf86libinput_handle_event(struct libinput_event *event); + +static void +xf86libinput_post_tablet_motion(InputInfoPtr pInfo, + struct libinput_event_tablet_tool *event); + +static inline int +use_server_fd(const InputInfoPtr pInfo) { + return pInfo->fd > -1 && (pInfo->flags & XI86_SERVER_FD); +} + +static inline unsigned int +btn_linux2xorg(unsigned int b) +{ + unsigned int button; + + switch(b) { + case 0: button = 0; break; + case BTN_LEFT: button = 1; break; + case BTN_MIDDLE: button = 2; break; + case BTN_RIGHT: button = 3; break; + /* tablet button range */ + case BTN_STYLUS: button = 2; break; + case BTN_STYLUS2: button = 3; break; + default: + button = 8 + b - BTN_SIDE; + break; + } + + return button; +} +static inline unsigned int +btn_xorg2linux(unsigned int b) +{ + unsigned int button; + + switch(b) { + case 0: button = 0; break; + case 1: button = BTN_LEFT; break; + case 2: button = BTN_MIDDLE; break; + case 3: button = BTN_RIGHT; break; + default: + button = b - 8 + BTN_SIDE; + break; + } + + return button; +} + +static BOOL +xf86libinput_is_subdevice(InputInfoPtr pInfo) +{ + char *source; + BOOL is_subdevice; + + source = xf86CheckStrOption(pInfo->options, "_source", ""); + is_subdevice = streq(source, "_driver/libinput"); + free(source); + + return is_subdevice; +} + +static inline InputInfoPtr +xf86libinput_get_parent(InputInfoPtr pInfo) +{ + InputInfoPtr parent; + int parent_id; + + parent_id = xf86CheckIntOption(pInfo->options, "_libinput/shared-device", -1); + if (parent_id == -1) + return NULL; + + nt_list_for_each_entry(parent, xf86FirstLocalDevice(), next) { + int id = xf86CheckIntOption(parent->options, + "_libinput/shared-device", + -1); + if (id == parent_id && !xf86libinput_is_subdevice(parent)) + return parent; + } + + return NULL; +} + +static inline struct xf86libinput_device* +xf86libinput_shared_create(struct libinput_device *device) +{ + static uint32_t next_shared_device_id; + struct xf86libinput_device *shared_device; + + shared_device = calloc(1, sizeof(*shared_device)); + if (!shared_device) + return NULL; + + shared_device->device = device; + shared_device->refcount = 1; + shared_device->id = ++next_shared_device_id; + xorg_list_init(&shared_device->device_list); + xorg_list_init(&shared_device->unclaimed_tablet_tool_list); + + return shared_device; +} + +static inline struct xf86libinput_device* +xf86libinput_shared_ref(struct xf86libinput_device *shared_device) +{ + shared_device->refcount++; + + return shared_device; +} + +static inline struct xf86libinput_device* +xf86libinput_shared_unref(struct xf86libinput_device *shared_device) +{ + shared_device->refcount--; + + if (shared_device->refcount > 0) + return shared_device; + + free(shared_device); + + return NULL; +} + +static inline struct libinput_device * +xf86libinput_shared_enable(InputInfoPtr pInfo, + struct xf86libinput_device *shared_device, + const char *path) +{ + struct libinput_device *device; + struct libinput *libinput = driver_context.libinput; + + /* With systemd-logind the server requests the fd from logind, sets + * pInfo->fd and sets the "fd" option to the fd number. + * + * If we have a second device that uses the same path, the server + * checks all pInfo->major/minor for a match and returns the matched + * device's pInfo->fd. In this driver, this fd is the epollfd, not + * the actual device. This causes troubles when removing the + * device. + * + * What we need to do here is: after enabling the device the first + * time extract the real fd and store it in the shared device + * struct. The second device replaces the pInfo->options "fd" with + * the real fd we're using. + * + * When the device is unplugged, the server now correctly finds two + * devices on the real fd and releases them in order. + */ + shared_device->enabled_count++; + if (shared_device->enabled_count > 1) { + if (pInfo->flags & XI86_SERVER_FD) { + pInfo->options = xf86ReplaceIntOption(pInfo->options, + "fd", + shared_device->server_fd); + } + + return shared_device->device; + } + + device = libinput_path_add_device(libinput, path); + if (!device) + return NULL; + + libinput_device_set_user_data(device, shared_device); + shared_device->device = libinput_device_ref(device); + + if (pInfo->flags & XI86_SERVER_FD) + shared_device->server_fd = xf86CheckIntOption(pInfo->options, + "fd", + -1); + return device; +} + +static inline void +xf86libinput_shared_disable(struct xf86libinput_device *shared_device) +{ + struct libinput_device *device = shared_device->device; + + shared_device->enabled_count--; + + if (shared_device->enabled_count > 0) + return; + + if (!device) + return; + + libinput_device_set_user_data(device, NULL); + libinput_path_remove_device(device); + libinput_device_unref(device); + shared_device->device = NULL; +} + +static inline bool +xf86libinput_shared_is_enabled(struct xf86libinput_device *shared_device) +{ + return shared_device->enabled_count > 0; +} + +static inline bool +xf86libinput_set_pressurecurve(struct xf86libinput *driver_data, + const struct bezier_control_point controls[4]) +{ + if (memcmp(controls, bezier_defaults, sizeof(bezier_defaults)) == 0) { + free(driver_data->pressurecurve.values); + driver_data->pressurecurve.values = NULL; + return true; + } + + if (!driver_data->pressurecurve.values) { + int *vals = calloc(TABLET_PRESSURE_AXIS_MAX + 1, sizeof(int)); + if (!vals) + return false; + + driver_data->pressurecurve.values = vals; + driver_data->pressurecurve.sz = TABLET_PRESSURE_AXIS_MAX + 1; + } + + return cubic_bezier(controls, + driver_data->pressurecurve.values, + driver_data->pressurecurve.sz); +} + +static inline void +xf86libinput_set_area_ratio(struct xf86libinput *driver_data, + const struct ratio *ratio) +{ + double f; + double w, h; + + if (libinput_device_get_size(driver_data->shared_device->device, &w, &h) != 0) + return; + + driver_data->options.area = *ratio; + + if (ratio->y == 0) { + driver_data->area_scale_factor.x = 1.0; + driver_data->area_scale_factor.y = 1.0; + return; + } + + f = 1.0 * (ratio->x * h)/(ratio->y * w); + + if (f <= 1.0) { + driver_data->area_scale_factor.x = 1.0/f; + driver_data->area_scale_factor.y = 1.0; + } else { + driver_data->area_scale_factor.x = 1.0; + driver_data->area_scale_factor.y = f; + } +} + +/** + * returns true if the device has one or more of the given capabilities or + * if the device isn't a subdevice + */ +static inline bool +subdevice_has_capabilities(DeviceIntPtr dev, uint32_t capabilities) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + + if (!xf86libinput_is_subdevice(pInfo)) + return true; + + return !!(driver_data->capabilities & capabilities); +} + +static int +LibinputSetProperty(DeviceIntPtr dev, Atom atom, XIPropertyValuePtr val, + BOOL checkonly); +static void +LibinputInitProperty(DeviceIntPtr dev); + +static void +LibinputApplyConfigSendEvents(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + + if (libinput_device_config_send_events_get_modes(device) != LIBINPUT_CONFIG_SEND_EVENTS_ENABLED && + libinput_device_config_send_events_set_mode(device, + driver_data->options.sendevents) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set SendEventsMode %u\n", + driver_data->options.sendevents); +} + +static void +LibinputApplyConfigNaturalScroll(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (libinput_device_config_scroll_has_natural_scroll(device) && + libinput_device_config_scroll_set_natural_scroll_enabled(device, + driver_data->options.natural_scrolling) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set NaturalScrolling to %d\n", + driver_data->options.natural_scrolling); +} + +static void +LibinputApplyConfigAccel(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (libinput_device_config_accel_is_available(device) && + libinput_device_config_accel_set_speed(device, + driver_data->options.speed) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set speed %.2f\n", + driver_data->options.speed); + + if (libinput_device_config_accel_get_profiles(device) && + driver_data->options.accel_profile != LIBINPUT_CONFIG_ACCEL_PROFILE_NONE && + libinput_device_config_accel_set_profile(device, + driver_data->options.accel_profile) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + const char *profile; + + switch (driver_data->options.accel_profile) { + case LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE: + profile = "adaptive"; + break; + case LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT: + profile = "flat"; + break; + default: + profile = "unknown"; + break; + } + xf86IDrvMsg(pInfo, X_ERROR, "Failed to set profile %s\n", profile); + } +} + +static inline void +LibinputApplyConfigTap(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (libinput_device_config_tap_get_finger_count(device) > 0 && + libinput_device_config_tap_set_enabled(device, + driver_data->options.tapping) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set Tapping to %d\n", + driver_data->options.tapping); + + if (libinput_device_config_tap_get_finger_count(device) > 0 && + libinput_device_config_tap_set_button_map(device, + driver_data->options.tap_button_map) != LIBINPUT_CONFIG_STATUS_SUCCESS) { + const char *map; + + switch(driver_data->options.tap_button_map) { + case LIBINPUT_CONFIG_TAP_MAP_LRM: map = "lrm"; break; + case LIBINPUT_CONFIG_TAP_MAP_LMR: map = "lmr"; break; + default: map = "unknown"; break; + } + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set Tapping ButtonMap to %s\n", + map); + } + + if (libinput_device_config_tap_get_finger_count(device) > 0 && + libinput_device_config_tap_set_drag_lock_enabled(device, + driver_data->options.tap_drag_lock) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set Tapping DragLock to %d\n", + driver_data->options.tap_drag_lock); + + if (libinput_device_config_tap_get_finger_count(device) > 0 && + libinput_device_config_tap_set_drag_enabled(device, + driver_data->options.tap_drag) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set Tapping Drag to %d\n", + driver_data->options.tap_drag); +} + +static void +LibinputApplyConfigCalibration(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + + if (!subdevice_has_capabilities(dev, CAP_TOUCH|CAP_TABLET)) + return; + + if (libinput_device_config_calibration_has_matrix(device) && + libinput_device_config_calibration_set_matrix(device, + driver_data->options.matrix) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to apply matrix: " + "%.2f %.2f %.2f %2.f %.2f %.2f %.2f %.2f %.2f\n", + driver_data->options.matrix[0], driver_data->options.matrix[1], + driver_data->options.matrix[2], driver_data->options.matrix[3], + driver_data->options.matrix[4], driver_data->options.matrix[5], + driver_data->options.matrix[6], driver_data->options.matrix[7], + driver_data->options.matrix[8]); +} + +static void +LibinputApplyConfigLeftHanded(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + + if (!subdevice_has_capabilities(dev, CAP_POINTER|CAP_TABLET)) + return; + + if (libinput_device_config_left_handed_is_available(device) && + libinput_device_config_left_handed_set(device, + driver_data->options.left_handed) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set LeftHanded to %d\n", + driver_data->options.left_handed); +} + +static void +LibinputApplyConfigScrollMethod(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (libinput_device_config_scroll_set_method(device, + driver_data->options.scroll_method) != LIBINPUT_CONFIG_STATUS_SUCCESS) { + const char *method; + + switch(driver_data->options.scroll_method) { + case LIBINPUT_CONFIG_SCROLL_NO_SCROLL: method = "none"; break; + case LIBINPUT_CONFIG_SCROLL_2FG: method = "twofinger"; break; + case LIBINPUT_CONFIG_SCROLL_EDGE: method = "edge"; break; + case LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN: method = "button"; break; + default: + method = "unknown"; break; + } + + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set scroll to %s\n", + method); + } + + if (libinput_device_config_scroll_get_methods(device) & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN) { + unsigned int scroll_button; +#if HAVE_LIBINPUT_SCROLL_BUTTON_LOCK + enum libinput_config_scroll_button_lock_state buttonlock; + + buttonlock = driver_data->options.scroll_buttonlock ? + LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_ENABLED : + LIBINPUT_CONFIG_SCROLL_BUTTON_LOCK_DISABLED; + + if (libinput_device_config_scroll_set_button_lock(device, buttonlock) + != LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to %s ScrollButtonLock\n", + buttonlock ? "enable" : "disable"); + } +#endif + + scroll_button = btn_xorg2linux(driver_data->options.scroll_button); + if (libinput_device_config_scroll_set_button(device, scroll_button) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set ScrollButton to %u\n", + driver_data->options.scroll_button); + + } +} + +static void +LibinputApplyConfigClickMethod(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (libinput_device_config_click_set_method(device, + driver_data->options.click_method) != LIBINPUT_CONFIG_STATUS_SUCCESS) { + const char *method; + + switch (driver_data->options.click_method) { + case LIBINPUT_CONFIG_CLICK_METHOD_NONE: method = "none"; break; + case LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS: method = "buttonareas"; break; + case LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER: method = "clickfinger"; break; + default: + method = "unknown"; break; + } + + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set click method to %s\n", + method); + } +} + +static void +LibinputApplyConfigMiddleEmulation(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (libinput_device_config_middle_emulation_is_available(device) && + libinput_device_config_middle_emulation_set_enabled(device, + driver_data->options.middle_emulation) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set MiddleEmulation to %d\n", + driver_data->options.middle_emulation); +} + +static void +LibinputApplyConfigDisableWhileTyping(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (libinput_device_config_dwt_is_available(device) && + libinput_device_config_dwt_set_enabled(device, + driver_data->options.disable_while_typing) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set DisableWhileTyping to %d\n", + driver_data->options.disable_while_typing); +} + +static void +LibinputApplyConfigRotation(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (libinput_device_config_rotation_is_available(device) && + libinput_device_config_rotation_set_angle(device, driver_data->options.rotation_angle) != LIBINPUT_CONFIG_STATUS_SUCCESS) + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set RotationAngle to %.2f\n", + driver_data->options.rotation_angle); +} + +static inline void +LibinputApplyConfig(DeviceIntPtr dev) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + + LibinputApplyConfigSendEvents(dev, driver_data, device); + LibinputApplyConfigNaturalScroll(dev, driver_data, device); + LibinputApplyConfigAccel(dev, driver_data, device); + LibinputApplyConfigTap(dev, driver_data, device); + LibinputApplyConfigCalibration(dev, driver_data, device); + LibinputApplyConfigLeftHanded(dev, driver_data, device); + LibinputApplyConfigScrollMethod(dev, driver_data, device); + LibinputApplyConfigClickMethod(dev, driver_data, device); + LibinputApplyConfigMiddleEmulation(dev, driver_data, device); + LibinputApplyConfigDisableWhileTyping(dev, driver_data, device); + LibinputApplyConfigRotation(dev, driver_data, device); +} + +static int +xf86libinput_on(DeviceIntPtr dev) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct xf86libinput_device *shared_device = driver_data->shared_device; + struct libinput *libinput = driver_context.libinput; + struct libinput_device *device; + + device = xf86libinput_shared_enable(pInfo, + shared_device, + driver_data->path); + if (!device) + return !Success; + + /* if we use server fds, overwrite the fd with the one from + libinput nonetheless, otherwise the server won't call ReadInput + for our device. This must be swapped back to the real fd in + DEVICE_OFF so systemd-logind closes the right fd */ + pInfo->fd = libinput_get_fd(libinput); + + if (driver_context.device_enabled_count == 0) { + xf86AddEnabledDevice(pInfo); + driver_context.registered_InputInfoPtr = pInfo; + } + + driver_context.device_enabled_count++; + dev->public.on = TRUE; + + LibinputApplyConfig(dev); + + return Success; +} + +static int +xf86libinput_off(DeviceIntPtr dev) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct xf86libinput_device *shared_device = driver_data->shared_device; + + if (--driver_context.device_enabled_count == 0) { + xf86RemoveEnabledDevice(pInfo); + } + + if (use_server_fd(pInfo)) { + pInfo->fd = xf86SetIntOption(pInfo->options, "fd", -1); + } else { + pInfo->fd = -1; + } + + dev->public.on = FALSE; + + xf86libinput_shared_disable(shared_device); + + return Success; +} + +static void +xf86libinput_ptr_ctl(DeviceIntPtr dev, PtrCtrl *ctl) +{ +} + +static void +init_button_map(unsigned char *btnmap, size_t size) +{ + int i; + + memset(btnmap, 0, size); + for (i = 0; i < size; i++) + btnmap[i] = i; +} + +static void +init_button_labels(Atom *labels, size_t size) +{ + assert(size > 10); + + memset(labels, 0, size * sizeof(Atom)); + labels[0] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_LEFT); + labels[1] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_MIDDLE); + labels[2] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_RIGHT); + labels[3] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_UP); + labels[4] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_WHEEL_DOWN); + labels[5] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_LEFT); + labels[6] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_HWHEEL_RIGHT); + labels[7] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_SIDE); + labels[8] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_EXTRA); + labels[9] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_FORWARD); + labels[10] = XIGetKnownProperty(BTN_LABEL_PROP_BTN_BACK); +} + +static void +init_axis_labels(Atom *labels, size_t size) +{ + memset(labels, 0, size * sizeof(Atom)); + labels[0] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_X); + labels[1] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y); + labels[2] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_HSCROLL); + labels[3] = XIGetKnownProperty(AXIS_LABEL_PROP_REL_VSCROLL); +} + +static int +xf86libinput_init_pointer(InputInfoPtr pInfo) +{ + DeviceIntPtr dev= pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + int min, max, res; + int nbuttons = 7; + int i; + + Atom btnlabels[MAX_BUTTONS]; + Atom axislabels[TOUCHPAD_NUM_AXES]; + + for (i = BTN_JOYSTICK - 1; i >= BTN_SIDE; i--) { + if (libinput_device_pointer_has_button(device, i)) { + nbuttons += i - BTN_SIDE + 1; + break; + } + } + + init_button_labels(btnlabels, ARRAY_SIZE(btnlabels)); + init_axis_labels(axislabels, ARRAY_SIZE(axislabels)); + + InitPointerDeviceStruct((DevicePtr)dev, + driver_data->options.btnmap, + nbuttons, + btnlabels, + xf86libinput_ptr_ctl, + GetMotionHistorySize(), + TOUCHPAD_NUM_AXES, + axislabels); + min = -1; + max = -1; + res = 0; + + xf86InitValuatorAxisStruct(dev, 0, + XIGetKnownProperty(AXIS_LABEL_PROP_REL_X), + min, max, res * 1000, 0, res * 1000, Relative); + xf86InitValuatorAxisStruct(dev, 1, + XIGetKnownProperty(AXIS_LABEL_PROP_REL_Y), + min, max, res * 1000, 0, res * 1000, Relative); + + SetScrollValuator(dev, 2, SCROLL_TYPE_HORIZONTAL, driver_data->scroll.h.dist, 0); + SetScrollValuator(dev, 3, SCROLL_TYPE_VERTICAL, driver_data->scroll.v.dist, 0); + + return Success; +} + +static int +xf86libinput_init_pointer_absolute(InputInfoPtr pInfo) +{ + DeviceIntPtr dev= pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + int min, max, res; + int nbuttons = 7; + int i; + + Atom btnlabels[MAX_BUTTONS]; + Atom axislabels[TOUCHPAD_NUM_AXES]; + + for (i = BTN_BACK; i >= BTN_SIDE; i--) { + if (libinput_device_pointer_has_button(device, i)) { + nbuttons += i - BTN_SIDE + 1; + break; + } + } + + init_button_labels(btnlabels, ARRAY_SIZE(btnlabels)); + init_axis_labels(axislabels, ARRAY_SIZE(axislabels)); + + InitPointerDeviceStruct((DevicePtr)dev, + driver_data->options.btnmap, + nbuttons, + btnlabels, + xf86libinput_ptr_ctl, + GetMotionHistorySize(), + TOUCHPAD_NUM_AXES, + axislabels); + min = 0; + max = TOUCH_AXIS_MAX; + res = 0; + + xf86InitValuatorAxisStruct(dev, 0, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_X), + min, max, res * 1000, 0, res * 1000, Absolute); + xf86InitValuatorAxisStruct(dev, 1, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_Y), + min, max, res * 1000, 0, res * 1000, Absolute); + + SetScrollValuator(dev, 2, SCROLL_TYPE_HORIZONTAL, driver_data->scroll.h.dist, 0); + SetScrollValuator(dev, 3, SCROLL_TYPE_VERTICAL, driver_data->scroll.v.dist, 0); + + driver_data->has_abs = TRUE; + + return Success; +} +static void +xf86libinput_kbd_ctrl(DeviceIntPtr device, KeybdCtrl *ctrl) +{ +#define CAPSFLAG 1 +#define NUMFLAG 2 +#define SCROLLFLAG 4 + + static struct { int xbit, code; } bits[] = { + { CAPSFLAG, LIBINPUT_LED_CAPS_LOCK }, + { NUMFLAG, LIBINPUT_LED_NUM_LOCK }, + { SCROLLFLAG, LIBINPUT_LED_SCROLL_LOCK }, + { 0, 0 }, + }; + int i = 0; + enum libinput_led leds = 0; + InputInfoPtr pInfo = device->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *ldevice = driver_data->shared_device->device; + + if (!device->enabled) + return; + + while (bits[i].xbit) { + if (ctrl->leds & bits[i].xbit) + leds |= bits[i].code; + i++; + } + + libinput_device_led_update(ldevice, leds); +} + +static void +xf86libinput_init_keyboard(InputInfoPtr pInfo) +{ + DeviceIntPtr dev= pInfo->dev; + XkbRMLVOSet rmlvo = {0}; + XkbRMLVOSet defaults = {0}; + + XkbGetRulesDflts(&defaults); + + rmlvo.rules = xf86SetStrOption(pInfo->options, + "xkb_rules", + defaults.rules); + rmlvo.model = xf86SetStrOption(pInfo->options, + "xkb_model", + defaults.model); + rmlvo.layout = xf86SetStrOption(pInfo->options, + "xkb_layout", + defaults.layout); + rmlvo.variant = xf86SetStrOption(pInfo->options, + "xkb_variant", + defaults.variant); + rmlvo.options = xf86SetStrOption(pInfo->options, + "xkb_options", + defaults.options); + + InitKeyboardDeviceStruct(dev, &rmlvo, NULL, + xf86libinput_kbd_ctrl); + XkbFreeRMLVOSet(&rmlvo, FALSE); + XkbFreeRMLVOSet(&defaults, FALSE); +} + +static void +xf86libinput_init_touch(InputInfoPtr pInfo) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + int min, max, res; + Atom btnlabels[MAX_BUTTONS]; + Atom axislabels[TOUCHPAD_NUM_AXES]; + int nbuttons = 7; + int ntouches = TOUCH_MAX_SLOTS; + + init_button_labels(btnlabels, ARRAY_SIZE(btnlabels)); + init_axis_labels(axislabels, ARRAY_SIZE(axislabels)); + + InitPointerDeviceStruct((DevicePtr)dev, + driver_data->options.btnmap, + nbuttons, + btnlabels, + xf86libinput_ptr_ctl, + GetMotionHistorySize(), + TOUCHPAD_NUM_AXES, + axislabels); + min = 0; + max = TOUCH_AXIS_MAX; + res = 0; + + xf86InitValuatorAxisStruct(dev, 0, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_MT_POSITION_X), + min, max, res * 1000, 0, res * 1000, Absolute); + xf86InitValuatorAxisStruct(dev, 1, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_MT_POSITION_Y), + min, max, res * 1000, 0, res * 1000, Absolute); + + ntouches = libinput_device_touch_get_touch_count(device); + if (ntouches == 0) /* unknown - mtdev */ + ntouches = TOUCH_MAX_SLOTS; + InitTouchClassDeviceStruct(dev, ntouches, XIDirectTouch, 2); +} + +#ifdef HAVE_GESTURES +static void +xf86libinput_init_gesture(InputInfoPtr pInfo) +{ + DeviceIntPtr dev = pInfo->dev; + int ntouches = TOUCH_MAX_SLOTS; + InitGestureClassDeviceStruct(dev, ntouches); +} +#endif + +static int +xf86libinput_init_tablet_pen_or_eraser(InputInfoPtr pInfo, + struct libinput_tablet_tool *tool) +{ + DeviceIntPtr dev = pInfo->dev; + int min, max, res; + int axis; + + min = 0; + max = TABLET_PRESSURE_AXIS_MAX; + res = 0; + axis = 2; + if (libinput_tablet_tool_has_pressure(tool)) + xf86InitValuatorAxisStruct(dev, axis++, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_PRESSURE), + min, max, res * 1000, 0, res * 1000, Absolute); + max = TABLET_TILT_AXIS_MAX; + min = -TABLET_TILT_AXIS_MAX; + if (libinput_tablet_tool_has_tilt(tool)) { + xf86InitValuatorAxisStruct(dev, axis++, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_TILT_X), + min, max, res * 1000, 0, res * 1000, Absolute); + xf86InitValuatorAxisStruct(dev, axis++, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_TILT_Y), + min, max, res * 1000, 0, res * 1000, Absolute); + } + + min = -TABLET_AXIS_MAX; + max = TABLET_AXIS_MAX; + if (libinput_tablet_tool_has_rotation(tool)) + xf86InitValuatorAxisStruct(dev, axis++, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_RZ), + min, max, res * 1000, 0, res * 1000, Absolute); + return axis; +} + +static void +xf86libinput_init_tablet_airbrush(InputInfoPtr pInfo, + struct libinput_tablet_tool *tool) +{ + DeviceIntPtr dev = pInfo->dev; + int min, max, res; + int axis; + + /* first axes are shared */ + axis = xf86libinput_init_tablet_pen_or_eraser(pInfo, tool); + if (axis < 5) { + xf86IDrvMsg(pInfo, X_ERROR, "Airbrush tool has missing pressure or tilt axes\n"); + return; + } + + if (!libinput_tablet_tool_has_slider(tool)) { + xf86IDrvMsg(pInfo, X_ERROR, "Airbrush tool is missing the slider axis\n"); + return; + } + + min = -TABLET_AXIS_MAX; + max = TABLET_AXIS_MAX; + res = 0; + + xf86InitValuatorAxisStruct(dev, axis, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_THROTTLE), + min, max, res * 1000, 0, res * 1000, Absolute); +} + +static void +xf86libinput_init_tablet_mouse(InputInfoPtr pInfo, + struct libinput_tablet_tool *tool) +{ + DeviceIntPtr dev = pInfo->dev; + int min, max, res; + int axis; + + if (!libinput_tablet_tool_has_rotation(tool)) { + xf86IDrvMsg(pInfo, X_ERROR, "Mouse tool is missing the rotation axis\n"); + return; + } + + min = 0; + max = TABLET_AXIS_MAX; + res = 0; + + /* The mouse/lens tool don't have pressure, but for backwards-compat + with the xorg wacom driver we initialize the the axis anyway */ + axis = 2; + xf86InitValuatorAxisStruct(dev, axis, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_PRESSURE), + min, max, res * 1000, 0, res * 1000, Absolute); + + axis = 3; + min = -TABLET_AXIS_MAX; + max = TABLET_AXIS_MAX; + xf86InitValuatorAxisStruct(dev, axis, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_RZ), + min, max, res * 1000, 0, res * 1000, Absolute); + return; +} + +static void +xf86libinput_init_tablet(InputInfoPtr pInfo) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_tablet_tool *tool; + int min, max, res; + Atom btnlabels[TABLET_NUM_BUTTONS] = {0}; + Atom axislabels[TOUCHPAD_NUM_AXES] = {0}; + int nbuttons = TABLET_NUM_BUTTONS; + int naxes = 2; + + BUG_RETURN(driver_data->tablet_tool == NULL); + + tool = driver_data->tablet_tool; + + if (libinput_tablet_tool_has_pressure(tool)) + naxes++; + if (libinput_tablet_tool_has_tilt(tool)) + naxes += 2; + if (libinput_tablet_tool_has_slider(tool)) + naxes++; + if (libinput_tablet_tool_has_rotation(tool)) + naxes++; + + InitPointerDeviceStruct((DevicePtr)dev, + driver_data->options.btnmap, + nbuttons, + btnlabels, + xf86libinput_ptr_ctl, + GetMotionHistorySize(), + naxes, + axislabels); + + min = 0; + max = TABLET_AXIS_MAX; + res = 0; + xf86InitValuatorAxisStruct(dev, 0, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_X), + min, max, res * 1000, 0, res * 1000, Absolute); + xf86InitValuatorAxisStruct(dev, 1, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_Y), + min, max, res * 1000, 0, res * 1000, Absolute); + + switch (libinput_tablet_tool_get_type(tool)) { + case LIBINPUT_TABLET_TOOL_TYPE_PEN: + case LIBINPUT_TABLET_TOOL_TYPE_ERASER: + xf86libinput_init_tablet_pen_or_eraser(pInfo, tool); + break; + case LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH: + xf86libinput_init_tablet_airbrush(pInfo, tool); + break; + case LIBINPUT_TABLET_TOOL_TYPE_MOUSE: + case LIBINPUT_TABLET_TOOL_TYPE_LENS: + xf86libinput_init_tablet_mouse(pInfo, tool); + break; + default: + xf86IDrvMsg(pInfo, X_ERROR, "Tool type not supported yet\n"); + break; + } + + InitProximityClassDeviceStruct(dev); +} + +static void +xf86libinput_init_tablet_pad(InputInfoPtr pInfo) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + int min, max, res; + Atom btnlabels[MAX_BUTTONS] = {0}; + Atom axislabels[TOUCHPAD_NUM_AXES] = {0}; + int nbuttons; + int naxes = 7; + + nbuttons = libinput_device_tablet_pad_get_num_buttons(device) + 4; + + InitPointerDeviceStruct((DevicePtr)dev, + driver_data->options.btnmap, + nbuttons, + btnlabels, + xf86libinput_ptr_ctl, + GetMotionHistorySize(), + naxes, + axislabels); + + /* For compat with xf86-input-wacom we init x, y, pressure, followed + * by strip x, strip y, ring, ring2*/ + min = 0; + max = TABLET_AXIS_MAX; + res = 0; + xf86InitValuatorAxisStruct(dev, 0, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_X), + min, max, res * 1000, 0, res * 1000, Absolute); + xf86InitValuatorAxisStruct(dev, 1, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_Y), + min, max, res * 1000, 0, res * 1000, Absolute); + xf86InitValuatorAxisStruct(dev, 2, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_PRESSURE), + min, max, res * 1000, 0, res * 1000, Absolute); + + /* strip x */ + max = TABLET_STRIP_AXIS_MAX; + xf86InitValuatorAxisStruct(dev, 3, + None, + min, max, res * 1000, 0, res * 1000, Absolute); + /* strip y */ + xf86InitValuatorAxisStruct(dev, 4, + None, + min, max, res * 1000, 0, res * 1000, Absolute); + /* first ring */ + max = TABLET_RING_AXIS_MAX; + xf86InitValuatorAxisStruct(dev, 5, + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_WHEEL), + min, max, res * 1000, 0, res * 1000, Absolute); + /* second ring */ + xf86InitValuatorAxisStruct(dev, 6, + None, + min, max, res * 1000, 0, res * 1000, Absolute); +} + +static int +xf86libinput_init(DeviceIntPtr dev) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct xf86libinput_device *shared_device = driver_data->shared_device; + struct libinput_device *device = shared_device->device; + + BUG_RETURN_VAL(device == NULL, !Success); + + dev->public.on = FALSE; + + if (driver_data->capabilities & CAP_KEYBOARD) + xf86libinput_init_keyboard(pInfo); + if (driver_data->capabilities & CAP_POINTER) { + if (libinput_device_config_calibration_has_matrix(device) && + !libinput_device_config_accel_is_available(device)) + xf86libinput_init_pointer_absolute(pInfo); + else + xf86libinput_init_pointer(pInfo); + } + if (driver_data->capabilities & CAP_TOUCH) + xf86libinput_init_touch(pInfo); +#ifdef HAVE_GESTURES + if (driver_data->capabilities & CAP_GESTURE) + xf86libinput_init_gesture(pInfo); +#endif + if (driver_data->capabilities & CAP_TABLET_TOOL) + xf86libinput_init_tablet(pInfo); + if (driver_data->capabilities & CAP_TABLET_PAD) + xf86libinput_init_tablet_pad(pInfo); + + LibinputApplyConfig(dev); + LibinputInitProperty(dev); + XIRegisterPropertyHandler(dev, LibinputSetProperty, NULL, NULL); + + /* If we have a device but it's not yet enabled it's the + * already-removed device from PreInit. Drop the ref to clean up, + * we'll get a new libinput_device during DEVICE_ON when we re-add + * it. */ + if (!xf86libinput_shared_is_enabled(shared_device)) { + libinput_device_unref(device); + shared_device->device = NULL; + } + + return 0; +} + +static bool +is_libinput_device(InputInfoPtr pInfo) +{ + char *driver; + BOOL rc; + + driver = xf86CheckStrOption(pInfo->options, "driver", ""); + rc = streq(driver, "libinput"); + free(driver); + + return rc; +} + +static void +swap_registered_device(InputInfoPtr pInfo) +{ + InputInfoPtr next; + + if (pInfo != driver_context.registered_InputInfoPtr) + return; + + next = xf86FirstLocalDevice(); + while (next == pInfo || !is_libinput_device(next)) + next = next->next; + + input_lock(); + xf86RemoveEnabledDevice(pInfo); + xf86AddEnabledDevice(next); + driver_context.registered_InputInfoPtr = next; + input_unlock(); +} + +static void +xf86libinput_destroy(DeviceIntPtr dev) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct xf86libinput_device *shared_device = driver_data->shared_device; + + /* If the device being destroyed is the one we used for + * xf86AddEnabledDevice(), we need to swap it out for one that is + * still live. xf86AddEnabledDevice() buffers some data and once the + * deletes pInfo (when DEVICE_OFF completes) the thread will keep + * calling that struct's read_input because we never removed it. + * Avoid this by removing ours and substituting one that's still + * valid, the fd is the same anyway (libinput's epollfd). + */ + if (driver_context.device_enabled_count > 0) + swap_registered_device(pInfo); + + xorg_list_del(&driver_data->shared_device_link); + + if (driver_data->tablet_tool) + libinput_tablet_tool_unref(driver_data->tablet_tool); + + xf86libinput_shared_unref(shared_device); +} + +static int +xf86libinput_device_control(DeviceIntPtr dev, int mode) +{ + int rc = BadValue; + + switch(mode) { + case DEVICE_INIT: + rc = xf86libinput_init(dev); + break; + case DEVICE_ON: + rc = xf86libinput_on(dev); + break; + case DEVICE_OFF: + rc = xf86libinput_off(dev); + break; + case DEVICE_CLOSE: + xf86libinput_destroy(dev); + rc = Success; + break; + } + + return rc; +} + +static void +xf86libinput_handle_motion(InputInfoPtr pInfo, struct libinput_event_pointer *event) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + ValuatorMask *mask = driver_data->valuators; + double x, y; + + if ((driver_data->capabilities & CAP_POINTER) == 0) + return; + + x = libinput_event_pointer_get_dx(event); + y = libinput_event_pointer_get_dy(event); + + valuator_mask_zero(mask); + + { + double ux, uy; + + ux = libinput_event_pointer_get_dx_unaccelerated(event); + uy = libinput_event_pointer_get_dy_unaccelerated(event); + + valuator_mask_set_unaccelerated(mask, 0, x, ux); + valuator_mask_set_unaccelerated(mask, 1, y, uy); + } + xf86PostMotionEventM(dev, Relative, mask); +} + +static void +xf86libinput_handle_absmotion(InputInfoPtr pInfo, struct libinput_event_pointer *event) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + ValuatorMask *mask = driver_data->valuators; + double x, y; + + if (!driver_data->has_abs) { + xf86IDrvMsg(pInfo, X_ERROR, + "Discarding absolute event from relative device. " + "Please file a bug\n"); + return; + } + + if ((driver_data->capabilities & CAP_POINTER) == 0) + return; + + x = libinput_event_pointer_get_absolute_x_transformed(event, TOUCH_AXIS_MAX); + y = libinput_event_pointer_get_absolute_y_transformed(event, TOUCH_AXIS_MAX); + + valuator_mask_zero(mask); + valuator_mask_set_double(mask, 0, x); + valuator_mask_set_double(mask, 1, y); + + xf86PostMotionEventM(dev, Absolute, mask); +} + +static void +xf86libinput_handle_button(InputInfoPtr pInfo, struct libinput_event_pointer *event) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + int button; + int is_press; + + if ((driver_data->capabilities & CAP_POINTER) == 0) + return; + + button = btn_linux2xorg(libinput_event_pointer_get_button(event)); + is_press = (libinput_event_pointer_get_button_state(event) == LIBINPUT_BUTTON_STATE_PRESSED); + + if (draglock_get_mode(&driver_data->draglock) != DRAGLOCK_DISABLED) + draglock_filter_button(&driver_data->draglock, &button, &is_press); + + if (button && button < 256) + xf86PostButtonEvent(dev, Relative, button, is_press, 0, 0); +} + +static void +xf86libinput_handle_key(InputInfoPtr pInfo, struct libinput_event_keyboard *event) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + int is_press; + int key = libinput_event_keyboard_get_key(event); + + if ((driver_data->capabilities & CAP_KEYBOARD) == 0) + return; + + key += XORG_KEYCODE_OFFSET; + + is_press = (libinput_event_keyboard_get_key_state(event) == LIBINPUT_KEY_STATE_PRESSED); + xf86PostKeyboardEvent(dev, key, is_press); +} + +/* + * The scroll fraction is the value we divide the scroll dist with to + * accommodate for wheels with a small click angle. On these devices, + * multiple clicks of small angle accumulate to the XI 2.1 scroll distance. + * This gives us smooth scrolling on those wheels for small movements, the + * legacy button events are generated whenever the full distance is reached. + * e.g. a 2 degree click angle requires 8 clicks before a legacy event is + * sent, but each of those clicks will send XI2.1 smooth scroll data for + * compatible clients. + * + * Starting with kernel v5.0 we should get REL_WHEEL_HI_RES from those + * devices for the fine-grained scrolling and REL_WHEEL for the normal one, + * so the use-case above shouldn't matter anymore. + */ +static inline double +guess_wheel_scroll_value(struct xf86libinput *driver_data, + struct libinput_event_pointer *event, + enum libinput_pointer_axis axis) +{ + struct scroll_axis *s; + double f; + double angle; + int discrete; + + switch (axis) { + case LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL: + s = &driver_data->scroll.h; + break; + case LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL: + s = &driver_data->scroll.v; + break; + default: + return 0.0; + } + + angle = libinput_event_pointer_get_axis_value(event, axis); + discrete = libinput_event_pointer_get_axis_value_discrete(event, axis); + + /* We only need to guess the fraction on the first set of + * scroll events until a discrete value arrives. Once known, we + * re-use the fraction until the device goes away. + */ + if (s->fraction != 0.0) + goto out; + + /* if we get a discrete of 0, assume REL_WHEEL_HI_RES exists and + * normal scroll events are sent correctly, so skip all the + * guesswork. + */ + if (discrete == 0) { + s->fraction = 1.0; + goto out; + } + + /* Calculate the angle per single scroll event */ + angle /= discrete; + + /* We only do magic for click angles smaller than 10 degrees */ + if (angle >= 10) { + s->fraction = 1.0; + goto out; + } + + /* Figure out something that gets close to 15 degrees (the general + * wheel default) with a number of clicks. This formula gives us + * between 12 and and 20 degrees for the range of 1-10. See + * https://bugs.freedesktop.org/attachment.cgi?id=128256 for a + * graph. + */ + f = round(15.0/angle); + + s->fraction = f; + +out: + return s->dist/s->fraction * discrete; +} + +#if HAVE_LIBINPUT_AXIS_VALUE_V120 +static inline double +get_wheel_120_value(struct xf86libinput *driver_data, + struct libinput_event_pointer *event, + enum libinput_pointer_axis axis) +{ + struct scroll_axis *s; + double angle; + + switch (axis) { + case LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL: + s = &driver_data->scroll.h; + break; + case LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL: + s = &driver_data->scroll.v; + break; + default: + return 0.0; + } + + angle = libinput_event_pointer_get_scroll_value_v120(event, axis); + return s->dist * angle/120; +} +#endif + +static inline double +get_wheel_scroll_value(struct xf86libinput *driver_data, + struct libinput_event_pointer *event, + enum libinput_pointer_axis axis) +{ +#if HAVE_LIBINPUT_AXIS_VALUE_V120 + if (driver_data->options.hires_scrolling_enabled) + return get_wheel_120_value(driver_data, event, axis); +#endif + return guess_wheel_scroll_value(driver_data, event, axis); +} + +static inline double +get_finger_or_continuous_scroll_value(struct xf86libinput *driver_data, + struct libinput_event_pointer *event, + enum libinput_pointer_axis axis) +{ +#if HAVE_LIBINPUT_AXIS_VALUE_V120 + if (driver_data->options.hires_scrolling_enabled) + return libinput_event_pointer_get_scroll_value(event, axis); +#endif + return libinput_event_pointer_get_axis_value(event, axis); +} + +static inline bool +calculate_axis_value(struct xf86libinput *driver_data, + enum libinput_pointer_axis axis, + struct libinput_event_pointer *event, + enum libinput_pointer_axis_source source, + double *value_out) +{ + double value; + + if (!libinput_event_pointer_has_axis(event, axis)) + return false; + + /* Event may be LIBINPUT_POINTER_AXIS or + * LIBINPUT_EVENT_POINTER_SCROLL_{WHEEL|FINGER|CONTINUOUS}, depending + * on the libinput version. + * + * libinput guarantees the axis source is set for the second set of + * events too but we can switch to the event type once we ditch + * libinput < 1.19 support. + */ + if (source == LIBINPUT_POINTER_AXIS_SOURCE_WHEEL) { + value = get_wheel_scroll_value(driver_data, event, axis); + } else { + double dist = driver_data->options.scroll_pixel_distance; + assert(dist != 0.0); + + value = get_finger_or_continuous_scroll_value(driver_data, + event, + axis); + + /* We need to scale this value into our scroll increment range + * because that one is constant for the lifetime of the + * device. The user may change the ScrollPixelDistance + * though, so where we have a dist of 10 but an increment of + * 15, we need to scale from 0..10 into 0..15. + * + * We now switched to vdist of 120, so make this + * proportionate - 120/15 is 8. + */ + value = value/dist * SCROLL_INCREMENT * 8; + } + + *value_out = value; + + return true; +} + +static void +xf86libinput_handle_axis(InputInfoPtr pInfo, + struct libinput_event *e, + enum libinput_pointer_axis_source source) +{ + struct libinput_event_pointer *event; + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + ValuatorMask *mask = driver_data->valuators; + double value; + + if ((driver_data->capabilities & CAP_POINTER) == 0) + return; + + valuator_mask_zero(mask); + + event = libinput_event_get_pointer_event(e); + if (calculate_axis_value(driver_data, + LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL, + event, + source, + &value)) + valuator_mask_set_double(mask, 3, value); + + if (!driver_data->options.horiz_scrolling_enabled) + goto out; + + if (calculate_axis_value(driver_data, + LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL, + event, + source, + &value)) + valuator_mask_set_double(mask, 2, value); + + if (source == LIBINPUT_POINTER_AXIS_SOURCE_WHEEL && + !valuator_mask_isset(mask, 2) && + !valuator_mask_isset(mask, 3)) + return; + +out: + xf86PostMotionEventM(dev, Relative, mask); +} + +static void +xf86libinput_handle_touch(InputInfoPtr pInfo, + struct libinput_event_touch *event, + enum libinput_event_type event_type) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + int type; + int slot; + ValuatorMask *m = driver_data->valuators; + double val; + + /* libinput doesn't give us hw touch ids which X expects, so + emulate them here */ + static unsigned int next_touchid; + static unsigned int touchids[TOUCH_MAX_SLOTS] = {0}; + + if ((driver_data->capabilities & CAP_TOUCH) == 0) + return; + + slot = libinput_event_touch_get_seat_slot(event); + + switch (event_type) { + case LIBINPUT_EVENT_TOUCH_DOWN: + type = XI_TouchBegin; + touchids[slot] = next_touchid++; + break; + case LIBINPUT_EVENT_TOUCH_UP: + case LIBINPUT_EVENT_TOUCH_CANCEL: + type = XI_TouchEnd; + break; + case LIBINPUT_EVENT_TOUCH_MOTION: + type = XI_TouchUpdate; + break; + default: + return; + } + + valuator_mask_zero(m); + + if (type != XI_TouchEnd) { + val = libinput_event_touch_get_x_transformed(event, TOUCH_AXIS_MAX); + valuator_mask_set_double(m, 0, val); + + val = libinput_event_touch_get_y_transformed(event, TOUCH_AXIS_MAX); + valuator_mask_set_double(m, 1, val); + } + + xf86PostTouchEvent(dev, touchids[slot], type, 0, m); +} + +#ifdef HAVE_GESTURES +static void +xf86libinput_handle_gesture_swipe(InputInfoPtr pInfo, + struct libinput_event_gesture *event, + enum libinput_event_type event_type) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + int type; + uint32_t flags = 0; + + if ((driver_data->capabilities & CAP_GESTURE) == 0) + return; + + switch (event_type) { + case LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN: + type = XI_GestureSwipeBegin; + break; + case LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE: + type = XI_GestureSwipeUpdate; + break; + case LIBINPUT_EVENT_GESTURE_SWIPE_END: + type = XI_GestureSwipeEnd; + if (libinput_event_gesture_get_cancelled(event)) + flags |= XIGestureSwipeEventCancelled; + break; + default: + return; + } + + xf86PostGestureSwipeEvent(dev, type, + libinput_event_gesture_get_finger_count(event), + flags, + libinput_event_gesture_get_dx(event), + libinput_event_gesture_get_dy(event), + libinput_event_gesture_get_dx_unaccelerated(event), + libinput_event_gesture_get_dy_unaccelerated(event)); +} + +static void +xf86libinput_handle_gesture_pinch(InputInfoPtr pInfo, + struct libinput_event_gesture *event, + enum libinput_event_type event_type) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + int type; + uint32_t flags = 0; + + if ((driver_data->capabilities & CAP_GESTURE) == 0) + return; + + switch (event_type) { + case LIBINPUT_EVENT_GESTURE_PINCH_BEGIN: + type = XI_GesturePinchBegin; + break; + case LIBINPUT_EVENT_GESTURE_PINCH_UPDATE: + type = XI_GesturePinchUpdate; + break; + case LIBINPUT_EVENT_GESTURE_PINCH_END: + type = XI_GesturePinchEnd; + if (libinput_event_gesture_get_cancelled(event)) + flags |= XIGesturePinchEventCancelled; + break; + default: + return; + } + + xf86PostGesturePinchEvent(dev, type, + libinput_event_gesture_get_finger_count(event), + flags, + libinput_event_gesture_get_dx(event), + libinput_event_gesture_get_dy(event), + libinput_event_gesture_get_dx_unaccelerated(event), + libinput_event_gesture_get_dy_unaccelerated(event), + libinput_event_gesture_get_scale(event), + libinput_event_gesture_get_angle_delta(event)); +} +#endif + +static InputInfoPtr +xf86libinput_pick_device(struct xf86libinput_device *shared_device, + struct libinput_event *event) +{ + struct xf86libinput *driver_data; + uint32_t needed_cap; + enum libinput_event_type type = libinput_event_get_type(event); + + if (shared_device == NULL) + return NULL; + + switch(type) { + case LIBINPUT_EVENT_KEYBOARD_KEY: + needed_cap = CAP_KEYBOARD; + break; + case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY: + needed_cap = CAP_TABLET; + break; + case LIBINPUT_EVENT_TABLET_TOOL_BUTTON: + case LIBINPUT_EVENT_TABLET_TOOL_AXIS: + case LIBINPUT_EVENT_TABLET_TOOL_TIP: + needed_cap = CAP_TABLET_TOOL; + break; + default: + needed_cap = ~CAP_KEYBOARD; + break; + } + + xorg_list_for_each_entry(driver_data, + &shared_device->device_list, + shared_device_link) { + if (driver_data->capabilities & needed_cap) { + struct libinput_tablet_tool *tool; + + if (needed_cap != CAP_TABLET_TOOL) + return driver_data->pInfo; + + tool = libinput_event_tablet_tool_get_tool( + libinput_event_get_tablet_tool_event(event)); + if (libinput_tablet_tool_get_serial(driver_data->tablet_tool) == + libinput_tablet_tool_get_serial(tool) && + libinput_tablet_tool_get_tool_id(driver_data->tablet_tool) == + libinput_tablet_tool_get_tool_id(tool) && + libinput_tablet_tool_get_type(driver_data->tablet_tool) == + libinput_tablet_tool_get_type(tool)) + return driver_data->pInfo; + } + } + + return NULL; +} + +static void +xf86libinput_tool_destroy_queued_event(struct xf86libinput_tablet_tool_queued_event *qe) +{ + struct libinput_event *e; + + e = libinput_event_tablet_tool_get_base_event(qe->event); + libinput_event_destroy(e); + xorg_list_del(&qe->node); + free(qe); +} + +static void +xf86libinput_tool_replay_events(struct xf86libinput_tablet_tool_event_queue *queue) +{ + struct xf86libinput_tablet_tool_queued_event *qe, *tmp; + + xorg_list_for_each_entry_safe(qe, tmp, &queue->event_list, node) { + struct libinput_event *e; + + e = libinput_event_tablet_tool_get_base_event(qe->event); + xf86libinput_handle_event(e); + xf86libinput_tool_destroy_queued_event(qe); + } +} + +static bool +xf86libinput_tool_queue_event(struct libinput_event_tablet_tool *event) +{ + struct libinput_event *e; + struct libinput_tablet_tool *tool; + struct xf86libinput_tablet_tool_event_queue *queue; + struct xf86libinput_tablet_tool_queued_event *qe; + + tool = libinput_event_tablet_tool_get_tool(event); + if (!tool) + return true; + + queue = libinput_tablet_tool_get_user_data(tool); + if (!queue) + return false; + + if (!queue->need_to_queue) { + if (!xorg_list_is_empty(&queue->event_list)) { + libinput_tablet_tool_set_user_data(tool, NULL); + xf86libinput_tool_replay_events(queue); + free(queue); + } + + return false; + } + + /* We got the prox out while still queuing, just ditch the whole + * series of events and the event queue with it. */ + if (libinput_event_tablet_tool_get_proximity_state(event) == + LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT) { + struct xf86libinput_tablet_tool_queued_event *tmp; + + xorg_list_for_each_entry_safe(qe, tmp, &queue->event_list, node) + xf86libinput_tool_destroy_queued_event(qe); + + libinput_tablet_tool_set_user_data(tool, NULL); + free(queue); + + /* we destroy the event here but return true + * to make sure the event looks like it got queued and the + * caller doesn't destroy it for us + */ + e = libinput_event_tablet_tool_get_base_event(event); + libinput_event_destroy(e); + return true; + } + + qe = calloc(1, sizeof(*qe)); + if (!qe) { + e = libinput_event_tablet_tool_get_base_event(event); + libinput_event_destroy(e); + return true; + } + + qe->event = event; + xorg_list_append(&qe->node, &queue->event_list); + + return true; +} + +static enum event_handling +xf86libinput_handle_tablet_tip(InputInfoPtr pInfo, + struct libinput_event_tablet_tool *event) +{ + DeviceIntPtr pDev = pInfo->dev; + enum libinput_tablet_tool_tip_state state; + const BOOL is_absolute = TRUE; + + if (xf86libinput_tool_queue_event(event)) + return EVENT_QUEUED; + + xf86libinput_post_tablet_motion(pDev->public.devicePrivate, event); + + state = libinput_event_tablet_tool_get_tip_state(event); + + xf86PostButtonEventP(pInfo->dev, + is_absolute, 1, + state == LIBINPUT_TABLET_TOOL_TIP_DOWN ? 1 : 0, + 0, 0, NULL); + + return EVENT_HANDLED; +} + +static enum event_handling +xf86libinput_handle_tablet_button(InputInfoPtr pInfo, + struct libinput_event_tablet_tool *event) +{ + enum libinput_button_state state; + uint32_t button, b; + + if (xf86libinput_tool_queue_event(event)) + return EVENT_QUEUED; + + button = libinput_event_tablet_tool_get_button(event); + state = libinput_event_tablet_tool_get_button_state(event); + + b = btn_linux2xorg(button); + + xf86PostButtonEventP(pInfo->dev, + TRUE, + b, + state == LIBINPUT_BUTTON_STATE_PRESSED ? 1 : 0, + 0, 0, NULL); + + return EVENT_HANDLED; +} + +static void +xf86libinput_apply_area(InputInfoPtr pInfo, double *x, double *y) +{ + struct xf86libinput *driver_data = pInfo->private; + const struct scale_factor *f = &driver_data->area_scale_factor; + double sx, sy; + + if (driver_data->options.area.x == 0) + return; + + /* In left-handed mode, libinput already gives us transformed + * coordinates, so we can clip the same way. */ + + sx = min(*x * f->x, TABLET_AXIS_MAX); + sy = min(*y * f->y, TABLET_AXIS_MAX); + + *x = sx; + *y = sy; +} + +static void +xf86libinput_post_tablet_motion(InputInfoPtr pInfo, + struct libinput_event_tablet_tool *event) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + ValuatorMask *mask = driver_data->valuators; + struct libinput_tablet_tool *tool; + double value; + double x, y; + + x = libinput_event_tablet_tool_get_x_transformed(event, + TABLET_AXIS_MAX); + y = libinput_event_tablet_tool_get_y_transformed(event, + TABLET_AXIS_MAX); + xf86libinput_apply_area(pInfo, &x, &y); + valuator_mask_set_double(mask, 0, x); + valuator_mask_set_double(mask, 1, y); + + tool = libinput_event_tablet_tool_get_tool(event); + + if (libinput_tablet_tool_has_pressure(tool)) { + value = TABLET_PRESSURE_AXIS_MAX * libinput_event_tablet_tool_get_pressure(event); + if (driver_data->pressurecurve.values) + value = driver_data->pressurecurve.values[(int)value]; + valuator_mask_set_double(mask, 2, value); + } + + if (libinput_tablet_tool_has_tilt(tool)) { + value = libinput_event_tablet_tool_get_tilt_x(event); + valuator_mask_set_double(mask, 3, value); + + value = libinput_event_tablet_tool_get_tilt_y(event); + valuator_mask_set_double(mask, 4, value); + } + + if (libinput_tablet_tool_has_slider(tool)) { + value = libinput_event_tablet_tool_get_slider_position(event); + value *= TABLET_AXIS_MAX; + valuator_mask_set_double(mask, 5, value); + } + + if (libinput_tablet_tool_has_rotation(tool)) { + int valuator; + + value = libinput_event_tablet_tool_get_rotation(event); + value *= TABLET_AXIS_MAX; + + switch (libinput_tablet_tool_get_type(tool)) { + case LIBINPUT_TABLET_TOOL_TYPE_PEN: + case LIBINPUT_TABLET_TOOL_TYPE_ERASER: + valuator = 5; + break; + case LIBINPUT_TABLET_TOOL_TYPE_MOUSE: + case LIBINPUT_TABLET_TOOL_TYPE_LENS: + valuator = 3; + break; + default: + xf86IDrvMsg(pInfo, X_ERROR, + "Invalid rotation axis on tool\n"); + return; + } + + valuator_mask_set_double(mask, valuator, value); + } + + xf86PostMotionEventM(dev, Absolute, mask); +} + +static enum event_handling +xf86libinput_handle_tablet_axis(InputInfoPtr pInfo, + struct libinput_event_tablet_tool *event) +{ + if (xf86libinput_tool_queue_event(event)) + return EVENT_QUEUED; + + xf86libinput_post_tablet_motion(pInfo, event); + + return EVENT_HANDLED; +} + +static inline const char * +tool_type_to_str(enum libinput_tablet_tool_type type) +{ + const char *str; + + switch (type) { + case LIBINPUT_TABLET_TOOL_TYPE_PEN: str = "Pen"; break; + case LIBINPUT_TABLET_TOOL_TYPE_BRUSH: str = "Brush"; break; + case LIBINPUT_TABLET_TOOL_TYPE_PENCIL: str = "Pencil"; break; + case LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH: str = "Airbrush"; break; + case LIBINPUT_TABLET_TOOL_TYPE_ERASER: str = "Eraser"; break; + case LIBINPUT_TABLET_TOOL_TYPE_MOUSE: str = "Mouse"; break; + case LIBINPUT_TABLET_TOOL_TYPE_LENS: str = "Lens"; break; + default: + str = "unknown tool"; + break; + } + + return str; +} + +static inline void +xf86libinput_create_tool_subdevice(InputInfoPtr pInfo, + struct libinput_event_tablet_tool *event) +{ + struct xf86libinput *driver_data = pInfo->private; + struct xf86libinput_device *shared_device = driver_data->shared_device; + struct xf86libinput_tablet_tool *t; + struct xf86libinput_tablet_tool_event_queue *queue; + struct libinput_tablet_tool *tool; + enum libinput_tablet_tool_type tool_type; + uint64_t serial, tool_id; + XF86OptionPtr options = NULL; + char name[64]; + + t = calloc(1, sizeof *t); + if (!t) + return; + + queue = calloc(1, sizeof(*queue)); + if (!queue) { + free(t); + return; + } + queue->need_to_queue = true; + xorg_list_init(&queue->event_list); + + tool = libinput_event_tablet_tool_get_tool(event); + serial = libinput_tablet_tool_get_serial(tool); + tool_id = libinput_tablet_tool_get_tool_id(tool); + tool_type = libinput_tablet_tool_get_type(tool); + + t->tool = libinput_tablet_tool_ref(tool); + xorg_list_append(&t->node, &shared_device->unclaimed_tablet_tool_list); + + options = xf86ReplaceIntOption(options, "_libinput/tablet-tool-serial", serial); + options = xf86ReplaceIntOption(options, "_libinput/tablet-tool-id", tool_id); + options = xf86ReplaceIntOption(options, "_libinput/tablet-tool-type", tool_type); + /* Convert the name to "<base name> <tool type> (serial number)" */ + if (snprintf(name, + sizeof(name), + "%s %s (%#x)", + pInfo->name, + tool_type_to_str(libinput_tablet_tool_get_type(tool)), + (uint32_t)serial) > strlen(pInfo->name)) + options = xf86ReplaceStrOption(options, "Name", name); + + libinput_tablet_tool_set_user_data(tool, queue); + xf86libinput_tool_queue_event(event); + + xf86libinput_create_subdevice(pInfo, CAP_TABLET_TOOL, options); +} + +static inline DeviceIntPtr +xf86libinput_find_device_for_tool(InputInfoPtr pInfo, + struct libinput_tablet_tool *tool) +{ + struct xf86libinput *dev; + struct xf86libinput *driver_data = pInfo->private; + struct xf86libinput_device *shared_device = driver_data->shared_device; + uint64_t serial = libinput_tablet_tool_get_serial(tool); + uint64_t tool_id = libinput_tablet_tool_get_tool_id(tool); + enum libinput_tablet_tool_type tool_type = libinput_tablet_tool_get_type(tool); + + xorg_list_for_each_entry(dev, + &shared_device->device_list, + shared_device_link) { + if (dev->tablet_tool && + libinput_tablet_tool_get_serial(dev->tablet_tool) == serial && + libinput_tablet_tool_get_tool_id(dev->tablet_tool) == tool_id && + libinput_tablet_tool_get_type(dev->tablet_tool) == tool_type) { + return dev->pInfo->dev; + } + } + + return NULL; +} + +static enum event_handling +xf86libinput_handle_tablet_proximity(InputInfoPtr pInfo, + struct libinput_event_tablet_tool *event) +{ + struct xf86libinput *driver_data = pInfo->private; + struct libinput_tablet_tool *tool; + DeviceIntPtr pDev; + ValuatorMask *mask = driver_data->valuators; + double x, y; + BOOL in_prox; + + tool = libinput_event_tablet_tool_get_tool(event); + pDev = xf86libinput_find_device_for_tool(pInfo, tool); + + in_prox = libinput_event_tablet_tool_get_proximity_state(event) == + LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN; + + if (pDev == NULL && in_prox) { + xf86libinput_create_tool_subdevice(pInfo, event); + return EVENT_QUEUED; + } + + if (xf86libinput_tool_queue_event(event)) + return EVENT_QUEUED; + + BUG_RETURN_VAL(pDev == NULL, EVENT_HANDLED); + + x = libinput_event_tablet_tool_get_x_transformed(event, TABLET_AXIS_MAX); + y = libinput_event_tablet_tool_get_y_transformed(event, TABLET_AXIS_MAX); + valuator_mask_set_double(mask, 0, x); + valuator_mask_set_double(mask, 1, y); + + xf86PostProximityEventM(pDev, in_prox, mask); + + /* We have to send an extra motion event after proximity to make + * sure the client got the updated x/y coordinates, especially if + * they don't handle proximity events (XI2). + */ + if (in_prox) + xf86libinput_post_tablet_motion(pDev->public.devicePrivate, event); + + return EVENT_HANDLED; +} + +static void +xf86libinput_handle_tablet_pad_button(InputInfoPtr pInfo, + struct libinput_event_tablet_pad *event) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_tablet_pad_mode_group *group; + int button, b; + int is_press; + + if ((driver_data->capabilities & CAP_TABLET_PAD) == 0) + return; + + b = libinput_event_tablet_pad_get_button_number(event); + button = 1 + b; + if (button > 3) + button += 4; /* offset by scroll buttons */ + is_press = (libinput_event_tablet_pad_get_button_state(event) == LIBINPUT_BUTTON_STATE_PRESSED); + + xf86PostButtonEvent(dev, Relative, button, is_press, 0, 0); + + group = libinput_event_tablet_pad_get_mode_group(event); + if (libinput_tablet_pad_mode_group_button_is_toggle(group, b)) + update_mode_prop(pInfo, event); +} + +static void +xf86libinput_handle_tablet_pad_strip(InputInfoPtr pInfo, + struct libinput_event_tablet_pad *event) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + ValuatorMask *mask = driver_data->valuators; + double value; + int axis = 3; + int v; + + if ((driver_data->capabilities & CAP_TABLET_PAD) == 0) + return; + + /* this isn't compatible with the wacom driver which just forwards + * the values and lets the clients handle them with log2. */ + axis += libinput_event_tablet_pad_get_strip_number(event); + value = libinput_event_tablet_pad_get_strip_position(event); + v = TABLET_STRIP_AXIS_MAX * value; + + valuator_mask_zero(mask); + valuator_mask_set(mask, axis, v); + + xf86PostMotionEventM(dev, Absolute, mask); +} + +static void +xf86libinput_handle_tablet_pad_ring(InputInfoPtr pInfo, + struct libinput_event_tablet_pad *event) +{ + DeviceIntPtr dev = pInfo->dev; + struct xf86libinput *driver_data = pInfo->private; + ValuatorMask *mask = driver_data->valuators; + double value; + int axis = 5; + int v; + + if ((driver_data->capabilities & CAP_TABLET_PAD) == 0) + return; + + axis += libinput_event_tablet_pad_get_ring_number(event); + value = libinput_event_tablet_pad_get_ring_position(event)/360.0; + v = TABLET_RING_AXIS_MAX * value; + + valuator_mask_zero(mask); + valuator_mask_set(mask, axis, v); + + xf86PostMotionEventM(dev, Absolute, mask); +} + +static enum event_handling +xf86libinput_handle_event(struct libinput_event *event) +{ + struct libinput_device *device; + enum libinput_event_type type; + InputInfoPtr pInfo; + struct xf86libinput *driver_data; + enum event_handling event_handling = EVENT_HANDLED; + + type = libinput_event_get_type(event); + device = libinput_event_get_device(event); + pInfo = xf86libinput_pick_device(libinput_device_get_user_data(device), + event); + + if (!pInfo || !pInfo->dev->public.on) + goto out; + + driver_data = pInfo->private; + + switch (type) { + case LIBINPUT_EVENT_NONE: + case LIBINPUT_EVENT_DEVICE_ADDED: + case LIBINPUT_EVENT_DEVICE_REMOVED: + break; + case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE: + xf86libinput_handle_absmotion(pInfo, + libinput_event_get_pointer_event(event)); + break; + + case LIBINPUT_EVENT_POINTER_MOTION: + xf86libinput_handle_motion(pInfo, + libinput_event_get_pointer_event(event)); + break; + case LIBINPUT_EVENT_POINTER_BUTTON: + xf86libinput_handle_button(pInfo, + libinput_event_get_pointer_event(event)); + break; + case LIBINPUT_EVENT_KEYBOARD_KEY: + xf86libinput_handle_key(pInfo, + libinput_event_get_keyboard_event(event)); + break; + case LIBINPUT_EVENT_POINTER_AXIS: +#if HAVE_LIBINPUT_AXIS_VALUE_V120 + /* ignore POINTER_AXIS where we have libinput 1.19 and + higher and high-resolution scroll is enabled */ + if (driver_data->options.hires_scrolling_enabled) + break; +#endif + + xf86libinput_handle_axis(pInfo, + event, + libinput_event_pointer_get_axis_source( + libinput_event_get_pointer_event(event) + )); + break; +#if HAVE_LIBINPUT_AXIS_VALUE_V120 + case LIBINPUT_EVENT_POINTER_SCROLL_WHEEL: + if (driver_data->options.hires_scrolling_enabled) { + xf86libinput_handle_axis(pInfo, + event, + LIBINPUT_POINTER_AXIS_SOURCE_WHEEL); + } + break; + case LIBINPUT_EVENT_POINTER_SCROLL_FINGER: + if (driver_data->options.hires_scrolling_enabled) { + xf86libinput_handle_axis(pInfo, + event, + LIBINPUT_POINTER_AXIS_SOURCE_FINGER); + } + break; + case LIBINPUT_EVENT_POINTER_SCROLL_CONTINUOUS: + if (driver_data->options.hires_scrolling_enabled) { + xf86libinput_handle_axis(pInfo, + event, + LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS); + } + break; +#endif + case LIBINPUT_EVENT_TOUCH_FRAME: + break; + case LIBINPUT_EVENT_TOUCH_UP: + case LIBINPUT_EVENT_TOUCH_DOWN: + case LIBINPUT_EVENT_TOUCH_MOTION: + case LIBINPUT_EVENT_TOUCH_CANCEL: + xf86libinput_handle_touch(pInfo, + libinput_event_get_touch_event(event), + libinput_event_get_type(event)); + break; + case LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN: + case LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE: + case LIBINPUT_EVENT_GESTURE_SWIPE_END: +#ifdef HAVE_GESTURES + xf86libinput_handle_gesture_swipe(pInfo, + libinput_event_get_gesture_event(event), + type); +#endif + break; + case LIBINPUT_EVENT_GESTURE_PINCH_BEGIN: + case LIBINPUT_EVENT_GESTURE_PINCH_UPDATE: + case LIBINPUT_EVENT_GESTURE_PINCH_END: +#ifdef HAVE_GESTURES + xf86libinput_handle_gesture_pinch(pInfo, + libinput_event_get_gesture_event(event), + type); +#endif + break; + case LIBINPUT_EVENT_TABLET_TOOL_AXIS: + event_handling = xf86libinput_handle_tablet_axis(pInfo, + libinput_event_get_tablet_tool_event(event)); + break; + case LIBINPUT_EVENT_TABLET_TOOL_BUTTON: + event_handling = xf86libinput_handle_tablet_button(pInfo, + libinput_event_get_tablet_tool_event(event)); + break; + case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY: + event_handling = xf86libinput_handle_tablet_proximity(pInfo, + libinput_event_get_tablet_tool_event(event)); + break; + case LIBINPUT_EVENT_TABLET_TOOL_TIP: + event_handling = xf86libinput_handle_tablet_tip(pInfo, + libinput_event_get_tablet_tool_event(event)); + break; + case LIBINPUT_EVENT_TABLET_PAD_BUTTON: + xf86libinput_handle_tablet_pad_button(pInfo, + libinput_event_get_tablet_pad_event(event)); + break; + case LIBINPUT_EVENT_TABLET_PAD_RING: + xf86libinput_handle_tablet_pad_ring(pInfo, + libinput_event_get_tablet_pad_event(event)); + break; + case LIBINPUT_EVENT_TABLET_PAD_STRIP: + xf86libinput_handle_tablet_pad_strip(pInfo, + libinput_event_get_tablet_pad_event(event)); + break; + case LIBINPUT_EVENT_SWITCH_TOGGLE: + break; + } + +out: + return event_handling; +} + +static void +xf86libinput_read_input(InputInfoPtr pInfo) +{ + struct libinput *libinput = driver_context.libinput; + int rc; + struct libinput_event *event; + + rc = libinput_dispatch(libinput); + if (rc == -EAGAIN) + return; + + if (rc < 0) { + xf86IDrvMsg(pInfo, X_ERROR, + "Error reading events: %s\n", + strerror(-rc)); + return; + } + + while ((event = libinput_get_event(libinput))) { + if (xf86libinput_handle_event(event) == EVENT_HANDLED) + libinput_event_destroy(event); + } +} + +/* + libinput provides a userdata for the context, but not per path device. so + the open_restricted call has the libinput context, but no reference to + the pInfo->fd that we actually need to return. + The server stores the fd in the options though, so we just get it from + there. If a device is added twice with two different fds this may give us + the wrong fd but why are you doing that anyway. + */ +static int +open_restricted(const char *path, int flags, void *data) +{ + InputInfoPtr pInfo; + int fd = -1; + + /* Special handling for sysfs files (used for pad LEDs) */ + if (strneq(path, "/sys/", 5)) { + fd = open(path, flags); + return fd < 0 ? -errno : fd; + } + + nt_list_for_each_entry(pInfo, xf86FirstLocalDevice(), next) { + char *device = xf86CheckStrOption(pInfo->options, "Device", NULL); + + if (device != NULL && streq(path, device)) { + free(device); + break; + } + free(device); + } + + if (pInfo == NULL) { + xf86Msg(X_ERROR, "Failed to look up path '%s'\n", path); + return -ENODEV; + } + + fd = xf86OpenSerial(pInfo->options); + if (fd < 0) + return -errno; + + xf86FlushInput(fd); + + return fd; +} + +static void +close_restricted(int fd, void *data) +{ + InputInfoPtr pInfo; + int server_fd = -1; + BOOL found = FALSE; + + nt_list_for_each_entry(pInfo, xf86FirstLocalDevice(), next) { + server_fd = xf86CheckIntOption(pInfo->options, "fd", -1); + + if (server_fd == fd) { + found = TRUE; + break; + } + } + + if (!found) + xf86CloseSerial(fd); +} + +const struct libinput_interface interface = { + .open_restricted = open_restricted, + .close_restricted = close_restricted, +}; + +_X_ATTRIBUTE_PRINTF(3, 0) +static void +xf86libinput_log_handler(struct libinput *libinput, + enum libinput_log_priority priority, + const char *format, + va_list args) +{ + MessageType type; + int verbosity; + + switch(priority) { + case LIBINPUT_LOG_PRIORITY_DEBUG: + type = X_DEBUG; + verbosity = 10; + break; + case LIBINPUT_LOG_PRIORITY_ERROR: + type = X_ERROR; + verbosity = -1; + break; + case LIBINPUT_LOG_PRIORITY_INFO: + type = X_INFO; + verbosity = 3; + break; + default: + return; + } + + /* log messages in libinput are per-context, not per device, so we + can't use xf86IDrvMsg here, and the server has no xf86VMsg or + similar */ + LogVMessageVerb(type, verbosity, format, args); +} + +static inline BOOL +xf86libinput_parse_tap_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + BOOL tap; + + if (libinput_device_config_tap_get_finger_count(device) == 0) + return FALSE; + + tap = xf86SetBoolOption(pInfo->options, + "Tapping", + libinput_device_config_tap_get_enabled(device)); + + if (libinput_device_config_tap_set_enabled(device, tap) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set Tapping to %d\n", + tap); + tap = libinput_device_config_tap_get_enabled(device); + } + + return tap; +} + +static inline BOOL +xf86libinput_parse_tap_drag_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + BOOL drag; + + if (libinput_device_config_tap_get_finger_count(device) == 0) + return FALSE; + + drag = xf86SetBoolOption(pInfo->options, + "TappingDrag", + libinput_device_config_tap_get_drag_enabled(device)); + + if (libinput_device_config_tap_set_drag_enabled(device, drag) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set Tapping Drag Lock to %d\n", + drag); + drag = libinput_device_config_tap_get_drag_enabled(device); + } + + return drag; +} + +static inline BOOL +xf86libinput_parse_tap_drag_lock_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + BOOL drag_lock; + + if (libinput_device_config_tap_get_finger_count(device) == 0) + return FALSE; + + drag_lock = xf86SetBoolOption(pInfo->options, + "TappingDragLock", + libinput_device_config_tap_get_drag_lock_enabled(device)); + + if (libinput_device_config_tap_set_drag_lock_enabled(device, drag_lock) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set Tapping Drag Lock to %d\n", + drag_lock); + drag_lock = libinput_device_config_tap_get_drag_lock_enabled(device); + } + + return drag_lock; +} + +static inline enum libinput_config_tap_button_map +xf86libinput_parse_tap_buttonmap_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + enum libinput_config_tap_button_map map; + char *str; + + if (libinput_device_config_tap_get_finger_count(device) == 0) + return FALSE; + + map = libinput_device_config_tap_get_button_map(device); + str = xf86SetStrOption(pInfo->options, + "TappingButtonMap", + NULL); + if (str) { + if (streq(str, "lmr")) + map = LIBINPUT_CONFIG_TAP_MAP_LMR; + else if (streq(str, "lrm")) + map = LIBINPUT_CONFIG_TAP_MAP_LRM; + else + xf86IDrvMsg(pInfo, X_ERROR, + "Invalid TapButtonMap: %s\n", + str); + free(str); + } + + if (libinput_device_config_tap_set_button_map(device, map) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set Tapping Button Map to %d\n", + map); + map = libinput_device_config_tap_get_button_map(device); + } + + return map; +} + +static inline double +xf86libinput_parse_accel_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + double speed; + + if (!libinput_device_config_accel_is_available(device)) + return 0.0; + + speed = xf86SetRealOption(pInfo->options, + "AccelSpeed", + libinput_device_config_accel_get_speed(device)); + if (libinput_device_config_accel_set_speed(device, speed) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Invalid speed %.2f, using 0 instead\n", + speed); + speed = libinput_device_config_accel_get_speed(device); + } + + return speed; +} + +static inline enum libinput_config_accel_profile +xf86libinput_parse_accel_profile_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + enum libinput_config_accel_profile profile; + char *str; + + if (libinput_device_config_accel_get_profiles(device) == + LIBINPUT_CONFIG_ACCEL_PROFILE_NONE) + return LIBINPUT_CONFIG_ACCEL_PROFILE_NONE; + + str = xf86SetStrOption(pInfo->options, "AccelProfile", NULL); + if (!str) + profile = libinput_device_config_accel_get_profile(device); + else if (strncasecmp(str, "adaptive", 9) == 0) + profile = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE; + else if (strncasecmp(str, "flat", 4) == 0) + profile = LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT; + else { + xf86IDrvMsg(pInfo, X_ERROR, + "Unknown accel profile '%s'. Using default.\n", + str); + profile = libinput_device_config_accel_get_profile(device); + } + + free(str); + + return profile; +} + +static inline BOOL +xf86libinput_parse_natscroll_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + BOOL natural_scroll; + + if (!libinput_device_config_scroll_has_natural_scroll(device)) + return FALSE; + + natural_scroll = xf86SetBoolOption(pInfo->options, + "NaturalScrolling", + libinput_device_config_scroll_get_natural_scroll_enabled(device)); + if (libinput_device_config_scroll_set_natural_scroll_enabled(device, + natural_scroll) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set NaturalScrolling to %d\n", + natural_scroll); + + natural_scroll = libinput_device_config_scroll_get_natural_scroll_enabled(device); + } + + return natural_scroll; +} + +static inline enum libinput_config_send_events_mode +xf86libinput_parse_sendevents_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + char *modestr; + enum libinput_config_send_events_mode mode; + + if (libinput_device_config_send_events_get_modes(device) == LIBINPUT_CONFIG_SEND_EVENTS_ENABLED) + return LIBINPUT_CONFIG_SEND_EVENTS_ENABLED; + + mode = libinput_device_config_send_events_get_mode(device); + modestr = xf86SetStrOption(pInfo->options, + "SendEventsMode", + NULL); + if (modestr) { + if (streq(modestr, "enabled")) + mode = LIBINPUT_CONFIG_SEND_EVENTS_ENABLED; + else if (streq(modestr, "disabled")) + mode = LIBINPUT_CONFIG_SEND_EVENTS_DISABLED; + else if (streq(modestr, "disabled-on-external-mouse")) + mode = LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE; + else + xf86IDrvMsg(pInfo, X_ERROR, + "Invalid SendeventsMode: %s\n", + modestr); + free(modestr); + } + + if (libinput_device_config_send_events_set_mode(device, mode) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set SendEventsMode %u\n", mode); + mode = libinput_device_config_send_events_get_mode(device); + } + + return mode; +} + +static inline void +xf86libinput_parse_calibration_option(InputInfoPtr pInfo, + struct libinput_device *device, + float matrix_out[9]) +{ + char *str; + float matrix[9] = { 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0}; + int num_calibration; + + memcpy(matrix_out, matrix, sizeof(matrix)); + + if (!libinput_device_config_calibration_has_matrix(device)) + return; + + libinput_device_config_calibration_get_matrix(device, matrix); + memcpy(matrix_out, matrix, sizeof(matrix)); + + str = xf86SetStrOption(pInfo->options, + "CalibrationMatrix", + NULL); + if (!str) + return; + + num_calibration = sscanf(str, "%f %f %f %f %f %f %f %f %f ", + &matrix[0], &matrix[1], + &matrix[2], &matrix[3], + &matrix[4], &matrix[5], + &matrix[6], &matrix[7], + &matrix[8]); + if (num_calibration != 9) { + xf86IDrvMsg(pInfo, X_ERROR, + "Invalid matrix: %s, using default\n", str); + } else if (libinput_device_config_calibration_set_matrix(device, + matrix) == + LIBINPUT_CONFIG_STATUS_SUCCESS) { + memcpy(matrix_out, matrix, sizeof(matrix)); + } else + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to apply matrix: %s, using default\n", str); + free(str); +} + +static inline BOOL +xf86libinput_parse_lefthanded_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + BOOL left_handed; + + if (!libinput_device_config_left_handed_is_available(device)) + return FALSE; + + left_handed = xf86SetBoolOption(pInfo->options, + "LeftHanded", + libinput_device_config_left_handed_get(device)); + if (libinput_device_config_left_handed_set(device, + left_handed) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set LeftHanded to %d\n", + left_handed); + left_handed = libinput_device_config_left_handed_get(device); + } + + return left_handed; +} + +static inline enum libinput_config_scroll_method +xf86libinput_parse_scroll_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + uint32_t scroll_methods; + enum libinput_config_scroll_method m; + char *method; + + scroll_methods = libinput_device_config_scroll_get_methods(device); + if (scroll_methods == LIBINPUT_CONFIG_SCROLL_NO_SCROLL) + return LIBINPUT_CONFIG_SCROLL_NO_SCROLL; + + method = xf86SetStrOption(pInfo->options, "ScrollMethod", NULL); + if (!method) + m = libinput_device_config_scroll_get_method(device); + else if (strncasecmp(method, "twofinger", 9) == 0) + m = LIBINPUT_CONFIG_SCROLL_2FG; + else if (strncasecmp(method, "edge", 4) == 0) + m = LIBINPUT_CONFIG_SCROLL_EDGE; + else if (strncasecmp(method, "button", 6) == 0) + m = LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN; + else if (strncasecmp(method, "none", 4) == 0) + m = LIBINPUT_CONFIG_SCROLL_NO_SCROLL; + else { + xf86IDrvMsg(pInfo, X_ERROR, + "Unknown scroll method '%s'. Using default.\n", + method); + m = libinput_device_config_scroll_get_method(device); + } + + free(method); + return m; +} + +static inline unsigned int +xf86libinput_parse_scrollbutton_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + unsigned int b; + CARD32 scroll_button; + + if ((libinput_device_config_scroll_get_methods(device) & + LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN) == 0) + return 0; + + b = btn_linux2xorg(libinput_device_config_scroll_get_button(device)); + scroll_button = xf86SetIntOption(pInfo->options, + "ScrollButton", + b); + + b = btn_xorg2linux(scroll_button); + + if (libinput_device_config_scroll_set_button(device, + b) != LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set ScrollButton to %u\n", + scroll_button); + scroll_button = btn_linux2xorg(libinput_device_config_scroll_get_button(device)); + } + return scroll_button; +} + +static inline BOOL +xf86libinput_parse_scrollbuttonlock_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + bool dflt; + BOOL buttonlock = FALSE; + + if ((libinput_device_config_scroll_get_methods(device) & + LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN) == 0) + return 0; + +#if HAVE_LIBINPUT_SCROLL_BUTTON_LOCK + dflt = libinput_device_config_scroll_get_default_button_lock(device); + buttonlock = xf86SetBoolOption(pInfo->options, "ScrollButtonLock", dflt); + + if (libinput_device_config_scroll_set_button_lock(device, buttonlock) + != LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to %s ScrollButtonLock\n", + buttonlock ? "enable" : "disable"); + buttonlock = libinput_device_config_scroll_get_button_lock(device); + } +#endif + return buttonlock; +} + +static inline bool +xf86libinput_want_scroll_distance_option(struct libinput_device *device) +{ + uint32_t methods = + LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN | + LIBINPUT_CONFIG_SCROLL_2FG | + LIBINPUT_CONFIG_SCROLL_EDGE; + + if ((libinput_device_config_scroll_get_methods(device) & methods) == 0) + return false; + + return true; +} + +static inline uint32_t +xf86libinput_parse_scroll_pixel_distance_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + uint32_t dflt = SCROLL_INCREMENT; + uint32_t dist; + + if (!xf86libinput_want_scroll_distance_option(device)) + return dflt; + + dist = xf86SetIntOption(pInfo->options, "ScrollPixelDistance", dflt); + if (dist < TOUCHPAD_SCROLL_DIST_MIN || dist > TOUCHPAD_SCROLL_DIST_MAX) { + xf86IDrvMsg(pInfo, X_ERROR, + "Invalid ScrollPixelDistance %d\n", dist); + dist = dflt; + } + return dist; +} + +static inline unsigned int +xf86libinput_parse_clickmethod_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + uint32_t click_methods = libinput_device_config_click_get_methods(device); + enum libinput_config_click_method m; + char *method; + + if (click_methods == LIBINPUT_CONFIG_CLICK_METHOD_NONE) + return LIBINPUT_CONFIG_CLICK_METHOD_NONE; + + method = xf86SetStrOption(pInfo->options, "ClickMethod", NULL); + + if (!method) + m = libinput_device_config_click_get_method(device); + else if (strncasecmp(method, "buttonareas", 11) == 0) + m = LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS; + else if (strncasecmp(method, "clickfinger", 11) == 0) + m = LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER; + else if (strncasecmp(method, "none", 4) == 0) + m = LIBINPUT_CONFIG_CLICK_METHOD_NONE; + else { + xf86IDrvMsg(pInfo, X_ERROR, + "Unknown click method '%s'. Using default.\n", + method); + m = libinput_device_config_click_get_method(device); + } + free(method); + + return m; +} + +static inline BOOL +xf86libinput_parse_middleemulation_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + BOOL enabled; + + if (!libinput_device_config_middle_emulation_is_available(device)) + return FALSE; + + enabled = xf86SetBoolOption(pInfo->options, + "MiddleEmulation", + libinput_device_config_middle_emulation_get_default_enabled(device)); + if (libinput_device_config_middle_emulation_set_enabled(device, enabled) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set MiddleEmulation to %d\n", + enabled); + enabled = libinput_device_config_middle_emulation_get_enabled(device); + } + + return enabled; +} + +static inline BOOL +xf86libinput_parse_disablewhiletyping_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + BOOL enabled; + + if (!libinput_device_config_dwt_is_available(device)) + return FALSE; + + enabled = xf86SetBoolOption(pInfo->options, + "DisableWhileTyping", + libinput_device_config_dwt_get_default_enabled(device)); + if (libinput_device_config_dwt_set_enabled(device, enabled) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Failed to set DisableWhileTyping to %d\n", + enabled); + enabled = libinput_device_config_dwt_get_enabled(device); + } + + return enabled; +} + +static void +xf86libinput_parse_buttonmap_option(InputInfoPtr pInfo, + unsigned char *btnmap, + size_t size) +{ + const int MAXBUTTONS = 32; + char *mapping, *map, *s = NULL; + int idx = 1; + + init_button_map(btnmap, size); + + mapping = xf86SetStrOption(pInfo->options, "ButtonMapping", NULL); + if (!mapping) + return; + + map = mapping; + do + { + unsigned long int btn = strtoul(map, &s, 10); + + if (s == map || btn > MAXBUTTONS) + { + xf86IDrvMsg(pInfo, X_ERROR, + "... Invalid button mapping. Using defaults\n"); + init_button_map(btnmap, size); + break; + } + + btnmap[idx++] = btn; + map = s; + } while (s && *s != '\0' && idx < MAXBUTTONS); + + free(mapping); +} + +static inline void +xf86libinput_parse_draglock_option(InputInfoPtr pInfo, + struct xf86libinput *driver_data) +{ + char *str; + + str = xf86SetStrOption(pInfo->options, "DragLockButtons", NULL); + if (draglock_init_from_string(&driver_data->draglock, str) != 0) + xf86IDrvMsg(pInfo, X_ERROR, + "Invalid DragLockButtons option: \"%s\"\n", + str); + free(str); +} + +static inline BOOL +xf86libinput_parse_horiz_scroll_option(InputInfoPtr pInfo) +{ + return xf86SetBoolOption(pInfo->options, "HorizontalScrolling", TRUE); +} + +static inline BOOL +xf86libinput_parse_hirescroll_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + return xf86SetBoolOption(pInfo->options, + "HighResolutionWheelScrolling", + TRUE); +} + +static inline double +xf86libinput_parse_rotation_angle_option(InputInfoPtr pInfo, + struct libinput_device *device) +{ + double angle; + + if (!libinput_device_config_rotation_is_available(device)) + return 0.0; + + angle = xf86SetRealOption(pInfo->options, + "RotationAngle", + libinput_device_config_rotation_get_default_angle(device)); + if (libinput_device_config_rotation_set_angle(device, angle) != + LIBINPUT_CONFIG_STATUS_SUCCESS) { + xf86IDrvMsg(pInfo, X_ERROR, + "Invalid angle %.2f, using 0.0 instead\n", + angle); + angle = libinput_device_config_rotation_get_angle(device); + } + + return angle; +} + +static void +xf86libinput_parse_pressurecurve_option(InputInfoPtr pInfo, + struct xf86libinput *driver_data, + struct bezier_control_point pcurve[4]) +{ + struct bezier_control_point controls[4] = { + { 0.0, 0.0 }, + { 0.0, 0.0 }, + { 1.0, 1.0 }, + { 1.0, 1.0 }, + }; + float points[8]; + char *str; + int rc = 0; + int test_bezier[64]; + struct libinput_tablet_tool *tool = driver_data->tablet_tool; + + if ((driver_data->capabilities & CAP_TABLET_TOOL) == 0) + return; + + if (!tool || !libinput_tablet_tool_has_pressure(tool)) + return; + + str = xf86SetStrOption(pInfo->options, + "TabletToolPressureCurve", + NULL); + if (!str) + goto out; + + rc = sscanf(str, "%f/%f %f/%f %f/%f %f/%f", + &points[0], &points[1], &points[2], &points[3], + &points[4], &points[5], &points[6], &points[7]); + if (rc != 8) + goto out; + + for (int i = 0; i < 4; i++) { + if (points[i] < 0.0 || points[i] > 1.0) + goto out; + } + + controls[0].x = points[0]; + controls[0].y = points[1]; + controls[1].x = points[2]; + controls[1].y = points[3]; + controls[2].x = points[4]; + controls[2].y = points[5]; + controls[3].x = points[6]; + controls[3].y = points[7]; + + if (!cubic_bezier(controls, test_bezier, ARRAY_SIZE(test_bezier))) { + memcpy(controls, bezier_defaults, sizeof(controls)); + goto out; + } + + rc = 0; +out: + if (rc != 0) + xf86IDrvMsg(pInfo, X_ERROR, "Invalid pressure curve: %s\n", str); + free(str); + memcpy(pcurve, controls, sizeof(controls)); + xf86libinput_set_pressurecurve(driver_data, controls); +} + +static inline bool +want_area_handling(struct xf86libinput *driver_data) +{ + struct libinput_device *device = driver_data->shared_device->device; + + if ((driver_data->capabilities & CAP_TABLET_TOOL) == 0) + return false; + + /* If we have a calibration matrix, it's a built-in tablet and we + * don't need to set the area ratio on those */ + return !libinput_device_config_calibration_has_matrix(device); +} + +static void +xf86libinput_parse_tablet_area_option(InputInfoPtr pInfo, + struct xf86libinput *driver_data, + struct ratio *area_out) +{ + char *str; + int rc; + struct ratio area; + + if (!want_area_handling(driver_data)) + return; + + str = xf86SetStrOption(pInfo->options, + "TabletToolAreaRatio", + NULL); + if (!str || streq(str, "default")) + goto out; + + rc = sscanf(str, "%d:%d", &area.x, &area.y); + if (rc != 2 || area.x <= 0 || area.y <= 0) { + xf86IDrvMsg(pInfo, X_ERROR, "Invalid tablet tool area ratio: %s\n", str); + } else { + *area_out = area; + } + +out: + free(str); +} + +static void +xf86libinput_parse_options(InputInfoPtr pInfo, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + struct options *options = &driver_data->options; + + /* libinput options */ + options->tapping = xf86libinput_parse_tap_option(pInfo, device); + options->tap_drag = xf86libinput_parse_tap_drag_option(pInfo, device); + options->tap_drag_lock = xf86libinput_parse_tap_drag_lock_option(pInfo, device); + options->tap_button_map = xf86libinput_parse_tap_buttonmap_option(pInfo, device); + options->speed = xf86libinput_parse_accel_option(pInfo, device); + options->accel_profile = xf86libinput_parse_accel_profile_option(pInfo, device); + options->natural_scrolling = xf86libinput_parse_natscroll_option(pInfo, device); + options->sendevents = xf86libinput_parse_sendevents_option(pInfo, device); + options->left_handed = xf86libinput_parse_lefthanded_option(pInfo, device); + options->scroll_method = xf86libinput_parse_scroll_option(pInfo, device); + options->scroll_button = xf86libinput_parse_scrollbutton_option(pInfo, device); + options->scroll_buttonlock = xf86libinput_parse_scrollbuttonlock_option(pInfo, device); + options->scroll_pixel_distance = xf86libinput_parse_scroll_pixel_distance_option(pInfo, device); + options->click_method = xf86libinput_parse_clickmethod_option(pInfo, device); + options->middle_emulation = xf86libinput_parse_middleemulation_option(pInfo, device); + options->disable_while_typing = xf86libinput_parse_disablewhiletyping_option(pInfo, device); + options->rotation_angle = xf86libinput_parse_rotation_angle_option(pInfo, device); + xf86libinput_parse_calibration_option(pInfo, device, driver_data->options.matrix); + + /* non-libinput options */ + xf86libinput_parse_buttonmap_option(pInfo, + options->btnmap, + sizeof(options->btnmap)); + if (driver_data->capabilities & CAP_POINTER) { + xf86libinput_parse_draglock_option(pInfo, driver_data); + options->horiz_scrolling_enabled = xf86libinput_parse_horiz_scroll_option(pInfo); + options->hires_scrolling_enabled = xf86libinput_parse_hirescroll_option(pInfo, device); + } + + xf86libinput_parse_pressurecurve_option(pInfo, + driver_data, + options->pressurecurve); + xf86libinput_parse_tablet_area_option(pInfo, + driver_data, + &options->area); +} + +static const char* +xf86libinput_get_type_name(struct libinput_device *device, + struct xf86libinput *driver_data) +{ + const char *type_name; + + /* now pick an actual type */ + if (libinput_device_config_tap_get_finger_count(device) > 0) + type_name = XI_TOUCHPAD; + else if (driver_data->capabilities & CAP_TOUCH) + type_name = XI_TOUCHSCREEN; + else if (driver_data->capabilities & CAP_POINTER) + type_name = XI_MOUSE; + else if (driver_data->capabilities & CAP_TABLET) + type_name = XI_TABLET; + else if (driver_data->capabilities & CAP_TABLET_PAD) + type_name = "PAD"; + else if (driver_data->capabilities & CAP_TABLET_TOOL){ + switch (libinput_tablet_tool_get_type(driver_data->tablet_tool)) { + case LIBINPUT_TABLET_TOOL_TYPE_PEN: + case LIBINPUT_TABLET_TOOL_TYPE_BRUSH: + case LIBINPUT_TABLET_TOOL_TYPE_PENCIL: + case LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH: + type_name = "STYLUS"; + break; + case LIBINPUT_TABLET_TOOL_TYPE_ERASER: + type_name = "ERASER"; + break; + case LIBINPUT_TABLET_TOOL_TYPE_MOUSE: + case LIBINPUT_TABLET_TOOL_TYPE_LENS: + type_name = "CURSOR"; + break; + default: + type_name = XI_TABLET; + break; + } + } else + type_name = XI_KEYBOARD; + + return type_name; +} + +static void +xf86libinput_init_driver_context(void) +{ + if (!driver_context.libinput) { + driver_context.libinput = libinput_path_create_context(&interface, &driver_context); + libinput_log_set_handler(driver_context.libinput, + xf86libinput_log_handler); + /* we want all msgs, let the server filter */ + libinput_log_set_priority(driver_context.libinput, + LIBINPUT_LOG_PRIORITY_DEBUG); + } else { + libinput_ref(driver_context.libinput); + } +} + +struct xf86libinput_hotplug_info { + InputAttributes *attrs; + InputOption *input_options; +}; + +static DeviceIntPtr +xf86libinput_hotplug_device(struct xf86libinput_hotplug_info *hotplug) +{ + DeviceIntPtr dev; + + input_lock(); + if (NewInputDeviceRequest(hotplug->input_options, + hotplug->attrs, + &dev) != Success) + dev = NULL; + input_unlock(); + + input_option_free_list(&hotplug->input_options); + FreeInputAttributes(hotplug->attrs); + free(hotplug); + + return dev; +} + +static Bool +xf86libinput_hotplug_device_cb(ClientPtr client, pointer closure) +{ + struct xf86libinput_hotplug_info *hotplug = closure; + + xf86libinput_hotplug_device(hotplug); + + return TRUE; +} + +static void +xf86libinput_create_subdevice(InputInfoPtr pInfo, + uint32_t capabilities, + XF86OptionPtr extra_options) +{ + struct xf86libinput *driver_data = pInfo->private; + struct xf86libinput_device *shared_device; + struct xf86libinput_hotplug_info *hotplug; + InputOption *iopts = NULL; + XF86OptionPtr options, o; + + shared_device = driver_data->shared_device; + pInfo->options = xf86ReplaceIntOption(pInfo->options, + "_libinput/shared-device", + shared_device->id); + + options = xf86OptionListDuplicate(pInfo->options); + options = xf86ReplaceStrOption(options, "_source", "_driver/libinput"); + options = xf86OptionListMerge(options, extra_options); + + if (capabilities & CAP_KEYBOARD) + options = xf86ReplaceBoolOption(options, "_libinput/cap-keyboard", 1); + if (capabilities & CAP_POINTER) + options = xf86ReplaceBoolOption(options, "_libinput/cap-pointer", 1); + if (capabilities & CAP_TOUCH) + options = xf86ReplaceBoolOption(options, "_libinput/cap-touch", 1); +#ifdef HAVE_GESTURES + if (capabilities & CAP_GESTURE) + options = xf86ReplaceBoolOption(options, "_libinput/cap-gesture", 1); +#endif + if (capabilities & CAP_TABLET_TOOL) + options = xf86ReplaceBoolOption(options, "_libinput/cap-tablet-tool", 1); + if (capabilities & CAP_TABLET_PAD) + options = xf86ReplaceBoolOption(options, "_libinput/cap-tablet-pad", 1); + + /* need convert from one option list to the other. woohoo. */ + o = options; + while (o) { + iopts = input_option_new(iopts, + xf86OptionName(o), + xf86OptionValue(o)); + o = xf86NextOption(o); + } + xf86OptionListFree(options); + + hotplug = calloc(1, sizeof(*hotplug)); + if (!hotplug) + return; + + hotplug->input_options = iopts; + hotplug->attrs = DuplicateInputAttributes(pInfo->attrs); + + xf86IDrvMsg(pInfo, X_INFO, "needs a virtual subdevice\n"); + + QueueWorkProc(xf86libinput_hotplug_device_cb, serverClient, hotplug); +} + +static inline uint32_t +caps_from_options(InputInfoPtr pInfo) +{ + uint32_t capabilities = 0; + + if (xf86CheckBoolOption(pInfo->options, "_libinput/cap-keyboard", 0)) + capabilities |= CAP_KEYBOARD; + if (xf86CheckBoolOption(pInfo->options, "_libinput/cap-pointer", 0)) + capabilities |= CAP_POINTER; + if (xf86CheckBoolOption(pInfo->options, "_libinput/cap-touch", 0)) + capabilities |= CAP_TOUCH; +#ifdef HAVE_GESTURES + if (xf86CheckBoolOption(pInfo->options, "_libinput/cap-gesture", 0)) + capabilities |= CAP_GESTURE; +#endif + if (xf86CheckBoolOption(pInfo->options, "_libinput/cap-tablet-tool", 0)) + capabilities |= CAP_TABLET_TOOL; + + return capabilities; +} + +static inline Bool +claim_tablet_tool(InputInfoPtr pInfo) +{ + struct xf86libinput *driver_data = pInfo->private; + struct xf86libinput_device *shared_device = driver_data->shared_device; + struct xf86libinput_tablet_tool_event_queue *queue; + struct xf86libinput_tablet_tool *t; + enum libinput_tablet_tool_type tool_type; + uint64_t serial, tool_id; + + serial = (uint32_t)xf86CheckIntOption(pInfo->options, "_libinput/tablet-tool-serial", 0); + tool_id = (uint32_t)xf86CheckIntOption(pInfo->options, "_libinput/tablet-tool-id", 0); + tool_type = (uint32_t)xf86CheckIntOption(pInfo->options, "_libinput/tablet-tool-type", 0); + + xorg_list_for_each_entry(t, + &shared_device->unclaimed_tablet_tool_list, + node) { + if (libinput_tablet_tool_get_serial(t->tool) == serial && + libinput_tablet_tool_get_tool_id(t->tool) == tool_id && + libinput_tablet_tool_get_type(t->tool) == tool_type) { + driver_data->tablet_tool = t->tool; + queue = libinput_tablet_tool_get_user_data(t->tool); + if (queue) + queue->need_to_queue = false; + xorg_list_del(&t->node); + free(t); + return TRUE; + } + } + + return FALSE; +} + +static int +xf86libinput_pre_init(InputDriverPtr drv, + InputInfoPtr pInfo, + int flags) +{ + struct xf86libinput *driver_data = NULL; + struct xf86libinput_device *shared_device = NULL; + struct libinput *libinput = NULL; + struct libinput_device *device = NULL; + char *path = NULL; + bool is_subdevice; + + pInfo->type_name = 0; + pInfo->device_control = xf86libinput_device_control; + pInfo->read_input = xf86libinput_read_input; + pInfo->control_proc = NULL; + pInfo->switch_mode = NULL; + + driver_data = calloc(1, sizeof(*driver_data)); + if (!driver_data) + goto fail; + + driver_data->valuators = valuator_mask_new(6); + if (!driver_data->valuators) + goto fail; + + driver_data->valuators_unaccelerated = valuator_mask_new(2); + if (!driver_data->valuators_unaccelerated) + goto fail; + + path = xf86SetStrOption(pInfo->options, "Device", NULL); + if (!path) + goto fail; + + xf86libinput_init_driver_context(); + libinput = driver_context.libinput; + + if (libinput == NULL) { + xf86IDrvMsg(pInfo, X_ERROR, "Creating a device for %s failed\n", path); + goto fail; + } + + is_subdevice = xf86libinput_is_subdevice(pInfo); + if (is_subdevice) { + InputInfoPtr parent; + struct xf86libinput *parent_driver_data; + + parent = xf86libinput_get_parent(pInfo); + if (!parent) { + xf86IDrvMsg(pInfo, X_ERROR, "Failed to find parent device\n"); + goto fail; + } + + parent_driver_data = parent->private; + if (!parent_driver_data) /* parent already removed again */ + goto fail; + + xf86IDrvMsg(pInfo, X_INFO, "is a virtual subdevice\n"); + shared_device = xf86libinput_shared_ref(parent_driver_data->shared_device); + device = shared_device->device; + if (!device) + xf86IDrvMsg(pInfo, X_ERROR, "Parent device not available\n"); + } + + if (!device) { + device = libinput_path_add_device(libinput, path); + if (!device) { + xf86IDrvMsg(pInfo, X_ERROR, "Failed to create a device for %s\n", path); + goto fail; + } + + /* We ref the device above, then remove it. It gets + re-added with the same path in DEVICE_ON, we hope + it doesn't change until then */ + libinput_device_ref(device); + libinput_path_remove_device(device); + + shared_device = xf86libinput_shared_create(device); + if (!shared_device) { + libinput_device_unref(device); + goto fail; + } + } + + pInfo->private = driver_data; + driver_data->pInfo = pInfo; + driver_data->path = path; + driver_data->shared_device = shared_device; + xorg_list_append(&driver_data->shared_device_link, + &shared_device->device_list); + + /* Scroll dist value matters for source finger/continuous. For those + * devices libinput provides pixel-like data, changing this will + * affect touchpad scroll speed. For wheels it doesn't matter as + * we're using the discrete value only. + */ + driver_data->scroll.v.dist = 120; + driver_data->scroll.h.dist = 120; + + if (!is_subdevice) { + if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_POINTER)) + driver_data->capabilities |= CAP_POINTER; + if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_KEYBOARD)) + driver_data->capabilities |= CAP_KEYBOARD; + if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TOUCH)) + driver_data->capabilities |= CAP_TOUCH; +#ifdef HAVE_GESTURES + if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_GESTURE)) + driver_data->capabilities |= CAP_GESTURE; +#endif + if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TABLET_TOOL)) + driver_data->capabilities |= CAP_TABLET; + if (libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TABLET_PAD)) + driver_data->capabilities |= CAP_TABLET_PAD; + } else { + + driver_data->capabilities = caps_from_options(pInfo); + + if (driver_data->capabilities & CAP_TABLET_TOOL) + claim_tablet_tool(pInfo); + } + + /* Disable acceleration in the server, libinput does it for us */ + pInfo->options = xf86ReplaceIntOption(pInfo->options, "AccelerationProfile", -1); + pInfo->options = xf86ReplaceStrOption(pInfo->options, "AccelerationScheme", "none"); + + xf86libinput_parse_options(pInfo, driver_data, device); + + /* Device is both keyboard and pointer. Drop the keyboard cap from + * this device, create a separate device instead */ + if (!is_subdevice && + driver_data->capabilities & CAP_KEYBOARD && + driver_data->capabilities & (CAP_POINTER|CAP_TOUCH|CAP_GESTURE)) { + driver_data->capabilities &= ~CAP_KEYBOARD; + xf86libinput_create_subdevice(pInfo, + CAP_KEYBOARD, + NULL); + } + + pInfo->type_name = xf86libinput_get_type_name(device, driver_data); + + return Success; +fail: + if (driver_data) { + if (driver_data->valuators) + valuator_mask_free(&driver_data->valuators); + if (driver_data->valuators_unaccelerated) + valuator_mask_free(&driver_data->valuators_unaccelerated); + } + free(path); + if (shared_device) + xf86libinput_shared_unref(shared_device); + free(driver_data); + if (libinput) + driver_context.libinput = libinput_unref(libinput); + return BadValue; +} + +static void +xf86libinput_uninit(InputDriverPtr drv, + InputInfoPtr pInfo, + int flags) +{ + struct xf86libinput *driver_data = pInfo->private; + if (driver_data) { + driver_context.libinput = libinput_unref(driver_context.libinput); + valuator_mask_free(&driver_data->valuators); + valuator_mask_free(&driver_data->valuators_unaccelerated); + free(driver_data->path); + free(driver_data); + pInfo->private = NULL; + } + xf86DeleteInput(pInfo, flags); +} + +InputDriverRec xf86libinput_driver = { + .driverVersion = 1, + .driverName = "libinput", + .PreInit = xf86libinput_pre_init, + .UnInit = xf86libinput_uninit, + .module = NULL, + .default_options= NULL, + .capabilities = XI86_DRV_CAP_SERVER_FD +}; + +static XF86ModuleVersionInfo xf86libinput_version_info = { + "libinput", + MODULEVENDORSTRING, + MODINFOSTRING1, + MODINFOSTRING2, + XORG_VERSION_CURRENT, + PACKAGE_VERSION_MAJOR, PACKAGE_VERSION_MINOR, PACKAGE_VERSION_PATCHLEVEL, + ABI_CLASS_XINPUT, + ABI_XINPUT_VERSION, + MOD_CLASS_XINPUT, + {0, 0, 0, 0} +}; + +static pointer +xf86libinput_setup_proc(pointer module, pointer options, int *errmaj, int *errmin) +{ + xf86AddInputDriver(&xf86libinput_driver, module, 0); + return module; +} + +_X_EXPORT XF86ModuleData libinputModuleData = { + .vers = &xf86libinput_version_info, + .setup = &xf86libinput_setup_proc, + .teardown = NULL +}; + +/* Property support */ + +/* libinput-specific properties */ +static Atom prop_tap; +static Atom prop_tap_default; +static Atom prop_tap_drag; +static Atom prop_tap_drag_default; +static Atom prop_tap_drag_lock; +static Atom prop_tap_drag_lock_default; +static Atom prop_tap_buttonmap; +static Atom prop_tap_buttonmap_default; +static Atom prop_calibration; +static Atom prop_calibration_default; +static Atom prop_accel; +static Atom prop_accel_default; +static Atom prop_accel_profile_enabled; +static Atom prop_accel_profile_default; +static Atom prop_accel_profiles_available; +static Atom prop_natural_scroll; +static Atom prop_natural_scroll_default; +static Atom prop_sendevents_available; +static Atom prop_sendevents_enabled; +static Atom prop_sendevents_default; +static Atom prop_left_handed; +static Atom prop_left_handed_default; +static Atom prop_scroll_methods_available; +static Atom prop_scroll_method_enabled; +static Atom prop_scroll_method_default; +static Atom prop_scroll_button; +static Atom prop_scroll_button_default; +static Atom prop_scroll_buttonlock; +static Atom prop_scroll_buttonlock_default; +static Atom prop_scroll_pixel_distance; +static Atom prop_scroll_pixel_distance_default; +static Atom prop_click_methods_available; +static Atom prop_click_method_enabled; +static Atom prop_click_method_default; +static Atom prop_middle_emulation; +static Atom prop_middle_emulation_default; +static Atom prop_disable_while_typing; +static Atom prop_disable_while_typing_default; +static Atom prop_mode_groups_available; +static Atom prop_mode_groups; +static Atom prop_mode_groups_buttons; +static Atom prop_mode_groups_rings; +static Atom prop_mode_groups_strips; +static Atom prop_rotation_angle; +static Atom prop_rotation_angle_default; + +/* driver properties */ +static Atom prop_draglock; +static Atom prop_horiz_scroll; +static Atom prop_pressurecurve; +static Atom prop_area_ratio; +static Atom prop_hires_scroll; + +/* general properties */ +static Atom prop_float; +static Atom prop_device; +static Atom prop_product_id; + +struct mode_prop_state { + int deviceid; + InputInfoPtr pInfo; + + struct libinput_tablet_pad_mode_group *group; + unsigned int mode; + unsigned int idx; +}; + +static Bool +update_mode_prop_cb(ClientPtr client, pointer closure) +{ + struct mode_prop_state *state = closure; + InputInfoPtr pInfo = state->pInfo, tmp; + struct xf86libinput *driver_data = pInfo->private; + BOOL found = FALSE; + XIPropertyValuePtr val; + int rc; + unsigned char groups[4] = {0}; + struct libinput_tablet_pad_mode_group *group = state->group; + unsigned int mode = state->mode; + unsigned int idx = state->idx; + + if (idx >= ARRAY_SIZE(groups)) + goto out; + + /* The device may have gotten removed before the WorkProc was + * scheduled. X reuses deviceids, but if the pointer value and + * device ID are what we had before, we're good */ + nt_list_for_each_entry(tmp, xf86FirstLocalDevice(), next) { + if (tmp->dev->id == state->deviceid && tmp == pInfo) { + found = TRUE; + break; + } + } + if (!found) + goto out; + + rc = XIGetDeviceProperty(pInfo->dev, + prop_mode_groups, + &val); + if (rc != Success || + val->format != 8 || + val->size <= 0) + goto out; + + memcpy(groups, (unsigned char*)val->data, val->size); + + if (groups[idx] == mode) + goto out; + + groups[idx] = mode; + + driver_data->allow_mode_group_updates = true; + XIChangeDeviceProperty(pInfo->dev, + prop_mode_groups, + XA_INTEGER, 8, + PropModeReplace, + val->size, + groups, + TRUE); + driver_data->allow_mode_group_updates = false; + +out: + libinput_tablet_pad_mode_group_unref(group); + free(state); + return TRUE; +} + +static inline void +update_mode_prop(InputInfoPtr pInfo, + struct libinput_event_tablet_pad *event) +{ + struct libinput_tablet_pad_mode_group *group; + struct mode_prop_state *state; + + state = calloc(1, sizeof(*state)); + if (!state) + return; + + state->deviceid = pInfo->dev->id; + state->pInfo = pInfo; + + group = libinput_event_tablet_pad_get_mode_group(event); + + state->group = libinput_tablet_pad_mode_group_ref(group); + state->mode = libinput_event_tablet_pad_get_mode(event); + state->idx = libinput_tablet_pad_mode_group_get_index(group); + + /* Schedule a WorkProc so we don't update from within the input + thread */ + QueueWorkProc(update_mode_prop_cb, serverClient, state); +} + +static inline BOOL +xf86libinput_check_device(DeviceIntPtr dev, + Atom atom) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + + if (device == NULL) { + BUG_WARN(dev->public.on); + xf86IDrvMsg(pInfo, X_INFO, + "SetProperty on %u called but device is disabled.\n" + "This driver cannot change properties on a disabled device\n", + atom); + return FALSE; + } + + return TRUE; +} + +static inline int +LibinputSetPropertyTap(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + BOOL* data; + + if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + if (checkonly) { + if (*data != 0 && *data != 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + if (libinput_device_config_tap_get_finger_count(device) == 0) + return BadMatch; + } else { + driver_data->options.tapping = *data; + } + + return Success; +} + +static inline int +LibinputSetPropertyTapDrag(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + BOOL* data; + + if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + if (checkonly) { + if (*data != 0 && *data != 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + if (libinput_device_config_tap_get_finger_count(device) == 0) + return BadMatch; + } else { + driver_data->options.tap_drag = *data; + } + + return Success; +} + +static inline int +LibinputSetPropertyTapDragLock(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + BOOL* data; + + if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + if (checkonly) { + if (*data != 0 && *data != 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + if (libinput_device_config_tap_get_finger_count(device) == 0) + return BadMatch; + } else { + driver_data->options.tap_drag_lock = *data; + } + + return Success; +} + +static inline int +LibinputSetPropertyTapButtonmap(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + BOOL* data; + enum libinput_config_tap_button_map map; + + if (val->format != 8 || val->size != 2 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + + if (checkonly) { + if ((data[0] && data[1]) || (!data[0] && !data[1])) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + } + + if (data[0]) + map = LIBINPUT_CONFIG_TAP_MAP_LRM; + else if (data[1]) + map = LIBINPUT_CONFIG_TAP_MAP_LMR; + else + return BadValue; + + if (!checkonly) + driver_data->options.tap_button_map = map; + + return Success; +} + +static inline int +LibinputSetPropertyCalibration(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + float* data; + + if (val->format != 32 || val->size != 9 || val->type != prop_float) + return BadMatch; + + data = (float*)val->data; + + if (checkonly) { + if (data[6] != 0.0 || + data[7] != 0.0 || + data[8] != 1.0) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + if (!libinput_device_config_calibration_has_matrix(device)) + return BadMatch; + } else { + memcpy(driver_data->options.matrix, + data, + sizeof(driver_data->options.matrix)); + } + + return Success; +} + +static inline int +LibinputSetPropertyAccel(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + float* data; + + if (val->format != 32 || val->size != 1 || val->type != prop_float) + return BadMatch; + + data = (float*)val->data; + + if (checkonly) { + if (*data < -1.0 || *data > 1.0) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + if (libinput_device_config_accel_is_available(device) == 0) + return BadMatch; + } else { + driver_data->options.speed = *data; + } + + return Success; +} + +static inline int +LibinputSetPropertyAccelProfile(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + BOOL* data; + uint32_t profiles = 0; + + if (val->format != 8 || val->size != 2 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + + if (data[0]) + profiles |= LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE; + if (data[1]) + profiles |= LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT; + + if (checkonly) { + uint32_t supported; + + if (__builtin_popcount(profiles) > 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + supported = libinput_device_config_accel_get_profiles(device); + if (profiles && (profiles & supported) == 0) + return BadValue; + } else { + driver_data->options.accel_profile = profiles; + } + + return Success; +} + +static inline int +LibinputSetPropertyNaturalScroll(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + BOOL* data; + + if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + + if (checkonly) { + if (*data != 0 && *data != 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + if (libinput_device_config_scroll_has_natural_scroll(device) == 0) + return BadMatch; + } else { + driver_data->options.natural_scrolling = *data; + } + + return Success; +} + +static inline int +LibinputSetPropertySendEvents(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + BOOL* data; + uint32_t modes = 0; + + if (val->format != 8 || val->size != 2 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + + if (data[0]) + modes |= LIBINPUT_CONFIG_SEND_EVENTS_DISABLED; + if (data[1]) + modes |= LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE; + + if (checkonly) { + uint32_t supported; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + supported = libinput_device_config_send_events_get_modes(device); + if ((modes | supported) != supported) + return BadValue; + + } else { + driver_data->options.sendevents = modes; + } + + return Success; +} + +static inline int +LibinputSetPropertyLeftHanded(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + BOOL* data; + + if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + + if (checkonly) { + int supported; + int left_handed = *data; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + supported = libinput_device_config_left_handed_is_available(device); + if (!supported && left_handed) + return BadValue; + } else { + struct xf86libinput *other; + + driver_data->options.left_handed = *data; + + xorg_list_for_each_entry(other, + &driver_data->shared_device->device_list, + shared_device_link) { + DeviceIntPtr other_device = other->pInfo->dev; + + if (other->options.left_handed == *data) + continue; + + XIChangeDeviceProperty(other_device, + atom, + val->type, + val->format, + PropModeReplace, + val->size, + val->data, + TRUE); + } + + } + + return Success; +} + +static inline int +LibinputSetPropertyScrollMethods(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + BOOL* data; + uint32_t modes = 0; + + if (val->format != 8 || val->size != 3 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + + if (data[0]) + modes |= LIBINPUT_CONFIG_SCROLL_2FG; + if (data[1]) + modes |= LIBINPUT_CONFIG_SCROLL_EDGE; + if (data[2]) + modes |= LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN; + + if (checkonly) { + uint32_t supported; + + if (__builtin_popcount(modes) > 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + supported = libinput_device_config_scroll_get_methods(device); + if (modes && (modes & supported) == 0) + return BadValue; + } else { + driver_data->options.scroll_method = modes; + } + + return Success; +} + +static inline int +LibinputSetPropertyScrollButton(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + CARD32* data; + + if (val->format != 32 || val->size != 1 || val->type != XA_CARDINAL) + return BadMatch; + + data = (CARD32*)val->data; + + if (checkonly) { + uint32_t button = *data; + uint32_t supported; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + supported = libinput_device_pointer_has_button(device, + btn_xorg2linux(button)); + if (button && !supported) + return BadValue; + } else { + driver_data->options.scroll_button = *data; + } + + return Success; +} + +static inline int +LibinputSetPropertyScrollButtonLock(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + BOOL enabled; + + if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER) + return BadMatch; + + enabled = *(BOOL*)val->data; + if (checkonly) { + if (enabled != 0 && enabled != 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + } else { + driver_data->options.scroll_buttonlock = enabled; + } + + return Success; +} + +static inline int +LibinputSetPropertyClickMethod(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + BOOL* data; + uint32_t modes = 0; + + if (val->format != 8 || val->size != 2 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + + if (data[0]) + modes |= LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS; + if (data[1]) + modes |= LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER; + + if (checkonly) { + uint32_t supported; + + if (__builtin_popcount(modes) > 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + supported = libinput_device_config_click_get_methods(device); + if (modes && (modes & supported) == 0) + return BadValue; + } else { + driver_data->options.click_method = modes; + } + + return Success; +} + +static inline int +LibinputSetPropertyMiddleEmulation(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + BOOL* data; + + if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + if (checkonly) { + if (*data != 0 && *data != 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + if (!libinput_device_config_middle_emulation_is_available(device)) + return BadMatch; + } else { + driver_data->options.middle_emulation = *data; + } + + return Success; +} + +static inline int +LibinputSetPropertyDisableWhileTyping(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + BOOL* data; + + if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER) + return BadMatch; + + data = (BOOL*)val->data; + if (checkonly) { + if (*data != 0 && *data != 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + if (!libinput_device_config_dwt_is_available(device)) + return BadMatch; + } else { + driver_data->options.disable_while_typing = *data; + } + + return Success; +} + +static inline int +prop_draglock_set_meta(struct xf86libinput *driver_data, + const BYTE *values, + int len, + BOOL checkonly) +{ + struct draglock *dl, + dummy; /* for checkonly */ + int meta; + + if (len > 1) + return BadImplementation; /* should not happen */ + + dl = (checkonly) ? &dummy : &driver_data->draglock; + meta = len > 0 ? values[0] : 0; + + return draglock_set_meta(dl, meta) == 0 ? Success: BadValue; +} + +static inline int +prop_draglock_set_pairs(struct xf86libinput *driver_data, + const BYTE* pairs, + int len, + BOOL checkonly) +{ + struct draglock *dl, + dummy; /* for checkonly */ + int data[MAX_BUTTONS + 1] = {0}; + int i; + int highest = 0; + + if (len >= ARRAY_SIZE(data)) + return BadMatch; + + if (len < 2 || len % 2) + return BadImplementation; /* should not happen */ + + dl = (checkonly) ? &dummy : &driver_data->draglock; + + for (i = 0; i < len; i += 2) { + if (pairs[i] > MAX_BUTTONS) + return BadValue; + + data[pairs[i]] = pairs[i+1]; + highest = max(highest, pairs[i]); + } + + return draglock_set_pairs(dl, data, highest + 1) == 0 ? Success : BadValue; +} + +static inline int +LibinputSetPropertyDragLockButtons(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + + if (val->format != 8 || val->type != XA_INTEGER) + return BadMatch; + + /* either a single value, or pairs of values */ + if (val->size > 1 && val->size % 2) + return BadMatch; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + if (val->size <= 1) + return prop_draglock_set_meta(driver_data, + (BYTE*)val->data, + val->size, checkonly); + else + return prop_draglock_set_pairs(driver_data, + (BYTE*)val->data, + val->size, checkonly); +} + +static inline int +LibinputSetPropertyHorizScroll(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + BOOL enabled; + + if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER) + return BadMatch; + + enabled = *(BOOL*)val->data; + if (checkonly) { + if (enabled != 0 && enabled != 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + } else { + driver_data->options.horiz_scrolling_enabled = enabled; + } + + return Success; +} + +static inline int +LibinputSetPropertyScrollPixelDistance(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + uint32_t dist; + + if (val->format != 32 || val->size != 1 || val->type != XA_CARDINAL) + return BadMatch; + + dist = *(BOOL*)val->data; + if (checkonly) { + if (dist < TOUCHPAD_SCROLL_DIST_MIN || + dist > TOUCHPAD_SCROLL_DIST_MAX) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + } else { + driver_data->options.scroll_pixel_distance = dist; + } + + return Success; +} + +static inline int +LibinputSetPropertyRotationAngle(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + float *angle; + + if (val->format != 32 || val->size != 1 || val->type != prop_float) + return BadMatch; + + angle = (float*)val->data; + + if (checkonly) { + if (*angle < 0.0 || *angle >= 360.0) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + if (libinput_device_config_rotation_is_available(device) == 0) + return BadMatch; + } else { + driver_data->options.rotation_angle = *angle; + } + + return Success; +} + +static inline int +LibinputSetPropertyPressureCurve(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + float *vals; + struct bezier_control_point controls[4]; + + if (val->format != 32 || val->size != 8 || val->type != prop_float) + return BadMatch; + + vals = val->data; + controls[0].x = vals[0]; + controls[0].y = vals[1]; + controls[1].x = vals[2]; + controls[1].y = vals[3]; + controls[2].x = vals[4]; + controls[2].y = vals[5]; + controls[3].x = vals[6]; + controls[3].y = vals[7]; + + if (checkonly) { + int test_bezier[64]; + + for (int i = 0; i < val->size; i++) { + if (vals[i] < 0.0 || vals[i] > 1.0) + return BadValue; + } + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + + if (!cubic_bezier(controls, test_bezier, ARRAY_SIZE(test_bezier))) + return BadValue; + } else { + xf86libinput_set_pressurecurve(driver_data, controls); + memcpy(driver_data->options.pressurecurve, controls, + sizeof(controls)); + } + + return Success; +} + +static inline int +LibinputSetPropertyAreaRatio(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + uint32_t *vals; + struct ratio area = { 0, 0 }; + + if (val->format != 32 || val->size != 2 || val->type != XA_CARDINAL) + return BadMatch; + + vals = val->data; + area.x = vals[0]; + area.y = vals[1]; + + if (checkonly) { + if (area.x < 0 || area.y < 0) + return BadValue; + + if ((area.x != 0 && area.y == 0) || + (area.x == 0 && area.y != 0)) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + } else { + struct xf86libinput *other; + + xf86libinput_set_area_ratio(driver_data, &area); + + xorg_list_for_each_entry(other, + &driver_data->shared_device->device_list, + shared_device_link) { + DeviceIntPtr other_device = other->pInfo->dev; + + if (other->options.area.x == area.x && + other->options.area.y == area.y) + continue; + + XIChangeDeviceProperty(other_device, + atom, + val->type, + val->format, + PropModeReplace, + val->size, + val->data, + TRUE); + } + } + + return Success; +} + +static inline int +LibinputSetPropertyHighResolutionScroll(DeviceIntPtr dev, + Atom atom, + XIPropertyValuePtr val, + BOOL checkonly) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + BOOL enabled; + + if (val->format != 8 || val->size != 1 || val->type != XA_INTEGER) + return BadMatch; + + enabled = *(BOOL*)val->data; + if (checkonly) { + if (enabled != 0 && enabled != 1) + return BadValue; + + if (!xf86libinput_check_device(dev, atom)) + return BadMatch; + } else { + driver_data->options.hires_scrolling_enabled = enabled; + } + + return Success; +} + +static int +LibinputSetProperty(DeviceIntPtr dev, Atom atom, XIPropertyValuePtr val, + BOOL checkonly) +{ + int rc; + + if (atom == prop_tap) + rc = LibinputSetPropertyTap(dev, atom, val, checkonly); + else if (atom == prop_tap_drag) + rc = LibinputSetPropertyTapDrag(dev, atom, val, checkonly); + else if (atom == prop_tap_drag_lock) + rc = LibinputSetPropertyTapDragLock(dev, atom, val, checkonly); + else if (atom == prop_tap_buttonmap) + rc = LibinputSetPropertyTapButtonmap(dev, atom, val, checkonly); + else if (atom == prop_calibration) + rc = LibinputSetPropertyCalibration(dev, atom, val, + checkonly); + else if (atom == prop_accel) + rc = LibinputSetPropertyAccel(dev, atom, val, checkonly); + else if (atom == prop_accel_profile_enabled) + rc = LibinputSetPropertyAccelProfile(dev, atom, val, checkonly); + else if (atom == prop_natural_scroll) + rc = LibinputSetPropertyNaturalScroll(dev, atom, val, checkonly); + else if (atom == prop_sendevents_enabled) + rc = LibinputSetPropertySendEvents(dev, atom, val, checkonly); + else if (atom == prop_left_handed) + rc = LibinputSetPropertyLeftHanded(dev, atom, val, checkonly); + else if (atom == prop_scroll_method_enabled) + rc = LibinputSetPropertyScrollMethods(dev, atom, val, checkonly); + else if (atom == prop_scroll_button) + rc = LibinputSetPropertyScrollButton(dev, atom, val, checkonly); + else if (atom == prop_scroll_buttonlock) + rc = LibinputSetPropertyScrollButtonLock(dev, atom, val, checkonly); + else if (atom == prop_click_method_enabled) + rc = LibinputSetPropertyClickMethod(dev, atom, val, checkonly); + else if (atom == prop_middle_emulation) + rc = LibinputSetPropertyMiddleEmulation(dev, atom, val, checkonly); + else if (atom == prop_disable_while_typing) + rc = LibinputSetPropertyDisableWhileTyping(dev, atom, val, checkonly); + else if (atom == prop_draglock) + rc = LibinputSetPropertyDragLockButtons(dev, atom, val, checkonly); + else if (atom == prop_horiz_scroll) + rc = LibinputSetPropertyHorizScroll(dev, atom, val, checkonly); + else if (atom == prop_scroll_pixel_distance) + rc = LibinputSetPropertyScrollPixelDistance(dev, atom, val, checkonly); + else if (atom == prop_mode_groups) { + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + + if (driver_data->allow_mode_group_updates) + return Success; + else + return BadAccess; + } + else if (atom == prop_rotation_angle) + rc = LibinputSetPropertyRotationAngle(dev, atom, val, checkonly); + else if (atom == prop_pressurecurve) + rc = LibinputSetPropertyPressureCurve(dev, atom, val, checkonly); + else if (atom == prop_area_ratio) + rc = LibinputSetPropertyAreaRatio(dev, atom, val, checkonly); + else if (atom == prop_hires_scroll) + rc = LibinputSetPropertyHighResolutionScroll(dev, atom, val, checkonly); + else if (atom == prop_device || atom == prop_product_id || + atom == prop_tap_default || + atom == prop_tap_drag_default || + atom == prop_tap_drag_lock_default || + atom == prop_tap_buttonmap_default || + atom == prop_calibration_default || + atom == prop_accel_default || + atom == prop_accel_profile_default || + atom == prop_natural_scroll_default || + atom == prop_sendevents_default || + atom == prop_sendevents_available || + atom == prop_left_handed_default || + atom == prop_scroll_method_default || + atom == prop_scroll_methods_available || + atom == prop_scroll_button_default || + atom == prop_scroll_buttonlock_default || + atom == prop_scroll_pixel_distance_default || + atom == prop_click_method_default || + atom == prop_click_methods_available || + atom == prop_middle_emulation_default || + atom == prop_disable_while_typing_default || + atom == prop_mode_groups_available || + atom == prop_mode_groups_buttons || + atom == prop_mode_groups_rings || + atom == prop_mode_groups_strips || + atom == prop_rotation_angle_default) + return BadAccess; /* read-only */ + else + return Success; + + if (!checkonly && rc == Success) + LibinputApplyConfig(dev); + + return rc; +} + +static Atom +LibinputMakeProperty(DeviceIntPtr dev, + const char *prop_name, + Atom type, + int format, + int len, + void *data) +{ + int rc; + Atom prop = MakeAtom(prop_name, strlen(prop_name), TRUE); + + rc = XIChangeDeviceProperty(dev, prop, type, format, + PropModeReplace, + len, data, FALSE); + if (rc != Success) + return None; + + XISetDevicePropertyDeletable(dev, prop, FALSE); + + return prop; +} + +static void +LibinputInitTapProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + BOOL tap = driver_data->options.tapping; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (libinput_device_config_tap_get_finger_count(device) == 0) + return; + + prop_tap = LibinputMakeProperty(dev, + LIBINPUT_PROP_TAP, + XA_INTEGER, + 8, + 1, + &tap); + if (!prop_tap) + return; + + tap = libinput_device_config_tap_get_default_enabled(device); + prop_tap_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_TAP_DEFAULT, + XA_INTEGER, 8, + 1, &tap); +} + +static void +LibinputInitTapDragProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + BOOL drag = driver_data->options.tap_drag; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (libinput_device_config_tap_get_finger_count(device) == 0) + return; + + prop_tap_drag = LibinputMakeProperty(dev, + LIBINPUT_PROP_TAP_DRAG, + XA_INTEGER, 8, + 1, &drag); + if (!prop_tap_drag) + return; + + drag = libinput_device_config_tap_get_default_drag_enabled(device); + prop_tap_drag_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_TAP_DRAG_DEFAULT, + XA_INTEGER, 8, + 1, &drag); +} + +static void +LibinputInitTapDragLockProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + BOOL drag_lock = driver_data->options.tap_drag_lock; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (libinput_device_config_tap_get_finger_count(device) == 0) + return; + + prop_tap_drag_lock = LibinputMakeProperty(dev, + LIBINPUT_PROP_TAP_DRAG_LOCK, + XA_INTEGER, 8, + 1, &drag_lock); + if (!prop_tap_drag_lock) + return; + + drag_lock = libinput_device_config_tap_get_default_drag_lock_enabled(device); + prop_tap_drag_lock_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_TAP_DRAG_LOCK_DEFAULT, + XA_INTEGER, 8, + 1, &drag_lock); +} + +static void +LibinputInitTapButtonmapProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + enum libinput_config_tap_button_map map; + BOOL data[2] = {0}; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + map = driver_data->options.tap_button_map; + + if (libinput_device_config_tap_get_finger_count(device) == 0) + return; + + switch (map) { + case LIBINPUT_CONFIG_TAP_MAP_LRM: + data[0] = 1; + break; + case LIBINPUT_CONFIG_TAP_MAP_LMR: + data[1] = 1; + break; + default: + break; + } + + prop_tap_buttonmap = LibinputMakeProperty(dev, + LIBINPUT_PROP_TAP_BUTTONMAP, + XA_INTEGER, 8, + 2, data); + if (!prop_tap_buttonmap) + return; + + map = libinput_device_config_tap_get_default_button_map(device); + memset(data, 0, sizeof(data)); + + switch (map) { + case LIBINPUT_CONFIG_TAP_MAP_LRM: + data[0] = 1; + break; + case LIBINPUT_CONFIG_TAP_MAP_LMR: + data[1] = 1; + break; + default: + break; + } + + prop_tap_buttonmap_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_TAP_BUTTONMAP_DEFAULT, + XA_INTEGER, 8, + 2, data); +} + +static void +LibinputInitCalibrationProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + float calibration[9]; + + if (!subdevice_has_capabilities(dev, CAP_POINTER|CAP_TOUCH|CAP_TABLET)) + return; + + if (!libinput_device_config_calibration_has_matrix(device)) + return; + + /* We use a 9-element matrix just to be closer to the X server's + transformation matrix which also has the full matrix */ + + libinput_device_config_calibration_get_matrix(device, calibration); + calibration[6] = 0.0; + calibration[7] = 0.0; + calibration[8] = 1.0; + + prop_calibration = LibinputMakeProperty(dev, + LIBINPUT_PROP_CALIBRATION, + prop_float, 32, + 9, calibration); + if (!prop_calibration) + return; + + libinput_device_config_calibration_get_default_matrix(device, + calibration); + + prop_calibration_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_CALIBRATION_DEFAULT, + prop_float, 32, + 9, calibration); +} + +static void +LibinputInitAccelProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + float speed = driver_data->options.speed; + uint32_t profile_mask; + enum libinput_config_accel_profile profile; + BOOL profiles[2] = {FALSE}; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (!libinput_device_config_accel_is_available(device) || + driver_data->capabilities & CAP_TABLET) + return; + + prop_accel = LibinputMakeProperty(dev, + LIBINPUT_PROP_ACCEL, + prop_float, 32, + 1, &speed); + if (!prop_accel) + return; + + speed = libinput_device_config_accel_get_default_speed(device); + prop_accel_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_ACCEL_DEFAULT, + prop_float, 32, + 1, &speed); + + profile_mask = libinput_device_config_accel_get_profiles(device); + if (profile_mask == LIBINPUT_CONFIG_ACCEL_PROFILE_NONE) + return; + + if (profile_mask & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE) + profiles[0] = TRUE; + if (profile_mask & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT) + profiles[1] = TRUE; + + prop_accel_profiles_available = LibinputMakeProperty(dev, + LIBINPUT_PROP_ACCEL_PROFILES_AVAILABLE, + XA_INTEGER, 8, + ARRAY_SIZE(profiles), + profiles); + if (!prop_accel_profiles_available) + return; + + memset(profiles, 0, sizeof(profiles)); + + profile = libinput_device_config_accel_get_profile(device); + switch(profile) { + case LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE: + profiles[0] = TRUE; + break; + case LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT: + profiles[1] = TRUE; + break; + default: + break; + } + + prop_accel_profile_enabled = LibinputMakeProperty(dev, + LIBINPUT_PROP_ACCEL_PROFILE_ENABLED, + XA_INTEGER, 8, + ARRAY_SIZE(profiles), + profiles); + if (!prop_accel_profile_enabled) + return; + + memset(profiles, 0, sizeof(profiles)); + + profile = libinput_device_config_accel_get_default_profile(device); + switch(profile) { + case LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE: + profiles[0] = TRUE; + break; + case LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT: + profiles[1] = TRUE; + break; + default: + break; + } + + prop_accel_profile_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_ACCEL_PROFILE_ENABLED_DEFAULT, + XA_INTEGER, 8, + ARRAY_SIZE(profiles), + profiles); + if (!prop_accel_profile_default) + return; + +} + +static void +LibinputInitNaturalScrollProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + BOOL natural_scroll = driver_data->options.natural_scrolling; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (!libinput_device_config_scroll_has_natural_scroll(device)) + return; + + prop_natural_scroll = LibinputMakeProperty(dev, + LIBINPUT_PROP_NATURAL_SCROLL, + XA_INTEGER, 8, + 1, &natural_scroll); + if (!prop_natural_scroll) + return; + + natural_scroll = libinput_device_config_scroll_get_default_natural_scroll_enabled(device); + prop_natural_scroll_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_NATURAL_SCROLL_DEFAULT, + XA_INTEGER, 8, + 1, &natural_scroll); +} + +static void +LibinputInitSendEventsProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + uint32_t sendevent_modes; + uint32_t sendevents; + BOOL modes[2] = {FALSE}; + + sendevent_modes = libinput_device_config_send_events_get_modes(device); + if (sendevent_modes == LIBINPUT_CONFIG_SEND_EVENTS_ENABLED) + return; + + if (sendevent_modes & LIBINPUT_CONFIG_SEND_EVENTS_DISABLED) + modes[0] = TRUE; + if (sendevent_modes & LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE) + modes[1] = TRUE; + + prop_sendevents_available = LibinputMakeProperty(dev, + LIBINPUT_PROP_SENDEVENTS_AVAILABLE, + XA_INTEGER, 8, + 2, modes); + if (!prop_sendevents_available) + return; + + memset(modes, 0, sizeof(modes)); + sendevents = driver_data->options.sendevents; + + switch(sendevents) { + case LIBINPUT_CONFIG_SEND_EVENTS_DISABLED: + modes[0] = TRUE; + break; + case LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE: + modes[1] = TRUE; + break; + } + + prop_sendevents_enabled = LibinputMakeProperty(dev, + LIBINPUT_PROP_SENDEVENTS_ENABLED, + XA_INTEGER, 8, + 2, modes); + + if (!prop_sendevents_enabled) + return; + + memset(modes, 0, sizeof(modes)); + sendevent_modes = libinput_device_config_send_events_get_default_mode(device); + if (sendevent_modes & LIBINPUT_CONFIG_SEND_EVENTS_DISABLED) + modes[0] = TRUE; + if (sendevent_modes & LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE) + modes[1] = TRUE; + + prop_sendevents_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_SENDEVENTS_ENABLED_DEFAULT, + XA_INTEGER, 8, + 2, modes); +} + +static void +LibinputInitLeftHandedProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + BOOL left_handed = driver_data->options.left_handed; + + if (!subdevice_has_capabilities(dev, CAP_POINTER|CAP_TABLET)) + return; + + if (!libinput_device_config_left_handed_is_available(device) || + driver_data->capabilities & CAP_TABLET) + return; + + prop_left_handed = LibinputMakeProperty(dev, + LIBINPUT_PROP_LEFT_HANDED, + XA_INTEGER, 8, + 1, &left_handed); + if (!prop_left_handed) + return; + + left_handed = libinput_device_config_left_handed_get_default(device); + prop_left_handed_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_LEFT_HANDED_DEFAULT, + XA_INTEGER, 8, + 1, &left_handed); +} + +static void +LibinputInitScrollMethodsProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + uint32_t scroll_methods; + enum libinput_config_scroll_method method; + BOOL methods[3] = {FALSE}; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + scroll_methods = libinput_device_config_scroll_get_methods(device); + if (scroll_methods == LIBINPUT_CONFIG_SCROLL_NO_SCROLL) + return; + + if (scroll_methods & LIBINPUT_CONFIG_SCROLL_2FG) + methods[0] = TRUE; + if (scroll_methods & LIBINPUT_CONFIG_SCROLL_EDGE) + methods[1] = TRUE; + if (scroll_methods & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN) + methods[2] = TRUE; + + prop_scroll_methods_available = LibinputMakeProperty(dev, + LIBINPUT_PROP_SCROLL_METHODS_AVAILABLE, + XA_INTEGER, 8, + ARRAY_SIZE(methods), + methods); + if (!prop_scroll_methods_available) + return; + + memset(methods, 0, sizeof(methods)); + + method = libinput_device_config_scroll_get_method(device); + switch(method) { + case LIBINPUT_CONFIG_SCROLL_2FG: + methods[0] = TRUE; + break; + case LIBINPUT_CONFIG_SCROLL_EDGE: + methods[1] = TRUE; + break; + case LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN: + methods[2] = TRUE; + break; + default: + break; + } + + prop_scroll_method_enabled = LibinputMakeProperty(dev, + LIBINPUT_PROP_SCROLL_METHOD_ENABLED, + XA_INTEGER, 8, + ARRAY_SIZE(methods), + methods); + if (!prop_scroll_method_enabled) + return; + + scroll_methods = libinput_device_config_scroll_get_default_method(device); + if (scroll_methods & LIBINPUT_CONFIG_SCROLL_2FG) + methods[0] = TRUE; + if (scroll_methods & LIBINPUT_CONFIG_SCROLL_EDGE) + methods[1] = TRUE; + if (scroll_methods & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN) + methods[2] = TRUE; + + prop_scroll_method_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_SCROLL_METHOD_ENABLED_DEFAULT, + XA_INTEGER, 8, + ARRAY_SIZE(methods), + methods); + /* Scroll button and scroll button lock */ + if (libinput_device_config_scroll_get_methods(device) & + LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN) { + CARD32 scroll_button = driver_data->options.scroll_button; + BOOL lock_enabled = driver_data->options.scroll_buttonlock; + + prop_scroll_button = LibinputMakeProperty(dev, + LIBINPUT_PROP_SCROLL_BUTTON, + XA_CARDINAL, 32, + 1, &scroll_button); + if (!prop_scroll_button) + return; + +#if HAVE_LIBINPUT_SCROLL_BUTTON_LOCK + scroll_button = libinput_device_config_scroll_get_default_button(device); + scroll_button = btn_linux2xorg(scroll_button); + prop_scroll_button_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_SCROLL_BUTTON_DEFAULT, + XA_CARDINAL, 32, + 1, &scroll_button); + prop_scroll_buttonlock = LibinputMakeProperty(dev, + LIBINPUT_PROP_SCROLL_BUTTON_LOCK, + XA_INTEGER, 8, + 1, &lock_enabled); + if (!prop_scroll_buttonlock) + return; + + lock_enabled = libinput_device_config_scroll_get_default_button_lock(device); + prop_scroll_buttonlock_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_SCROLL_BUTTON_LOCK_DEFAULT, + XA_INTEGER, 8, + 1, &lock_enabled); +#endif + } +} + +static void +LibinputInitScrollPixelDistanceProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + CARD32 dist = driver_data->options.scroll_pixel_distance; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (!xf86libinput_want_scroll_distance_option(device)) + return; + + prop_scroll_pixel_distance = LibinputMakeProperty(dev, + LIBINPUT_PROP_SCROLL_PIXEL_DISTANCE, + XA_CARDINAL, 32, + 1, &dist); + if (!prop_scroll_pixel_distance) + return; + + prop_scroll_pixel_distance_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_SCROLL_PIXEL_DISTANCE_DEFAULT, + XA_CARDINAL, 32, + 1, &dist); +} + +static void +LibinputInitClickMethodsProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + uint32_t click_methods; + enum libinput_config_click_method method; + BOOL methods[2] = {FALSE}; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + click_methods = libinput_device_config_click_get_methods(device); + if (click_methods == LIBINPUT_CONFIG_CLICK_METHOD_NONE) + return; + + if (click_methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS) + methods[0] = TRUE; + if (click_methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER) + methods[1] = TRUE; + + prop_click_methods_available = LibinputMakeProperty(dev, + LIBINPUT_PROP_CLICK_METHODS_AVAILABLE, + XA_INTEGER, 8, + ARRAY_SIZE(methods), + methods); + if (!prop_click_methods_available) + return; + + memset(methods, 0, sizeof(methods)); + + method = libinput_device_config_click_get_method(device); + switch(method) { + case LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS: + methods[0] = TRUE; + break; + case LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER: + methods[1] = TRUE; + break; + default: + break; + } + + prop_click_method_enabled = LibinputMakeProperty(dev, + LIBINPUT_PROP_CLICK_METHOD_ENABLED, + XA_INTEGER, 8, + ARRAY_SIZE(methods), + methods); + + if (!prop_click_method_enabled) + return; + + memset(methods, 0, sizeof(methods)); + + method = libinput_device_config_click_get_default_method(device); + switch(method) { + case LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS: + methods[0] = TRUE; + break; + case LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER: + methods[1] = TRUE; + break; + default: + break; + } + + prop_click_method_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_CLICK_METHOD_ENABLED_DEFAULT, + XA_INTEGER, 8, + ARRAY_SIZE(methods), + methods); +} + +static void +LibinputInitMiddleEmulationProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + BOOL middle = driver_data->options.middle_emulation; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (!libinput_device_config_middle_emulation_is_available(device)) + return; + + prop_middle_emulation = LibinputMakeProperty(dev, + LIBINPUT_PROP_MIDDLE_EMULATION_ENABLED, + XA_INTEGER, + 8, + 1, + &middle); + if (!prop_middle_emulation) + return; + + middle = libinput_device_config_middle_emulation_get_default_enabled(device); + prop_middle_emulation_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_MIDDLE_EMULATION_ENABLED_DEFAULT, + XA_INTEGER, 8, + 1, &middle); +} + +static void +LibinputInitDisableWhileTypingProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + BOOL dwt = driver_data->options.disable_while_typing; + + if (!subdevice_has_capabilities(dev, CAP_POINTER)) + return; + + if (!libinput_device_config_dwt_is_available(device)) + return; + + prop_disable_while_typing = LibinputMakeProperty(dev, + LIBINPUT_PROP_DISABLE_WHILE_TYPING, + XA_INTEGER, + 8, + 1, + &dwt); + if (!prop_disable_while_typing) + return; + + dwt = libinput_device_config_dwt_get_default_enabled(device); + prop_disable_while_typing_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_DISABLE_WHILE_TYPING_DEFAULT, + XA_INTEGER, 8, + 1, &dwt); +} + +static void +LibinputInitModeGroupProperties(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + struct libinput_tablet_pad_mode_group *group; + int ngroups, nmodes, mode; + int nbuttons, nstrips, nrings; + unsigned char groups[4] = {0}, + current[4] = {0}, + associations[MAX_BUTTONS] = {0}; + int g, b, r, s; + + if (!subdevice_has_capabilities(dev, CAP_TABLET_PAD)) + return; + + if (!libinput_device_has_capability(device, LIBINPUT_DEVICE_CAP_TABLET_PAD)) + return; + + ngroups = libinput_device_tablet_pad_get_num_mode_groups(device); + if (ngroups <= 0) + return; + + group = libinput_device_tablet_pad_get_mode_group(device, 0); + nmodes = libinput_tablet_pad_mode_group_get_num_modes(group); + if (ngroups == 1 && nmodes == 1) + return; + + ngroups = min(ngroups, ARRAY_SIZE(groups)); + for (g = 0; g < ngroups; g++) { + group = libinput_device_tablet_pad_get_mode_group(device, g); + nmodes = libinput_tablet_pad_mode_group_get_num_modes(group); + mode = libinput_tablet_pad_mode_group_get_mode(group); + + groups[g] = nmodes; + current[g] = mode; + } + + prop_mode_groups_available = LibinputMakeProperty(dev, + LIBINPUT_PROP_TABLET_PAD_MODE_GROUPS_AVAILABLE, + XA_INTEGER, + 8, + ngroups, + groups); + if (!prop_mode_groups_available) + return; + + prop_mode_groups = LibinputMakeProperty(dev, + LIBINPUT_PROP_TABLET_PAD_MODE_GROUPS, + XA_INTEGER, + 8, + ngroups, + current); + if (!prop_mode_groups) + return; + + for (b = 0; b < ARRAY_SIZE(associations); b++) + associations[b] = -1; + + nbuttons = libinput_device_tablet_pad_get_num_buttons(device); + for (b = 0; b < nbuttons; b++) { + /* logical buttons exclude scroll wheel buttons */ + int lb = b <= 3 ? b : b + 4; + associations[lb] = -1; + for (g = 0; g < ngroups; g++) { + group = libinput_device_tablet_pad_get_mode_group(device, g); + if (libinput_tablet_pad_mode_group_has_button(group, b)) { + associations[lb] = g; + break; + } + } + } + + prop_mode_groups_buttons = LibinputMakeProperty(dev, + LIBINPUT_PROP_TABLET_PAD_MODE_GROUP_BUTTONS, + XA_INTEGER, + 8, + nbuttons, + associations); + if (!prop_mode_groups_buttons) + return; + + nrings = libinput_device_tablet_pad_get_num_rings(device); + if (nrings) { + for (r = 0; r < nrings; r++) { + associations[r] = -1; + for (g = 0; g < ngroups; g++) { + group = libinput_device_tablet_pad_get_mode_group(device, g); + if (libinput_tablet_pad_mode_group_has_ring(group, r)) { + associations[r] = g; + break; + } + } + } + + prop_mode_groups_rings = LibinputMakeProperty(dev, + LIBINPUT_PROP_TABLET_PAD_MODE_GROUP_RINGS, + XA_INTEGER, + 8, + nrings, + associations); + if (!prop_mode_groups_rings) + return; + } + + nstrips = libinput_device_tablet_pad_get_num_strips(device); + if (nstrips) { + for (s = 0; s < nstrips; s++) { + associations[s] = -1; + for (g = 0; g < ngroups; g++) { + group = libinput_device_tablet_pad_get_mode_group(device, g); + if (libinput_tablet_pad_mode_group_has_strip(group, s)) { + associations[s] = g; + break; + } + } + } + + prop_mode_groups_strips = LibinputMakeProperty(dev, + LIBINPUT_PROP_TABLET_PAD_MODE_GROUP_STRIPS, + XA_INTEGER, + 8, + nstrips, + associations); + if (!prop_mode_groups_strips) + return; + } +} + +static void +LibinputInitDragLockProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data) +{ + size_t sz; + int dl_values[MAX_BUTTONS + 1]; + + if ((driver_data->capabilities & CAP_POINTER) == 0) + return; + + switch (draglock_get_mode(&driver_data->draglock)) { + case DRAGLOCK_DISABLED: + sz = 0; /* will be an empty property */ + break; + case DRAGLOCK_META: + dl_values[0] = draglock_get_meta(&driver_data->draglock); + sz = 1; + break; + case DRAGLOCK_PAIRS: + sz = draglock_get_pairs(&driver_data->draglock, + dl_values, ARRAY_SIZE(dl_values)); + break; + default: + xf86IDrvMsg(dev->public.devicePrivate, + X_ERROR, + "Invalid drag lock mode\n"); + return; + } + + prop_draglock = LibinputMakeProperty(dev, + LIBINPUT_PROP_DRAG_LOCK_BUTTONS, + XA_INTEGER, 8, + sz, dl_values); +} + +static void +LibinputInitHorizScrollProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data) +{ + BOOL enabled = driver_data->options.horiz_scrolling_enabled; + + if ((driver_data->capabilities & CAP_POINTER) == 0) + return; + + prop_horiz_scroll = LibinputMakeProperty(dev, + LIBINPUT_PROP_HORIZ_SCROLL_ENABLED, + XA_INTEGER, 8, + 1, &enabled); +} + +static void +LibinputInitRotationAngleProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + float angle = driver_data->options.rotation_angle; + + if (!libinput_device_config_rotation_is_available(device)) + return; + + prop_rotation_angle = LibinputMakeProperty(dev, + LIBINPUT_PROP_ROTATION_ANGLE, + prop_float, 32, + 1, &angle); + if (!prop_rotation_angle) + return; + + angle = libinput_device_config_rotation_get_default_angle(device); + prop_rotation_angle_default = LibinputMakeProperty(dev, + LIBINPUT_PROP_ROTATION_ANGLE_DEFAULT, + prop_float, 32, + 1, &angle); + + if (!prop_rotation_angle_default) + return; +} + +static void +LibinputInitPressureCurveProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data) +{ + const struct bezier_control_point *curve = driver_data->options.pressurecurve; + struct libinput_tablet_tool *tool = driver_data->tablet_tool; + float data[8]; + + if ((driver_data->capabilities & CAP_TABLET_TOOL) == 0) + return; + + if (!tool || !libinput_tablet_tool_has_pressure(tool)) + return; + + data[0] = curve[0].x; + data[1] = curve[0].y; + data[2] = curve[1].x; + data[3] = curve[1].y; + data[4] = curve[2].x; + data[5] = curve[2].y; + data[6] = curve[3].x; + data[7] = curve[3].y; + + prop_pressurecurve = LibinputMakeProperty(dev, + LIBINPUT_PROP_TABLET_TOOL_PRESSURECURVE, + prop_float, 32, + 8, data); +} + +static void +LibinputInitTabletAreaRatioProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data) +{ + const struct ratio *ratio = &driver_data->options.area; + uint32_t data[2]; + + if (!want_area_handling(driver_data)) + return; + + data[0] = ratio->x; + data[1] = ratio->y; + + prop_area_ratio = LibinputMakeProperty(dev, + LIBINPUT_PROP_TABLET_TOOL_AREA_RATIO, + XA_CARDINAL, 32, + 2, data); +} + +static void +LibinputInitHighResolutionScrollProperty(DeviceIntPtr dev, + struct xf86libinput *driver_data, + struct libinput_device *device) +{ + BOOL enabled = driver_data->options.hires_scrolling_enabled; + + if ((driver_data->capabilities & CAP_POINTER) == 0) + return; + + prop_hires_scroll = LibinputMakeProperty(dev, + LIBINPUT_PROP_HIRES_WHEEL_SCROLL_ENABLED, + XA_INTEGER, 8, + 1, &enabled); +} + +static void +LibinputInitProperty(DeviceIntPtr dev) +{ + InputInfoPtr pInfo = dev->public.devicePrivate; + struct xf86libinput *driver_data = pInfo->private; + struct libinput_device *device = driver_data->shared_device->device; + const char *device_node; + CARD32 product[2]; + int rc; + + prop_float = XIGetKnownProperty("FLOAT"); + + LibinputInitTapProperty(dev, driver_data, device); + LibinputInitTapDragProperty(dev, driver_data, device); + LibinputInitTapDragLockProperty(dev, driver_data, device); + LibinputInitTapButtonmapProperty(dev, driver_data, device); + LibinputInitNaturalScrollProperty(dev, driver_data, device); + LibinputInitDisableWhileTypingProperty(dev, driver_data, device); + LibinputInitScrollMethodsProperty(dev, driver_data, device); + LibinputInitClickMethodsProperty(dev, driver_data, device); + LibinputInitMiddleEmulationProperty(dev, driver_data, device); + LibinputInitRotationAngleProperty(dev, driver_data, device); + LibinputInitAccelProperty(dev, driver_data, device); + LibinputInitCalibrationProperty(dev, driver_data, device); + LibinputInitLeftHandedProperty(dev, driver_data, device); + LibinputInitModeGroupProperties(dev, driver_data, device); + LibinputInitSendEventsProperty(dev, driver_data, device); + + /* Device node property, read-only */ + device_node = driver_data->path; + prop_device = MakeAtom(XI_PROP_DEVICE_NODE, + strlen(XI_PROP_DEVICE_NODE), + TRUE); + rc = XIChangeDeviceProperty(dev, prop_device, XA_STRING, 8, + PropModeReplace, + strlen(device_node), device_node, + FALSE); + if (rc != Success) + return; + + XISetDevicePropertyDeletable(dev, prop_device, FALSE); + + prop_product_id = MakeAtom(XI_PROP_PRODUCT_ID, + strlen(XI_PROP_PRODUCT_ID), + TRUE); + product[0] = libinput_device_get_id_vendor(device); + product[1] = libinput_device_get_id_product(device); + rc = XIChangeDeviceProperty(dev, prop_product_id, XA_INTEGER, 32, + PropModeReplace, 2, product, FALSE); + if (rc != Success) + return; + + XISetDevicePropertyDeletable(dev, prop_product_id, FALSE); + + LibinputInitDragLockProperty(dev, driver_data); + LibinputInitHorizScrollProperty(dev, driver_data); + LibinputInitScrollPixelDistanceProperty(dev, driver_data, device); + LibinputInitPressureCurveProperty(dev, driver_data); + LibinputInitTabletAreaRatioProperty(dev, driver_data); + LibinputInitHighResolutionScrollProperty(dev, driver_data, device); +} |