#include <assert.h>
#include <math.h>
#include <stdbool.h>
+#include <limits.h>
#include "evdev-mt-touchpad.h"
-#define DEFAULT_CONSTANT_ACCEL_NUMERATOR 100
-#define DEFAULT_MIN_ACCEL_FACTOR 0.20
-#define DEFAULT_MAX_ACCEL_FACTOR 0.40
+#define DEFAULT_ACCEL_NUMERATOR 1200.0
#define DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR 700.0
static inline int
if (diff > margin)
return center + diff - margin;
- else if (diff < -margin)
+ else
return center + diff + margin;
- return center + diff;
-}
-
-static double
-tp_accel_profile(struct motion_filter *filter,
- void *data,
- double velocity,
- uint64_t time)
-{
- struct tp_dispatch *tp =
- (struct tp_dispatch *) data;
-
- double accel_factor;
-
- accel_factor = velocity * tp->accel.constant_factor;
-
- if (accel_factor > tp->accel.max_factor)
- accel_factor = tp->accel.max_factor;
- else if (accel_factor < tp->accel.min_factor)
- accel_factor = tp->accel.min_factor;
-
- return accel_factor;
}
static inline struct tp_motion *
motion.dx = *dx * tp->accel.x_scale_coeff;
motion.dy = *dy * tp->accel.y_scale_coeff;
- filter_dispatch(tp->filter, &motion, tp, time);
+ if (motion.dx != 0.0 || motion.dy != 0.0)
+ filter_dispatch(tp->filter, &motion, tp, time);
*dx = motion.dx;
*dy = motion.dy;
t->dirty = true;
t->is_pointer = false;
+ t->palm.is_palm = false;
t->state = TOUCH_END;
t->pinned.is_pinned = false;
assert(tp->nfingers_down >= 1);
tp_touch_active(struct tp_dispatch *tp, struct tp_touch *t)
{
return (t->state == TOUCH_BEGIN || t->state == TOUCH_UPDATE) &&
+ !t->palm.is_palm &&
!t->pinned.is_pinned && tp_button_touch_active(tp, t);
}
}
static void
+tp_palm_detect(struct tp_dispatch *tp, struct tp_touch *t, uint64_t time)
+{
+ const int PALM_TIMEOUT = 200; /* ms */
+ const int DIRECTIONS = NE|E|SE|SW|W|NW;
+
+ /* If labelled a touch as palm, we unlabel as palm when
+ we move out of the palm edge zone within the timeout, provided
+ the direction is within 45 degrees of the horizontal.
+ */
+ if (t->palm.is_palm) {
+ if (time < t->palm.time + PALM_TIMEOUT &&
+ (t->x > tp->palm.left_edge && t->x < tp->palm.right_edge)) {
+ int dirs = vector_get_direction(t->x - t->palm.x, t->y - t->palm.y);
+ if ((dirs & DIRECTIONS) && !(dirs & ~DIRECTIONS)) {
+ t->palm.is_palm = false;
+ tp_set_pointer(tp, t);
+ }
+ }
+ return;
+ }
+
+ /* palm must start in exclusion zone, it's ok to move into
+ the zone without being a palm */
+ if (t->state != TOUCH_BEGIN ||
+ (t->x > tp->palm.left_edge && t->x < tp->palm.right_edge))
+ return;
+
+ /* don't detect palm in software button areas, it's
+ likely that legitimate touches start in the area
+ covered by the exclusion zone */
+ if (tp->buttons.is_clickpad &&
+ tp_button_is_inside_softbutton_area(tp, t))
+ return;
+
+ t->palm.is_palm = true;
+ t->palm.time = time;
+ t->palm.x = t->x;
+ t->palm.y = t->y;
+}
+
+static void
tp_process_state(struct tp_dispatch *tp, uint64_t time)
{
struct tp_touch *t;
t->y = first->y;
if (!t->dirty)
t->dirty = first->dirty;
- } else if (!t->dirty)
+ } else if (!t->dirty) {
continue;
+ }
+
+ tp_palm_detect(tp, t, time);
tp_motion_hysteresis(tp, t);
tp_motion_history_push(t);
dx += tmpx;
dy += tmpy;
}
+ /* Stop spurious MOTION events at the end of scrolling */
+ t->is_pointer = false;
}
if (nchanged == 0)
tp_filter_motion(tp, &dx, &dy, time);
- /* Require at least three px scrolling to start */
- if (dy <= -3.0 || dy >= 3.0) {
- tp->scroll.state = SCROLL_STATE_SCROLLING;
- tp->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_VERTICAL_SCROLL);
- }
- if (dx <= -3.0 || dx >= 3.0) {
- tp->scroll.state = SCROLL_STATE_SCROLLING;
- tp->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_HORIZONTAL_SCROLL);
- }
+ /* Require at least five px scrolling to start */
+ if (dy <= -5.0 || dy >= 5.0)
+ tp->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL);
- if (tp->scroll.state == SCROLL_STATE_NONE)
- return;
-
- /* Stop spurious MOTION events at the end of scrolling */
- tp_for_each_touch(tp, t)
- t->is_pointer = false;
+ if (dx <= -5.0 || dx >= 5.0)
+ tp->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL);
if (dy != 0.0 &&
- (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_VERTICAL_SCROLL))) {
+ (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))) {
pointer_notify_axis(&tp->device->base,
time,
- LIBINPUT_POINTER_AXIS_VERTICAL_SCROLL,
+ LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
dy);
}
if (dx != 0.0 &&
- (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_HORIZONTAL_SCROLL))) {
+ (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL))) {
pointer_notify_axis(&tp->device->base,
time,
- LIBINPUT_POINTER_AXIS_HORIZONTAL_SCROLL,
+ LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
dx);
}
}
static void
tp_stop_scroll_events(struct tp_dispatch *tp, uint64_t time)
{
- if (tp->scroll.state == SCROLL_STATE_NONE)
- return;
-
/* terminate scrolling with a zero scroll event */
- if (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_VERTICAL_SCROLL))
+ if (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL))
pointer_notify_axis(&tp->device->base,
time,
- LIBINPUT_POINTER_AXIS_VERTICAL_SCROLL,
+ LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
0);
- if (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_HORIZONTAL_SCROLL))
+ if (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL))
pointer_notify_axis(&tp->device->base,
time,
- LIBINPUT_POINTER_AXIS_HORIZONTAL_SCROLL,
+ LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
0);
- tp->scroll.state = SCROLL_STATE_NONE;
tp->scroll.direction = 0;
}
if (tp_post_scroll_events(tp, time) != 0)
return;
- if (t->history.count >= TOUCHPAD_MIN_SAMPLES) {
- if (!t->is_pointer) {
- tp_for_each_touch(tp, t) {
- if (t->is_pointer)
- break;
- }
+ if (!t->is_pointer) {
+ tp_for_each_touch(tp, t) {
+ if (t->is_pointer)
+ break;
}
+ }
- if (!t->is_pointer)
- return;
+ if (!t->is_pointer ||
+ !t->dirty ||
+ t->history.count < TOUCHPAD_MIN_SAMPLES)
+ return;
- tp_get_delta(t, &dx, &dy);
- tp_filter_motion(tp, &dx, &dy, time);
+ tp_get_delta(t, &dx, &dy);
+ tp_filter_motion(tp, &dx, &dy, time);
- if (dx != 0.0 || dy != 0.0)
- pointer_notify_motion(&tp->device->base, time, dx, dy);
- }
+ if (dx != 0.0 || dy != 0.0)
+ pointer_notify_motion(&tp->device->base, time, dx, dy);
}
static void
tp_destroy_tap(tp);
tp_destroy_buttons(tp);
- motion_filter_destroy(tp->filter);
+ filter_destroy(tp->filter);
free(tp->touches);
free(tp);
}
return 0;
}
-static void
-calculate_scale_coefficients(struct tp_dispatch *tp)
+static int
+tp_init_accel(struct tp_dispatch *tp, double diagonal)
{
+ struct motion_filter *accel;
int res_x, res_y;
if (tp->has_mt) {
ABS_Y);
}
- if (res_x <= 0 || res_y <= 0) {
- tp->accel.x_scale_coeff = 1.0;
- tp->accel.y_scale_coeff = 1.0;
- } else if (res_x > res_y) {
- tp->accel.x_scale_coeff = res_y / (double) res_x;
- tp->accel.y_scale_coeff = 1.0f;
+ /*
+ * Not all touchpads report the same amount of units/mm (resolution).
+ * Normalize motion events to a resolution of 15.74 units/mm
+ * (== 400 dpi) as base (unaccelerated) speed. This also evens out any
+ * differences in x and y resolution, so that a circle on the
+ * touchpad does not turn into an elipse on the screen.
+ *
+ * We pick 400dpi as thats one of the many default resolutions
+ * for USB mice, so we end up with a similar base speed on the device.
+ */
+ if (res_x > 1 && res_y > 1) {
+ tp->accel.x_scale_coeff = (400/25.4) / res_x;
+ tp->accel.y_scale_coeff = (400/25.4) / res_y;
} else {
- tp->accel.y_scale_coeff = res_x / (double) res_y;
- tp->accel.x_scale_coeff = 1.0f;
+ /*
+ * For touchpads where the driver does not provide resolution, fall
+ * back to scaling motion events based on the diagonal size in units.
+ */
+ tp->accel.x_scale_coeff = DEFAULT_ACCEL_NUMERATOR / diagonal;
+ tp->accel.y_scale_coeff = DEFAULT_ACCEL_NUMERATOR / diagonal;
}
-}
-
-static int
-tp_init_accel(struct tp_dispatch *touchpad, double diagonal)
-{
- struct motion_filter *accel;
-
- calculate_scale_coefficients(touchpad);
-
- touchpad->accel.constant_factor =
- DEFAULT_CONSTANT_ACCEL_NUMERATOR / diagonal;
- touchpad->accel.min_factor = DEFAULT_MIN_ACCEL_FACTOR;
- touchpad->accel.max_factor = DEFAULT_MAX_ACCEL_FACTOR;
- accel = create_pointer_accelator_filter(tp_accel_profile);
+ accel = create_pointer_accelator_filter(
+ pointer_accel_profile_smooth_simple);
if (accel == NULL)
return -1;
- touchpad->filter = accel;
+ tp->filter = accel;
return 0;
}
tp_init_scroll(struct tp_dispatch *tp)
{
tp->scroll.direction = 0;
- tp->scroll.state = SCROLL_STATE_NONE;
return 0;
}
static int
+tp_init_palmdetect(struct tp_dispatch *tp,
+ struct evdev_device *device)
+{
+ int width;
+
+ tp->palm.right_edge = INT_MAX;
+ tp->palm.left_edge = INT_MIN;
+
+ /* We don't know how big the touchpad is */
+ if (device->abs.absinfo_x->resolution == 1)
+ return 0;
+
+ width = abs(device->abs.absinfo_x->maximum -
+ device->abs.absinfo_x->minimum);
+
+ /* Enable palm detection on touchpads >= 80 mm. Anything smaller
+ probably won't need it, until we find out it does */
+ if (width/device->abs.absinfo_x->resolution < 80)
+ return 0;
+
+ /* palm edges are 5% of the width on each side */
+ tp->palm.right_edge = device->abs.absinfo_x->maximum - width * 0.05;
+ tp->palm.left_edge = device->abs.absinfo_x->minimum + width * 0.05;
+
+ return 0;
+}
+
+
+static int
tp_init(struct tp_dispatch *tp,
struct evdev_device *device)
{
if (tp_init_buttons(tp, device) != 0)
return -1;
+ if (tp_init_palmdetect(tp, device) != 0)
+ return -1;
+
return 0;
}