#include "config.h"
#include <errno.h>
+#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "linux/input.h"
#include "libinput-private.h"
#define DEFAULT_AXIS_STEP_DISTANCE 10
+#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,
down_count = update_key_down_count(device, button, state);
if ((state == LIBINPUT_BUTTON_STATE_PRESSED && down_count == 1) ||
- (state == LIBINPUT_BUTTON_STATE_RELEASED && down_count == 0))
+ (state == LIBINPUT_BUTTON_STATE_RELEASED && down_count == 0)) {
pointer_notify_button(&device->base, time, button, state);
+
+ if (state == LIBINPUT_BUTTON_STATE_RELEASED &&
+ device->buttons.change_to_left_handed)
+ device->buttons.change_to_left_handed(device);
+ }
+
}
void
case EVDEV_NONE:
return;
case EVDEV_RELATIVE_MOTION:
- motion.dx = device->rel.dx;
- motion.dy = device->rel.dy;
+ motion.dx = device->rel.dx / ((double)device->dpi / DEFAULT_MOUSE_DPI);
+ motion.dy = 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.has_middle_button_scroll &&
+ hw_is_key_down(device, BTN_MIDDLE)) {
+ if (device->scroll.middle_button_scroll_active)
+ evdev_post_scroll(device, time,
+ motion.dx, motion.dy);
+ break;
+ }
+
/* Apply pointer acceleration. */
filter_dispatch(device->pointer.filter, &motion, device, time);
}
static void
+evdev_middle_button_scroll_timeout(uint64_t time, void *data)
+{
+ struct evdev_device *device = data;
+
+ device->scroll.middle_button_scroll_active = true;
+}
+
+static void
+evdev_middle_button_scroll_button(struct evdev_device *device,
+ uint64_t time, int is_press)
+{
+ if (is_press) {
+ libinput_timer_set(&device->scroll.timer,
+ time + DEFAULT_MIDDLE_BUTTON_SCROLL_TIMEOUT);
+ } else {
+ libinput_timer_cancel(&device->scroll.timer);
+ if (device->scroll.middle_button_scroll_active) {
+ evdev_stop_scroll(device, time);
+ device->scroll.middle_button_scroll_active = false;
+ } else {
+ /* If the button is released quickly enough emit the
+ * button press/release events. */
+ evdev_pointer_notify_button(device, time, BTN_MIDDLE,
+ LIBINPUT_BUTTON_STATE_PRESSED);
+ evdev_pointer_notify_button(device, time, BTN_MIDDLE,
+ LIBINPUT_BUTTON_STATE_RELEASED);
+ }
+ }
+}
+
+static void
evdev_process_touch_button(struct evdev_device *device,
uint64_t time, int value)
{
LIBINPUT_KEY_STATE_RELEASED);
break;
case EVDEV_KEY_TYPE_BUTTON:
+ if (device->scroll.has_middle_button_scroll &&
+ e->code == BTN_MIDDLE) {
+ evdev_middle_button_scroll_button(device, time,
+ e->value);
+ break;
+ }
evdev_pointer_notify_button(
device,
time,
- e->code,
+ evdev_to_left_handed(device, e->code),
e->value ? LIBINPUT_BUTTON_STATE_PRESSED :
LIBINPUT_BUTTON_STATE_RELEASED);
break;
}
}
-static inline int
+static inline bool
evdev_need_touch_frame(struct evdev_device *device)
{
if (!(device->seat_caps & EVDEV_DEVICE_TOUCH))
- return 0;
+ return false;
switch (device->pending_event) {
case EVDEV_NONE:
case EVDEV_ABSOLUTE_TOUCH_DOWN:
case EVDEV_ABSOLUTE_TOUCH_UP:
case EVDEV_ABSOLUTE_MOTION:
- return 1;
+ return true;
}
- return 0;
+ return false;
+}
+
+static void
+evdev_tag_external_mouse(struct evdev_device *device,
+ struct udev_device *udev_device)
+{
+ int bustype;
+
+ bustype = libevdev_get_id_bustype(device->evdev);
+ if (bustype == BUS_USB || bustype == BUS_BLUETOOTH) {
+ if (device->seat_caps & EVDEV_DEVICE_POINTER)
+ device->tags |= EVDEV_TAG_EXTERNAL_MOUSE;
+ }
+}
+
+static void
+evdev_tag_trackpoint(struct evdev_device *device,
+ struct udev_device *udev_device)
+{
+ if (libevdev_has_property(device->evdev, INPUT_PROP_POINTING_STICK))
+ device->tags |= EVDEV_TAG_TRACKPOINT;
}
static void
struct input_event *event,
uint64_t time)
{
- int need_frame = 0;
+ bool need_frame = false;
switch (event->type) {
case EV_REL:
free(dispatch);
}
+static void
+fallback_tag_device(struct evdev_device *device,
+ struct udev_device *udev_device)
+{
+ evdev_tag_external_mouse(device, udev_device);
+ evdev_tag_trackpoint(device, udev_device);
+}
+
static int
evdev_calibration_has_matrix(struct libinput_device *libinput_device)
{
struct evdev_dispatch_interface fallback_interface = {
fallback_process,
- fallback_destroy
+ fallback_destroy,
+ NULL, /* device_added */
+ NULL, /* device_removed */
+ NULL, /* device_suspended */
+ NULL, /* device_resumed */
+ fallback_tag_device,
};
static uint32_t
return LIBINPUT_CONFIG_SEND_EVENTS_ENABLED;
}
+static int
+evdev_left_handed_has(struct libinput_device *device)
+{
+ /* This is only hooked up when we have left-handed configuration, so we
+ * can hardcode 1 here */
+ return 1;
+}
+
+static void
+evdev_change_to_left_handed(struct evdev_device *device)
+{
+ unsigned int button;
+
+ if (device->buttons.want_left_handed == device->buttons.left_handed)
+ return;
+
+ for (button = BTN_LEFT; button < BTN_JOYSTICK; button++) {
+ if (libevdev_has_event_code(device->evdev, EV_KEY, button) &&
+ hw_is_key_down(device, button))
+ return;
+ }
+
+ device->buttons.left_handed = device->buttons.want_left_handed;
+}
+
+static enum libinput_config_status
+evdev_left_handed_set(struct libinput_device *device, int left_handed)
+{
+ struct evdev_device *evdev_device = (struct evdev_device *)device;
+
+ evdev_device->buttons.want_left_handed = left_handed ? true : false;
+
+ evdev_device->buttons.change_to_left_handed(evdev_device);
+
+ return LIBINPUT_CONFIG_STATUS_SUCCESS;
+}
+
+static int
+evdev_left_handed_get(struct libinput_device *device)
+{
+ struct evdev_device *evdev_device = (struct evdev_device *)device;
+
+ /* return the wanted configuration, even if it hasn't taken
+ * effect yet! */
+ return evdev_device->buttons.want_left_handed;
+}
+
+static int
+evdev_left_handed_get_default(struct libinput_device *device)
+{
+ return 0;
+}
+
+int
+evdev_init_left_handed(struct evdev_device *device,
+ void (*change_to_left_handed)(struct evdev_device *))
+{
+ device->buttons.config_left_handed.has = evdev_left_handed_has;
+ device->buttons.config_left_handed.set = evdev_left_handed_set;
+ device->buttons.config_left_handed.get = evdev_left_handed_get;
+ device->buttons.config_left_handed.get_default = evdev_left_handed_get_default;
+ device->base.config.left_handed = &device->buttons.config_left_handed;
+ device->buttons.left_handed = false;
+ device->buttons.want_left_handed = false;
+ device->buttons.change_to_left_handed = change_to_left_handed;
+
+ return 0;
+}
+
static struct evdev_dispatch *
fallback_dispatch_create(struct libinput_device *device)
{
struct evdev_dispatch *dispatch = zalloc(sizeof *dispatch);
+ struct evdev_device *evdev_device = (struct evdev_device *)device;
+
if (dispatch == NULL)
return NULL;
dispatch->interface = &fallback_interface;
+ if (evdev_device->buttons.want_left_handed &&
+ evdev_init_left_handed(evdev_device,
+ evdev_change_to_left_handed) == -1) {
+ free(dispatch);
+ return NULL;
+ }
+
device->config.calibration = &dispatch->calibration;
dispatch->calibration.has_matrix = evdev_calibration_has_matrix;
rc = libevdev_next_event(device->evdev,
LIBEVDEV_READ_FLAG_NORMAL, &ev);
if (rc == LIBEVDEV_READ_STATUS_SYNC) {
+ if (device->syn_drops_received < 10) {
+ device->syn_drops_received++;
+ log_info(libinput, "SYN_DROPPED event from "
+ "\"%s\" - some input events have "
+ "been lost.\n", device->devname);
+ if (device->syn_drops_received == 10)
+ log_info(libinput, "No longer logging "
+ "SYN_DROPPED events for "
+ "\"%s\"\n", device->devname);
+ }
+
/* send one more sync event so we handle all
currently pending events before we sync up
to the current state */
}
static int
-configure_pointer_acceleration(struct evdev_device *device)
+evdev_accel_config_available(struct libinput_device *device)
+{
+ /* this function is only called if we set up ptraccel, so we can
+ reply with a resounding "Yes" */
+ return 1;
+}
+
+static enum libinput_config_status
+evdev_accel_config_set_speed(struct libinput_device *device, double speed)
+{
+ struct evdev_device *dev = (struct evdev_device *)device;
+
+ if (!filter_set_speed(dev->pointer.filter, speed))
+ return LIBINPUT_CONFIG_STATUS_INVALID;
+
+ return LIBINPUT_CONFIG_STATUS_SUCCESS;
+}
+
+static double
+evdev_accel_config_get_speed(struct libinput_device *device)
+{
+ struct evdev_device *dev = (struct evdev_device *)device;
+
+ return filter_get_speed(dev->pointer.filter);
+}
+
+static double
+evdev_accel_config_get_default_speed(struct libinput_device *device)
+{
+ return 0.0;
+}
+
+int
+evdev_device_init_pointer_acceleration(struct evdev_device *device)
{
device->pointer.filter =
- create_pointer_accelator_filter(
- pointer_accel_profile_smooth_simple);
+ create_pointer_accelerator_filter(
+ pointer_accel_profile_linear);
if (!device->pointer.filter)
return -1;
+ device->pointer.config.available = evdev_accel_config_available;
+ device->pointer.config.set_speed = evdev_accel_config_set_speed;
+ device->pointer.config.get_speed = evdev_accel_config_get_speed;
+ device->pointer.config.get_default_speed = evdev_accel_config_get_default_speed;
+ device->base.config.accel = &device->pointer.config;
+
return 0;
}
+
static inline int
evdev_need_mtdev(struct evdev_device *device)
{
!libevdev_has_event_code(evdev, EV_ABS, ABS_MT_SLOT));
}
+static void
+evdev_tag_device(struct evdev_device *device)
+{
+ struct udev *udev;
+ struct udev_device *udev_device = NULL;
+
+ udev = udev_new();
+ if (!udev)
+ return;
+
+ 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);
+ }
+ udev_unref(udev);
+}
+
static int
evdev_configure_device(struct evdev_device *device)
{
device->mt.slot = active_slot;
}
}
+
+ if (libevdev_has_property(evdev, INPUT_PROP_POINTING_STICK)) {
+ libinput_timer_init(&device->scroll.timer,
+ device->base.seat->libinput,
+ evdev_middle_button_scroll_timeout,
+ device);
+ device->scroll.has_middle_button_scroll = true;
+ }
+
if (libevdev_has_event_code(evdev, EV_REL, REL_X) ||
libevdev_has_event_code(evdev, EV_REL, REL_Y))
has_rel = 1;
has_keyboard = 1;
if ((has_abs || has_rel) && has_button) {
- if (configure_pointer_acceleration(device) == -1)
+ if (evdev_device_init_pointer_acceleration(device) == -1)
return -1;
device->seat_caps |= EVDEV_DEVICE_POINTER;
has_abs ? " absolute-motion" : "",
has_rel ? " relative-motion": "",
has_button ? " button" : "");
+
+ /* want left-handed config option */
+ device->buttons.want_left_handed = true;
}
if (has_keyboard) {
device->seat_caps |= EVDEV_DEVICE_KEYBOARD;
return 0;
}
+static void
+evdev_notify_added_device(struct evdev_device *device)
+{
+ struct libinput_device *dev;
+
+ list_for_each(dev, &device->base.seat->devices_list, link) {
+ struct evdev_device *d = (struct evdev_device*)dev;
+ if (dev == &device->base)
+ continue;
+
+ /* Notify existing device d about addition of device device */
+ if (d->dispatch->interface->device_added)
+ d->dispatch->interface->device_added(d, device);
+
+ /* Notify new device device about existing device d */
+ if (device->dispatch->interface->device_added)
+ device->dispatch->interface->device_added(device, d);
+
+ /* Notify new device device if existing device d is suspended */
+ if (d->suspended && device->dispatch->interface->device_suspended)
+ device->dispatch->interface->device_suspended(device, d);
+ }
+
+ notify_added_device(&device->base);
+}
+
struct evdev_device *
evdev_device_create(struct libinput_seat *seat,
const char *devnode,
device->fd = fd;
device->pending_event = EVDEV_NONE;
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;
matrix_init_identity(&device->abs.calibration);
matrix_init_identity(&device->abs.usermatrix);
goto err;
list_insert(seat->devices_list.prev, &device->base.link);
- notify_added_device(&device->base);
+
+ evdev_tag_device(device);
+ evdev_notify_added_device(device);
return device;
return 0;
}
+void
+evdev_post_scroll(struct evdev_device *device,
+ uint64_t time,
+ double dx,
+ double dy)
+{
+ if (dy <= -device->scroll.threshold || dy >= device->scroll.threshold)
+ device->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
+
+ if (dx <= -device->scroll.threshold || dx >= device->scroll.threshold)
+ device->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
+
+ if (dy != 0.0 &&
+ (device->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))) {
+ pointer_notify_axis(&device->base,
+ time,
+ LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
+ dy);
+ }
+
+ if (dx != 0.0 &&
+ (device->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL))) {
+ pointer_notify_axis(&device->base,
+ time,
+ LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
+ dx);
+ }
+}
+
+void
+evdev_stop_scroll(struct evdev_device *device, uint64_t time)
+{
+ /* terminate scrolling with a zero scroll event */
+ if (device->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))
+ 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 = 0;
+}
+
static void
release_pressed_keys(struct evdev_device *device)
{
evdev_pointer_notify_button(
device,
time,
- code,
+ evdev_to_left_handed(device, code),
LIBINPUT_BUTTON_STATE_RELEASED);
break;
}
}
}
+void
+evdev_notify_suspended_device(struct evdev_device *device)
+{
+ struct libinput_device *it;
+
+ if (device->suspended)
+ return;
+
+ list_for_each(it, &device->base.seat->devices_list, link) {
+ struct evdev_device *d = (struct evdev_device*)it;
+ if (it == &device->base)
+ continue;
+
+ if (d->dispatch->interface->device_suspended)
+ d->dispatch->interface->device_suspended(d, device);
+ }
+
+ device->suspended = 1;
+}
+
+void
+evdev_notify_resumed_device(struct evdev_device *device)
+{
+ struct libinput_device *it;
+
+ if (!device->suspended)
+ return;
+
+ list_for_each(it, &device->base.seat->devices_list, link) {
+ struct evdev_device *d = (struct evdev_device*)it;
+ if (it == &device->base)
+ continue;
+
+ if (d->dispatch->interface->device_resumed)
+ d->dispatch->interface->device_resumed(d, device);
+ }
+
+ device->suspended = 0;
+}
+
int
evdev_device_suspend(struct evdev_device *device)
{
+ evdev_notify_suspended_device(device);
+
if (device->source) {
libinput_remove_source(device->base.seat->libinput,
device->source);
memset(device->hw_key_mask, 0, sizeof(device->hw_key_mask));
+ evdev_notify_resumed_device(device);
+
return 0;
}
void
evdev_device_remove(struct evdev_device *device)
{
+ struct libinput_device *dev;
+
+ list_for_each(dev, &device->base.seat->devices_list, link) {
+ struct evdev_device *d = (struct evdev_device*)dev;;
+ if (dev == &device->base)
+ continue;
+
+ if (d->dispatch->interface->device_removed)
+ d->dispatch->interface->device_removed(d, device);
+ }
+
evdev_device_suspend(device);
/* A device may be removed while suspended. Free the syspath to
projects / platform / upstream / libinput.git / blobdiff