Merge lp:~oif-team/grail/trunk.v1.0.13 into lp:grail

[Henrik Rydberg]

The changes needed to support non-MT devices through the utouch stack.

[Chase Douglas (chasedouglas)]

Commit 79 makes sense, so no issues there.

However, I'm not sure what to do about commit 80. I think it looks good and it probably can introduce some interesting support for synaptics trackpads. However, it's also really late in the cycle to be adding this much new code.

I know it would be a bit of extra work, but can we keep commit 80 in a separate branch for now and not package it up for Maverick? By strict definition it is clearly out of scope at this point in the development cycle, and it likely won't actually add any new features since synaptics will be used for most of these devices anyways. However, I worry that there could be regressions in the single-touch touchscreen use case.

I guess the most appropriate review state for this is resubmit to include only commit 79. If you aren't meaning to push this into maverick, perhaps this could be merged as 1.1.0 and we would keep maverick on the 1.0.x series that would not include commit 80?

review: Needs Resubmitting

[Henrik Rydberg (rydberg)]

Well, I was thinking maverick for this, since there has already been bug reports about it. I see your point clearly, but I also see the conflict between the normal maverick procedure and the interests to make gestures work for as broad an audience as possible.

[lp:~oif-team/grail/trunk.v1.0.13]

79. By Henrik Rydberg on 2010-09-10

Make sure contact area is always defined

Some devices do not always send touch_minor after touch_major
has been set. According to the MT protocol, this case should
be treated as if minor is equal to major. This patch makes sure
touch_minor is never zero when touch_major is set.

80. By Henrik Rydberg on 2010-09-10

Support legacy devices

Simulate MT touch events for legacy devices that support the
DOUBLETAP, TRIPLETAP and QUADTAP events. This allows multi-finger
tap and drag gestures to be emitted, providing a basic level of
MT functionality for legacy devices.

81. By Henrik Rydberg on 2010-09-10

Discard tapping even when there are zero events between dow
n and up

The current logic assumes there will be at least one frame with
between touch up and touch down or the tap will not be properly
timed out. Fixed with this patch.

Reported-by: Chase Douglas <email address hidden>

82. By Henrik Rydberg on 2010-09-10

Cancel tapping also on zoom events

The current code cancels tapping when dragging is active. This
patch adds zooming to the set, to inhibit tapping also when a
perfect zoom without dragging is performed.

Reported-by: Chase Douglas <email address hidden>

83. By Henrik Rydberg on 2010-09-10

Only emit abs events when motion is active

This bug was hidden behind the motion inhibit during tapping,
but resurfaced when tapping from resting finger was introduced.
With this patch, pointer movement is inhibited also when lifting
fingers from the surface.

Ideally, tapping should be treated as a transient event, which would
allow zero pointer event also _before_ the tap, but presently unity
seems to depend on the initial pointer movement as a touch-down event.

84. By Henrik Rydberg on 2010-09-10

Inhibit taps immediately after a finger is lifted

The intentional tap starts with a finger in the air. This patch
treats the sequence up-down-up as unintentional, unless performed
with a single finger. Fixes the problem with accidental taps during
multi-finger gestures.

85. By Henrik Rydberg on 2010-09-10

Allow slow tapping

For the benefit of hardware that cannot accurately meet the desirable
response times, allow for tapping times up to 300 ms.

86. By Henrik Rydberg on 2010-09-10

grail v1.0.13

Unmerged revisions

=== modified file 'configure.ac'
--- configure.ac	2010-09-01 21:01:08 +0000
+++ configure.ac	2010-09-08 09:41:45 +0000
@@ -1,7 +1,7 @@
 # Initialize Autoconf
 AC_PREREQ([2.60])
 AC_INIT([Gesture Recognition And Instantiation Library],
-        [1.0.12],
+        [1.0.13],
         [],
         [utouch-grail])
 AC_CONFIG_SRCDIR([Makefile.am])
 
=== modified file 'include/grail-touch.h'
--- include/grail-touch.h	2010-08-19 20:26:11 +0000
+++ include/grail-touch.h	2010-09-08 09:41:45 +0000
@@ -72,6 +72,7 @@
 	int state;
 };
 
+int touch_caps_is_supported(struct touch_dev *dev, int fd);
 void touch_caps_init(struct touch_dev *dev);
 float touch_angle(const struct touch_dev *dev, int orientation);
 float touch_pressure(const struct touch_dev *dev, int pressure);
 
=== modified file 'src/touch-caps.c'
--- src/touch-caps.c	2010-08-31 12:20:32 +0000
+++ src/touch-caps.c	2010-09-08 09:41:45 +0000
@@ -21,6 +21,7 @@
  ****************************************************************************/
 
 #include <grail-touch.h>
+#include <errno.h>
 #include <math.h>
 
 /* see mtdev-mapping.h */
@@ -29,6 +30,42 @@
 #define MTDEV_ORIENTATION	4
 #define MTDEV_PRESSURE		10
 
