#include "filter.h"
#include "libinput-private.h"
-#define DEFAULT_AXIS_STEP_DISTANCE 10
+#define DEFAULT_WHEEL_CLICK_ANGLE 15
#define DEFAULT_MIDDLE_BUTTON_SCROLL_TIMEOUT 200
-/* The HW DPI rate we normalize to before calculating pointer acceleration */
-#define DEFAULT_MOUSE_DPI 400
enum evdev_key_type {
EVDEV_KEY_TYPE_NONE,
device->buttons.change_to_left_handed(device);
if (state == LIBINPUT_BUTTON_STATE_RELEASED &&
- device->scroll.change_scroll_mode)
- device->scroll.change_scroll_mode(device);
+ device->scroll.change_scroll_method)
+ device->scroll.change_scroll_method(device);
}
}
{
struct libinput *libinput = device->base.seat->libinput;
struct motion_params motion;
+ double dx_unaccel, dy_unaccel;
int32_t cx, cy;
int32_t x, y;
int slot;
case EVDEV_NONE:
return;
case EVDEV_RELATIVE_MOTION:
- motion.dx = device->rel.dx / ((double)device->dpi / DEFAULT_MOUSE_DPI);
- motion.dy = device->rel.dy / ((double)device->dpi / DEFAULT_MOUSE_DPI);
+ dx_unaccel = device->rel.dx / ((double) device->dpi /
+ DEFAULT_MOUSE_DPI);
+ dy_unaccel = device->rel.dy / ((double) device->dpi /
+ DEFAULT_MOUSE_DPI);
device->rel.dx = 0;
device->rel.dy = 0;
/* Use unaccelerated deltas for pointing stick scroll */
- if (device->scroll.mode == LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN &&
+ if (device->scroll.method == LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN &&
hw_is_key_down(device, device->scroll.button)) {
if (device->scroll.button_scroll_active)
evdev_post_scroll(device, time,
- motion.dx, motion.dy);
+ LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS,
+ dx_unaccel, dy_unaccel);
break;
}
/* Apply pointer acceleration. */
+ motion.dx = dx_unaccel;
+ motion.dy = dy_unaccel;
filter_dispatch(device->pointer.filter, &motion, device, time);
- if (motion.dx == 0.0 && motion.dy == 0.0)
+ if (motion.dx == 0.0 && motion.dy == 0.0 &&
+ dx_unaccel == 0.0 && dy_unaccel == 0.0) {
break;
+ }
- pointer_notify_motion(base, time, motion.dx, motion.dy);
+ pointer_notify_motion(base, time,
+ motion.dx, motion.dy,
+ dx_unaccel, dy_unaccel);
break;
case EVDEV_ABSOLUTE_MT_DOWN:
if (!(device->seat_caps & EVDEV_DEVICE_TOUCH))
if (device->mt.slots[slot].seat_slot != -1) {
log_bug_kernel(libinput,
"%s: Driver sent multiple touch down for the "
- "same slot", device->devnode);
+ "same slot",
+ udev_device_get_devnode(device->udev_device));
break;
}
if (device->abs.seat_slot != -1) {
log_bug_kernel(libinput,
"%s: Driver sent multiple touch down for the "
- "same slot", device->devnode);
+ "same slot",
+ udev_device_get_devnode(device->udev_device));
break;
}
} else {
libinput_timer_cancel(&device->scroll.timer);
if (device->scroll.button_scroll_active) {
- evdev_stop_scroll(device, time);
+ evdev_stop_scroll(device, time,
+ LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS);
device->scroll.button_scroll_active = false;
} else {
/* If the button is released quickly enough emit the
LIBINPUT_KEY_STATE_RELEASED);
break;
case EVDEV_KEY_TYPE_BUTTON:
- if (device->scroll.mode == LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN &&
+ if (device->scroll.method == LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN &&
e->code == device->scroll.button) {
evdev_button_scroll_button(device, time, e->value);
break;
}
}
+static void
+evdev_notify_axis(struct evdev_device *device,
+ uint64_t time,
+ uint32_t axes,
+ enum libinput_pointer_axis_source source,
+ double x, double y)
+{
+ if (device->scroll.natural_scrolling_enabled) {
+ x *= -1;
+ y *= -1;
+ }
+
+ pointer_notify_axis(&device->base,
+ time,
+ axes,
+ source,
+ x, y);
+}
+
static inline void
evdev_process_relative(struct evdev_device *device,
struct input_event *e, uint64_t time)
{
- struct libinput_device *base = &device->base;
-
switch (e->code) {
case REL_X:
if (device->pending_event != EVDEV_RELATIVE_MOTION)
break;
case REL_WHEEL:
evdev_flush_pending_event(device, time);
- pointer_notify_axis(
- base,
+ evdev_notify_axis(
+ device,
time,
- LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
- -1 * e->value * DEFAULT_AXIS_STEP_DISTANCE);
+ AS_MASK(LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL),
+ LIBINPUT_POINTER_AXIS_SOURCE_WHEEL,
+ 0,
+ -1 * e->value * device->scroll.wheel_click_angle);
break;
case REL_HWHEEL:
evdev_flush_pending_event(device, time);
- pointer_notify_axis(
- base,
+ evdev_notify_axis(
+ device,
time,
- LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
- e->value * DEFAULT_AXIS_STEP_DISTANCE);
+ AS_MASK(LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL),
+ LIBINPUT_POINTER_AXIS_SOURCE_WHEEL,
+ e->value * device->scroll.wheel_click_angle,
+ 0);
break;
}
}
struct evdev_dispatch_interface fallback_interface = {
fallback_process,
+ NULL, /* remove */
fallback_destroy,
NULL, /* device_added */
NULL, /* device_removed */
}
static uint32_t
-evdev_scroll_get_modes(struct libinput_device *device)
+evdev_scroll_get_methods(struct libinput_device *device)
{
return LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
}
static void
-evdev_change_scroll_mode(struct evdev_device *device)
+evdev_change_scroll_method(struct evdev_device *device)
{
- if (device->scroll.want_mode == device->scroll.mode &&
+ if (device->scroll.want_method == device->scroll.method &&
device->scroll.want_button == device->scroll.button)
return;
if (evdev_any_button_down(device))
return;
- device->scroll.mode = device->scroll.want_mode;
+ device->scroll.method = device->scroll.want_method;
device->scroll.button = device->scroll.want_button;
}
static enum libinput_config_status
-evdev_scroll_set_mode(struct libinput_device *device,
- enum libinput_config_scroll_mode mode)
+evdev_scroll_set_method(struct libinput_device *device,
+ enum libinput_config_scroll_method method)
{
struct evdev_device *evdev = (struct evdev_device*)device;
- evdev->scroll.want_mode = mode;
- evdev->scroll.change_scroll_mode(evdev);
+ evdev->scroll.want_method = method;
+ evdev->scroll.change_scroll_method(evdev);
return LIBINPUT_CONFIG_STATUS_SUCCESS;
}
-static enum libinput_config_scroll_mode
-evdev_scroll_get_mode(struct libinput_device *device)
+static enum libinput_config_scroll_method
+evdev_scroll_get_method(struct libinput_device *device)
{
struct evdev_device *evdev = (struct evdev_device *)device;
/* return the wanted configuration, even if it hasn't taken
* effect yet! */
- return evdev->scroll.want_mode;
+ return evdev->scroll.want_method;
}
-static enum libinput_config_scroll_mode
-evdev_scroll_get_default_mode(struct libinput_device *device)
+static enum libinput_config_scroll_method
+evdev_scroll_get_default_method(struct libinput_device *device)
{
struct evdev_device *evdev = (struct evdev_device *)device;
struct evdev_device *evdev = (struct evdev_device*)device;
evdev->scroll.want_button = button;
- evdev->scroll.change_scroll_mode(evdev);
+ evdev->scroll.change_scroll_method(evdev);
return LIBINPUT_CONFIG_STATUS_SUCCESS;
}
static int
evdev_init_button_scroll(struct evdev_device *device,
- void (*change_scroll_mode)(struct evdev_device *))
+ void (*change_scroll_method)(struct evdev_device *))
{
libinput_timer_init(&device->scroll.timer, device->base.seat->libinput,
evdev_button_scroll_timeout, device);
- device->scroll.config.get_modes = evdev_scroll_get_modes;
- device->scroll.config.set_mode = evdev_scroll_set_mode;
- device->scroll.config.get_mode = evdev_scroll_get_mode;
- device->scroll.config.get_default_mode = evdev_scroll_get_default_mode;
+ device->scroll.config.get_methods = evdev_scroll_get_methods;
+ device->scroll.config.set_method = evdev_scroll_set_method;
+ device->scroll.config.get_method = evdev_scroll_get_method;
+ device->scroll.config.get_default_method = evdev_scroll_get_default_method;
device->scroll.config.set_button = evdev_scroll_set_button;
device->scroll.config.get_button = evdev_scroll_get_button;
device->scroll.config.get_default_button = evdev_scroll_get_default_button;
- device->base.config.scroll_mode = &device->scroll.config;
- device->scroll.mode = evdev_scroll_get_default_mode((struct libinput_device *)device);
- device->scroll.want_mode = device->scroll.mode;
+ device->base.config.scroll_method = &device->scroll.config;
+ device->scroll.method = evdev_scroll_get_default_method((struct libinput_device *)device);
+ device->scroll.want_method = device->scroll.method;
device->scroll.button = evdev_scroll_get_default_button((struct libinput_device *)device);
device->scroll.want_button = device->scroll.button;
- device->scroll.change_scroll_mode = change_scroll_mode;
+ device->scroll.change_scroll_method = change_scroll_method;
return 0;
}
if (evdev_device->scroll.want_button &&
evdev_init_button_scroll(evdev_device,
- evdev_change_scroll_mode) == -1) {
+ evdev_change_scroll_method) == -1) {
free(dispatch);
return NULL;
}
+ if (evdev_device->scroll.natural_scrolling_enabled)
+ evdev_init_natural_scroll(evdev_device);
+
evdev_init_calibration(evdev_device, dispatch);
evdev_init_sendevents(evdev_device, dispatch);
static void
evdev_tag_device(struct evdev_device *device)
{
- struct udev *udev;
- struct udev_device *udev_device = NULL;
+ if (device->dispatch->interface->tag_device)
+ device->dispatch->interface->tag_device(device,
+ device->udev_device);
+}
- udev = udev_new();
- if (!udev)
- return;
+static inline int
+evdev_read_wheel_click_prop(struct evdev_device *device)
+{
+ struct libinput *libinput = device->base.seat->libinput;
+ const char *prop;
+ int angle = DEFAULT_WHEEL_CLICK_ANGLE;
+
+ prop = udev_device_get_property_value(device->udev_device,
+ "MOUSE_WHEEL_CLICK_ANGLE");
+ if (prop) {
+ angle = parse_mouse_wheel_click_angle_property(prop);
+ if (!angle) {
+ log_error(libinput,
+ "Mouse wheel click angle '%s' is present but invalid,"
+ "using %d degrees instead\n",
+ device->devname,
+ DEFAULT_WHEEL_CLICK_ANGLE);
+ angle = DEFAULT_WHEEL_CLICK_ANGLE;
+ }
+ }
- udev_device = udev_device_new_from_syspath(udev, device->syspath);
- if (udev_device) {
- if (device->dispatch->interface->tag_device)
- device->dispatch->interface->tag_device(device, udev_device);
- udev_device_unref(udev_device);
+ return angle;
+}
+static inline int
+evdev_read_dpi_prop(struct evdev_device *device)
+{
+ struct libinput *libinput = device->base.seat->libinput;
+ const char *mouse_dpi;
+ int dpi = DEFAULT_MOUSE_DPI;
+
+ mouse_dpi = udev_device_get_property_value(device->udev_device,
+ "MOUSE_DPI");
+ if (mouse_dpi) {
+ dpi = parse_mouse_dpi_property(mouse_dpi);
+ if (!dpi) {
+ log_error(libinput, "Mouse DPI property for '%s' is "
+ "present but invalid, using %d "
+ "DPI instead\n",
+ device->devname,
+ DEFAULT_MOUSE_DPI);
+ dpi = DEFAULT_MOUSE_DPI;
+ }
}
- udev_unref(udev);
+
+ return dpi;
}
static inline int
int active_slot;
int slot;
unsigned int i;
+ const char *devnode = udev_device_get_devnode(device->udev_device);
has_rel = 0;
has_abs = 0;
has_keyboard = 0;
has_touch = 0;
+ for (i = BTN_JOYSTICK; i < BTN_DIGI; i++) {
+ if (libevdev_has_event_code(evdev, EV_KEY, i)) {
+ log_info(libinput,
+ "input device '%s', %s is a joystick, ignoring\n",
+ device->devname, devnode);
+ return -1;
+ }
+ }
+
if (libevdev_has_event_type(evdev, EV_ABS)) {
if ((absinfo = libevdev_get_abs_info(evdev, ABS_X))) {
device->dispatch = evdev_mt_touchpad_create(device);
log_info(libinput,
"input device '%s', %s is a touchpad\n",
- device->devname, device->devnode);
+ device->devname, devnode);
return device->dispatch == NULL ? -1 : 0;
}
log_info(libinput,
"input device '%s', %s is a pointer caps =%s%s%s\n",
- device->devname, device->devnode,
+ device->devname, devnode,
has_abs ? " absolute-motion" : "",
has_rel ? " relative-motion": "",
has_button ? " button" : "");
/* want left-handed config option */
device->buttons.want_left_handed = true;
+ /* want natural-scroll config option */
+ device->scroll.natural_scrolling_enabled = true;
}
if (has_rel && has_button) {
device->seat_caps |= EVDEV_DEVICE_KEYBOARD;
log_info(libinput,
"input device '%s', %s is a keyboard\n",
- device->devname, device->devnode);
+ device->devname, devnode);
}
if (has_touch && !has_button) {
device->seat_caps |= EVDEV_DEVICE_TOUCH;
log_info(libinput,
"input device '%s', %s is a touch device\n",
- device->devname, device->devnode);
+ device->devname, devnode);
}
return 0;
notify_added_device(&device->base);
}
+static int
+evdev_device_compare_syspath(struct udev_device *udev_device, int fd)
+{
+ struct udev *udev = udev_device_get_udev(udev_device);
+ struct udev_device *udev_device_new = NULL;
+ struct stat st;
+ int rc = 1;
+
+ if (fstat(fd, &st) < 0)
+ goto out;
+
+ udev_device_new = udev_device_new_from_devnum(udev, 'c', st.st_rdev);
+ if (!udev_device_new)
+ goto out;
+
+ rc = strcmp(udev_device_get_syspath(udev_device_new),
+ udev_device_get_syspath(udev_device));
+out:
+ if (udev_device_new)
+ udev_device_unref(udev_device_new);
+ return rc;
+}
+
struct evdev_device *
evdev_device_create(struct libinput_seat *seat,
- const char *devnode,
- const char *sysname,
- const char *syspath)
+ struct udev_device *udev_device)
{
struct libinput *libinput = seat->libinput;
- struct evdev_device *device;
+ struct evdev_device *device = NULL;
int rc;
int fd;
int unhandled_device = 0;
+ const char *devnode = udev_device_get_devnode(udev_device);
/* Use non-blocking mode so that we can loop on read on
* evdev_device_data() until all events on the fd are
return NULL;
}
+ if (evdev_device_compare_syspath(udev_device, fd) != 0)
+ goto err;
+
device = zalloc(sizeof *device);
if (device == NULL)
- return NULL;
+ goto err;
libinput_device_init(&device->base, seat);
libinput_seat_ref(seat);
device->seat_caps = 0;
device->is_mt = 0;
device->mtdev = NULL;
- device->devnode = strdup(devnode);
- device->sysname = strdup(sysname);
- device->syspath = strdup(syspath);
+ device->udev_device = udev_device_ref(udev_device);
device->rel.dx = 0;
device->rel.dy = 0;
device->abs.seat_slot = -1;
device->devname = libevdev_get_name(device->evdev);
device->scroll.threshold = 5.0; /* Default may be overridden */
device->scroll.direction = 0;
- device->dpi = DEFAULT_MOUSE_DPI;
+ device->scroll.wheel_click_angle =
+ evdev_read_wheel_click_prop(device);
+ device->dpi = evdev_read_dpi_prop(device);
/* at most 5 SYN_DROPPED log-messages per 30s */
ratelimit_init(&device->syn_drop_limit, 30ULL * 1000, 5);
err:
if (fd >= 0)
close_restricted(libinput, fd);
- evdev_device_destroy(device);
+ if (device)
+ evdev_device_destroy(device);
return unhandled_device ? EVDEV_UNHANDLED_DEVICE : NULL;
}
-int
-evdev_device_get_keys(struct evdev_device *device, char *keys, size_t size)
-{
- memset(keys, 0, size);
- return 0;
-}
-
const char *
evdev_device_get_output(struct evdev_device *device)
{
const char *
evdev_device_get_sysname(struct evdev_device *device)
{
- return device->sysname;
+ return udev_device_get_sysname(device->udev_device);
}
const char *
return libevdev_get_id_vendor(device->evdev);
}
+struct udev_device *
+evdev_device_get_udev_device(struct evdev_device *device)
+{
+ return udev_device_ref(device->udev_device);
+}
+
void
evdev_device_set_default_calibration(struct evdev_device *device,
const float calibration[6])
assert(axis == LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL ||
axis == LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
- return (device->scroll.direction & (1 << axis)) != 0;
+ return (device->scroll.direction & AS_MASK(axis)) != 0;
}
static inline void
assert(axis == LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL ||
axis == LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
- device->scroll.direction |= (1 << axis);
+ device->scroll.direction |= AS_MASK(axis);
}
void
evdev_post_scroll(struct evdev_device *device,
uint64_t time,
+ enum libinput_pointer_axis_source source,
double dx,
double dy)
{
double trigger_horiz, trigger_vert;
- if (device->scroll.natural_scrolling_enabled) {
- dx = -dx;
- dy = -dy;
- }
-
if (!evdev_is_scrolling(device,
LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))
device->scroll.buildup_vertical += dy;
/* We use the trigger to enable, but the delta from this event for
* the actual scroll movement. Otherwise we get a jump once
* scrolling engages */
- if (dy != 0.0 &&
- evdev_is_scrolling(device,
- LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL)) {
- pointer_notify_axis(&device->base,
- time,
- LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
- dy);
- }
+ if (!evdev_is_scrolling(device,
+ LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))
+ dy = 0.0;
+ if (!evdev_is_scrolling(device,
+ LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL))
+ dx = 0.0;
- if (dx != 0.0 &&
- evdev_is_scrolling(device,
- LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)) {
- pointer_notify_axis(&device->base,
- time,
- LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
- dx);
- }
+ if (dx != 0.0 || dy != 0.0)
+ evdev_notify_axis(device,
+ time,
+ device->scroll.direction,
+ source,
+ dx,
+ dy);
}
void
-evdev_stop_scroll(struct evdev_device *device, uint64_t time)
+evdev_stop_scroll(struct evdev_device *device,
+ uint64_t time,
+ enum libinput_pointer_axis_source source)
{
/* terminate scrolling with a zero scroll event */
- if (device->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))
+ if (device->scroll.direction != 0)
pointer_notify_axis(&device->base,
time,
- LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
- 0);
- if (device->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL))
- pointer_notify_axis(&device->base,
- time,
- LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
- 0);
+ device->scroll.direction,
+ source,
+ 0.0, 0.0);
device->scroll.buildup_horizontal = 0;
device->scroll.buildup_vertical = 0;
return 0;
}
-static int
-evdev_device_compare_syspath(struct evdev_device *device, int fd)
-{
- struct udev *udev = NULL;
- struct udev_device *udev_device = NULL;
- const char *syspath;
- struct stat st;
- int rc = 1;
-
- udev = udev_new();
- if (!udev)
- goto out;
-
- if (fstat(fd, &st) < 0)
- goto out;
-
- udev_device = udev_device_new_from_devnum(udev, 'c', st.st_rdev);
- if (!device)
- goto out;
-
- syspath = udev_device_get_syspath(udev_device);
- rc = strcmp(syspath, device->syspath);
-out:
- if (udev_device)
- udev_device_unref(udev_device);
- if (udev)
- udev_unref(udev);
- return rc;
-}
-
int
evdev_device_resume(struct evdev_device *device)
{
struct libinput *libinput = device->base.seat->libinput;
int fd;
+ const char *devnode;
+ struct input_event ev;
+ enum libevdev_read_status status;
if (device->fd != -1)
return 0;
- if (device->syspath == NULL)
+ if (device->was_removed)
return -ENODEV;
- fd = open_restricted(libinput, device->devnode, O_RDWR | O_NONBLOCK);
+ devnode = udev_device_get_devnode(device->udev_device);
+ fd = open_restricted(libinput, devnode, O_RDWR | O_NONBLOCK);
if (fd < 0)
return -errno;
- if (evdev_device_compare_syspath(device, fd)) {
+ if (evdev_device_compare_syspath(device->udev_device, fd)) {
close_restricted(libinput, fd);
return -ENODEV;
}
return -ENODEV;
}
+ libevdev_change_fd(device->evdev, fd);
+ libevdev_set_clock_id(device->evdev, CLOCK_MONOTONIC);
+
+ /* re-sync libevdev's view of the device, but discard the actual
+ events. Our device is in a neutral state already */
+ libevdev_next_event(device->evdev,
+ LIBEVDEV_READ_FLAG_FORCE_SYNC,
+ &ev);
+ do {
+ status = libevdev_next_event(device->evdev,
+ LIBEVDEV_READ_FLAG_SYNC,
+ &ev);
+ } while (status == LIBEVDEV_READ_STATUS_SYNC);
+
device->source =
libinput_add_fd(libinput, fd, evdev_device_dispatch, device);
if (!device->source) {
struct libinput_device *dev;
list_for_each(dev, &device->base.seat->devices_list, link) {
- struct evdev_device *d = (struct evdev_device*)dev;;
+ struct evdev_device *d = (struct evdev_device*)dev;
if (dev == &device->base)
continue;
evdev_device_suspend(device);
- /* A device may be removed while suspended. Free the syspath to
+ if (device->dispatch->interface->remove)
+ device->dispatch->interface->remove(device->dispatch);
+
+ /* A device may be removed while suspended, mark it to
* skip re-opening a different device with the same node */
- free(device->syspath);
- device->syspath = NULL;
+ device->was_removed = true;
list_remove(&device->base.link);
filter_destroy(device->pointer.filter);
libinput_seat_unref(device->base.seat);
libevdev_free(device->evdev);
+ udev_device_unref(device->udev_device);
free(device->mt.slots);
- free(device->devnode);
- free(device->sysname);
- free(device->syspath);
free(device);
}