+#define SYSCALL(call) while (((call) == -1) && (errno == EINTR))
+
+static const int bits_per_long = 8 * sizeof(long);
+
+static inline int nlongs(int nbit)
+{
+	return (nbit + bits_per_long - 1) / bits_per_long;
+}
+
+static inline int getbit(const unsigned long *map, int key)
+{
+	return (map[key / bits_per_long] >> (key % bits_per_long)) & 0x01;
+}
+
+int touch_caps_is_supported(struct touch_dev *dev, int fd)
+{
+	unsigned long keybits[nlongs(KEY_MAX)];
+	unsigned long absbits[nlongs(ABS_MAX)];
+	int rc;
+
+	if (dev->mtdev.caps.has_mtdata)
+		return 1;
+
+	SYSCALL(rc = ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits));
+	if (rc < 0)
+		return 0;
+	SYSCALL(rc = ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbits)), absbits));
+	if (rc < 0)
+		return 0;
+
+	return getbit(absbits, ABS_X) &&
+		getbit(absbits, ABS_Y) &&
+		getbit(keybits, BTN_TOUCH) &&
+		getbit(keybits, BTN_TOOL_DOUBLETAP);
+}
+
 void touch_caps_init(struct touch_dev *dev)
 {
 	const struct mtdev_caps *mt = &dev->mtdev.caps;
 
=== modified file 'src/touch-dev.c'
--- src/touch-dev.c	2010-08-19 20:26:11 +0000
+++ src/touch-dev.c	2010-09-08 09:41:45 +0000
@@ -34,6 +34,8 @@
 static void finish_touch(struct touch_dev *dev, struct touch_frame *frame)
 {
 	struct touch *t = &frame->touch[dev->slot];
+	if (t->touch_major && !t->touch_minor)
+		SET_PROP(touch_minor, t->touch_major);
 	if (dev->state > 0) {
 		t->active = 1;
 		grail_mask_set(frame->touches, dev->slot);
@@ -47,13 +49,45 @@
 	dev->state = 0;
 }
 
+static void finish_legacy(struct touch_dev *dev, struct touch_frame *frame)
+{
+	static int trkid;
+	int i;
+	for (i = 0; i < frame->nactive; i++) {
+		struct touch *t = &frame->touch[i];
+		t->active = 1;
+		if (t->id < 0) {
+			t->id = trkid++ & 0xffff;
+			frame->ncreate++;
+		}
+		if (i > 0) {
+			SET_PROP(x, frame->touch[0].x);
+			SET_PROP(y, frame->touch[0].y);
+			SET_PROP(pressure, frame->touch[0].pressure);
+		}
+		grail_mask_set(frame->touches, i);
+	}
+	for (i = frame->nactive; i < DIM_TOUCH; i++) {
+		struct touch *t = &frame->touch[i];
+		t->active = 0;
+		if (t->id >= 0) {
+			t->id = -1;
+			frame->ndestroy++;
+		}
+		grail_mask_clear(frame->touches, i);
+	}
+}
+
 static void finish_packet(struct touch_dev *dev,
 			  const struct input_event *syn)
 {
 	static const touch_time_t ms = 1000;
 	struct touch_frame *frame = &dev->frame;
 	int i, nslot = 0;
-	finish_touch(dev, frame);
+	if (dev->mtdev.caps.has_mtdata)
+		finish_touch(dev, frame);
+	else
+		finish_legacy(dev, frame);
 	grail_mask_foreach(i, frame->touches, DIM_TOUCH_BYTES)
 		frame->active[nslot++] = &frame->touch[i];
 	frame->nactive = nslot;
@@ -71,6 +105,21 @@
 	struct touch_frame *frame = &dev->frame;
 	struct touch *t = &frame->touch[dev->slot];
 	switch (ev->code) {
+	case ABS_X:
+		if (dev->mtdev.caps.has_mtdata)
+			return 0;
+		SET_PROP(x, ev->value);
+		return 1;
+	case ABS_Y:
+		if (dev->mtdev.caps.has_mtdata)
+			return 0;
+		SET_PROP(y, ev->value);
+		return 1;
+	case ABS_PRESSURE:
+		if (dev->mtdev.caps.has_mtdata)
+			return 0;
+		SET_PROP(pressure, ev->value);
+		return 1;
 	case ABS_MT_SLOT:
 		if (ev->value >= 0 && ev->value < DIM_TOUCH) {
 			if (dev->slot != ev->value)
@@ -122,6 +171,40 @@
 	}
 }
 
+static int handle_key_event(struct touch_dev *dev,
+			    const struct input_event *ev)
+{
+	struct touch_frame *frame = &dev->frame;
+	if (dev->mtdev.caps.has_mtdata)
+		return 0;
+	switch (ev->code) {
+	case BTN_TOUCH:
+		if (ev->value && !frame->nactive)
+		    frame->nactive = 1;
+		else if (!ev->value && frame->nactive)
+		    frame->nactive = 0;
+		return 1;
+	case BTN_TOOL_FINGER:
+		if (ev->value)
+			frame->nactive = 1;
+		return 1;
+	case BTN_TOOL_DOUBLETAP:
+		if (ev->value)
+			frame->nactive = 2;
+		return 1;
+	case BTN_TOOL_TRIPLETAP:
+		if (ev->value)
+			frame->nactive = 3;
+		return 1;
+	case BTN_TOOL_QUADTAP:
+		if (ev->value)
+			frame->nactive = 4;
+		return 1;
+	default:
+		return 0;
+	}
+}
+
 int touch_dev_open(struct touch_dev *dev, int fd)
 {
 	struct touch_frame *frame = &dev->frame;
@@ -133,7 +216,7 @@
 		t->id = MT_ID_NULL;
 	}
 	ret = mtdev_open(&dev->mtdev, fd);
-	if (!ret && !dev->mtdev.caps.has_mtdata)
+	if (!ret && !touch_caps_is_supported(dev, fd))
 		ret = -ENODEV;
 	if (ret)
 		goto error;
@@ -160,6 +243,8 @@
 			consumed++;
 		} else if (ev.type == EV_ABS) {
 			consumed += handle_abs_event(dev, &ev);
+		} else if (ev.type == EV_KEY) {
+			consumed += handle_key_event(dev, &ev);
 		}
 		if (!consumed && dev->event)
 			dev->event(dev, &ev);