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

[Henrik Rydberg]

A bunch of patches aiming to integrate the ideas of v1.0.19 more seamlessly into the grail code. This will fix the remaining tap bug and help further development. The only part not addressed by this branch is the sysflag, and a discussion around it is likely enough to see how to form a patch for it.

[Stephen M. Webb (bregma)]

A more elegant and nuanced way of handling the various timeout issues. Compiles and runs OK.

review: Approve

[Chase Douglas (chasedouglas)]

In line 371 of the patch below, there's an ambiguity in the if statement "if (a || b && c)". This should be cleaned up.

I need to test this branch, but I think the changes look reasonable. However, I can't approve the request until it also handles the global flag. This is something I think we will really need in natty, since we're going to have more applications using gestures.

review: Needs Fixing

[Chase Douglas (chasedouglas)]

Test results:

1. Regression: If you use a physical trackpad button to click while there's no movement on the trackpad, it's held up until a movement is performed.

2. Timeouts seem ok. I was able to request all 3, 4, and 5 finger gestures and still perform two finger multitouch reasonably. I will perform more thorough testing when the regressions are resolved.

3. Regression: I often get a tap event at the end of a drag gesture sequence. The tap touch count matches the drag touch count.

review: Needs Fixing

[Henrik Rydberg (rydberg)]

Thank you very much for the tests! I have updated the branch with fixes for
the two problems found. I will add something for the global flag shortly.

[Henrik Rydberg (rydberg)]

Fix of the fix - the first regression was pretty complex, and revealed some
additional assumptions that were not true. Hopefully this version will do better.

[Chase Douglas (chasedouglas)]

Things are progressing :). I want to test this some more before approving, and we will also need to resolve the SYSFLAG issue before we merge as well.

[Henrik Rydberg (rydberg)]

Ok, here is a stop-gap measure for the sysflag issue. Apparently the solution has issues overall, both in the X drivers and in grail. But frankly, it does not seem important enough to stop progress at this stage. Uploaded new version with added sysflag patch.

[Chase Douglas (chasedouglas)]

I think the last commit is all I needed. The log message also summarizes an interesting "bug" that we're going to leave as is for now as SYSFLAG1 is an undocumented "feature". We need to hammer this new grail version in testing so we can upload it as soon as possible. I'll mark this as approved after I've done testing.

[Henrik Rydberg (rydberg)]

Argh, I committed the wrong version of the patch - this one is almost the same, but resets grab_active at the start of a new set of touches, rather than at the end. More stable.

[Chase Douglas (chasedouglas)]

I've done testing locally and everything seems to operate correctly.

review: Approve

=== modified file 'configure.ac'
--- configure.ac	2011-02-21 19:20:28 +0000
+++ configure.ac	2011-03-04 00:06:44 +0000
@@ -1,7 +1,7 @@
 # Initialize Autoconf
 AC_PREREQ([2.60])
 AC_INIT([Gesture Recognition And Instantiation Library],
-        [1.0.19],
+        [1.0.20],
         [],
         [utouch-grail])
 AC_CONFIG_SRCDIR([Makefile.am])

=== modified file 'src/evbuf.h'
--- src/evbuf.h	2010-08-06 20:30:20 +0000
+++ src/evbuf.h	2011-03-04 00:06:44 +0000
@@ -29,7 +29,7 @@
 #ifndef GRAIL_EVBUF_H
 #define GRAIL_EVBUF_H
 
-#define DIM_EVENTS 512
+#define DIM_EVENTS 4096
 
 struct evbuf {
 	int head;

=== modified file 'src/gestures-drag.c'
--- src/gestures-drag.c	2011-01-02 12:08:08 +0000
+++ src/gestures-drag.c	2011-03-04 00:06:44 +0000
@@ -72,6 +72,13 @@
 			state->active = 0;
 		}
 	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_discard(ge, state->gid);
+			state->active = 0;
+		}
+		return 0;
+	}
 	if (!state->active) {
 		int type = getype[move->ntouch];
 		if (type < 0)
@@ -102,6 +109,13 @@
 			state->active = 0;
 		}
 	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_discard(ge, state->gid);
+			state->active = 0;
+		}
+		return 0;
+	}
 	if (!state->active) {
 		if (move->ntouch == 4) {
 			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MDRAG,

=== modified file 'src/gestures-pinch.c'
--- src/gestures-pinch.c	2011-01-02 12:08:08 +0000
+++ src/gestures-pinch.c	2011-03-04 00:06:44 +0000
@@ -54,7 +54,7 @@
 	struct combo_model *state = &gru->pinch;
 	struct move_model *move = &gru->move;
 	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi) {
+	if (!move->multi && !move->single) {
 		if (state->active) {
 			gru_end(ge, state->gid, move,
 				state->prop, state->nprop);
@@ -62,6 +62,13 @@
 		}
 		return 0;
 	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_discard(ge, state->gid);
+			state->active = 0;
+		}
+		return 0;
+	}
 	if (!(move->tickle & mask))
 		return 0;
 	if (!state->active) {
@@ -93,6 +100,13 @@
 		}
 		return 0;
 	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_discard(ge, state->gid);
+			state->active = 0;
+		}
+		return 0;
+	}
 	if (!(move->tickle & mask))
 		return 0;
 	if (!state->active) {

=== modified file 'src/gestures-rotate.c'
--- src/gestures-rotate.c	2011-01-02 12:08:08 +0000
+++ src/gestures-rotate.c	2011-03-04 00:06:44 +0000
@@ -53,7 +53,7 @@
 	struct combo_model *state = &gru->rotate;
 	struct move_model *move = &gru->move;
 	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi) {
+	if (!move->multi && !move->single) {
 		if (state->active) {
 			gru_end(ge, state->gid, move,
 				state->prop, state->nprop);
@@ -61,6 +61,13 @@
 		}
 		return 0;
 	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_discard(ge, state->gid);
+			state->active = 0;
+		}
+		return 0;
+	}
 	if (!(move->tickle & mask))
 		return 0;
 	if (!state->active) {
@@ -92,6 +99,13 @@
 		}
 		return 0;
 	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_discard(ge, state->gid);
+			state->active = 0;
+		}
+		return 0;
+	}
 	if (!(move->tickle & mask))
 		return 0;
 	if (!state->active) {

=== modified file 'src/gestures-tapping.c'
--- src/gestures-tapping.c	2011-02-09 15:17:50 +0000
+++ src/gestures-tapping.c	2011-03-04 00:06:44 +0000
@@ -43,8 +43,10 @@
 	struct tapping_model *state = &gru->tapping;
 	struct move_model *move = &gru->move;
 	state->tap = 0;
-	if (move->ntouch && move->ntouch < state->mintouch)
-		state->end = move->time;
+	if (frame->num_active && !frame->prev->num_active) {
+		state->mintouch = 0;
+		state->maxtouch = 0;
+	}
 	if (move->ntouch > state->maxtouch) {
 		if (state->active) {
 			gin_gid_discard(ge, state->gid);
@@ -91,6 +93,8 @@
 	if ((move->active & fm_mask) ||
 	    move->time - state->start > move->fm[FM_X].bar_ms) {
 		gin_gid_discard(ge, state->gid);
+		state->mintouch = move->ntouch;
+		state->maxtouch = move->ntouch;
 		state->active = 0;
 	}
 	return 0;

=== modified file 'src/grail-api.c'
--- src/grail-api.c	2011-02-21 01:22:08 +0000
+++ src/grail-api.c	2011-03-04 00:06:44 +0000
@@ -34,11 +34,6 @@
 #define DIM_FRAMES 100
 #define FRAME_RATE 100
 
-/* Wait time (ms) for number of touches to stabilize. */
-static const unsigned int stable_time = 50;
-/* Maximum time (ms) for gesture to be recognized. */
-static const unsigned int recognition_time = 300;
-
 void grail_filter_abs_events(struct grail *ge, int usage)
 {
 	struct grail_impl *x = ge->impl;
@@ -132,62 +127,72 @@
 	max->y = s->max_y;
 }
 
-/* Check for any potential gestures given the number of touch points and where
- * they occur on screen. */
-static int check_potential_gestures(struct grail *ge,
-				    const struct utouch_frame *frame)
-{
-	grail_mask_t types[DIM_GRAIL_TYPE_BYTES] = {0};
-	struct grail_client_info client;
-	struct grail_coord pos[frame->num_active];
-	int i;
-
-	switch (frame->num_active) {
-		case 1:
-			grail_mask_set(types, GRAIL_TYPE_DRAG1);
-			grail_mask_set(types, GRAIL_TYPE_PINCH1);
-			grail_mask_set(types, GRAIL_TYPE_ROTATE1);
-			grail_mask_set(types, GRAIL_TYPE_TAP1);
-			break;
-		case 2:
-			grail_mask_set(types, GRAIL_TYPE_DRAG2);
-			grail_mask_set(types, GRAIL_TYPE_PINCH2);
-			grail_mask_set(types, GRAIL_TYPE_ROTATE2);
-			grail_mask_set(types, GRAIL_TYPE_TAP2);
-			break;
-		case 3:
-			grail_mask_set(types, GRAIL_TYPE_DRAG3);
-			grail_mask_set(types, GRAIL_TYPE_PINCH3);
-			grail_mask_set(types, GRAIL_TYPE_ROTATE3);
-			grail_mask_set(types, GRAIL_TYPE_TAP3);
-			grail_mask_set(types, GRAIL_TYPE_EDRAG);
-			grail_mask_set(types, GRAIL_TYPE_EPINCH);
-			grail_mask_set(types, GRAIL_TYPE_EROTATE);
-			break;
-		case 4:
-			grail_mask_set(types, GRAIL_TYPE_DRAG4);
-			grail_mask_set(types, GRAIL_TYPE_PINCH4);
-			grail_mask_set(types, GRAIL_TYPE_ROTATE4);
-			grail_mask_set(types, GRAIL_TYPE_TAP4);
-			grail_mask_set(types, GRAIL_TYPE_MDRAG);
-			grail_mask_set(types, GRAIL_TYPE_MPINCH);
-			grail_mask_set(types, GRAIL_TYPE_MROTATE);
-			break;
-		case 5:
-			grail_mask_set(types, GRAIL_TYPE_DRAG5);
-			grail_mask_set(types, GRAIL_TYPE_PINCH5);
-			grail_mask_set(types, GRAIL_TYPE_ROTATE5);
-			grail_mask_set(types, GRAIL_TYPE_TAP5);
-			break;
-	}
-
-	for (i = 0; i < frame->num_active; i++) {
-		pos[i].x = gin_prop_x(ge->gin, frame->active[i]->x);
-		pos[i].y = gin_prop_y(ge->gin, frame->active[i]->y);
-	}
-
-	return ge->get_clients(ge, &client, 1, pos, frame->num_active,
-			       types, DIM_GRAIL_TYPE_BYTES);
+static void flush_events(struct grail *ge)
+{
+	struct grail_impl *impl = ge->impl;
+	struct input_event iev;
+
+	grailbuf_clear(&impl->gbuf);
+	while (!evbuf_empty(&impl->evbuf)) {
+		evbuf_get(&impl->evbuf, &iev);
+		if (ge->event)
+			ge->event(ge, &iev);
+	}
+}
+
+static int skip_event(const struct input_event *ev, int count)
+{
+	switch (ev->type) {
+	case EV_ABS:
+		return 1;
+	case EV_KEY:
+		return ev->code >= BTN_DIGI && ev->code < BTN_WHEEL;
+	case EV_SYN:
+		switch (ev->code) {
+		case SYN_MT_REPORT:
+			return 1;
+		case SYN_REPORT:
+			return count == 0;
+		default:
+			return 0;
+		}
+	default:
+		return 0;
+	}
+}
+
+static void flush_gestures(struct grail *ge)
+{
+	struct grail_impl *impl = ge->impl;
+	struct input_event iev;
+	struct grail_event gev;
+	int count = 0;
+
+	while (!evbuf_empty(&impl->evbuf)) {
+		evbuf_get(&impl->evbuf, &iev);
+		if (skip_event(&iev, count))
+			continue;
+		if (ge->event)
+			ge->event(ge, &iev);
+		if (iev.type == EV_SYN && iev.code == SYN_REPORT)
+			count = 0;
+		else
+			count++;
+	}
+	while (!grailbuf_empty(&impl->gbuf)) {
+		grailbuf_get(&impl->gbuf, &gev);
+		if (ge->gesture)
+			ge->gesture(ge, &gev);
+	}
+}
+
+static int gesture_timeout(struct grail *ge, const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct gesture_inserter *gin = ge->gin;
+
+	return grail_mask_count(gin->used, sizeof(gin->used)) == 0 &&
+		frame->time - frame->mod_time > gru->move.fm[FM_X].hold_ms;
 }
 
 static void report_frame(struct grail *ge,
@@ -195,96 +200,27 @@
 			 const struct input_event *syn)
 {
 	struct grail_impl *impl = ge->impl;
-	struct gesture_recognizer *gru = ge->gru;
-	struct input_event iev;
 	struct grail_event gev;
 
 	ge->impl->frame = frame;
 
-	/* Reset timer when number of touches changes. */
-	if (frame->prev->revision != frame->revision && frame->num_active) {
-		gru->start_time = frame->time;
-	}
-
-	/* Once touches have stabilized, check if there are any potential
-	 * gestures registered for the number of touches. */
-	if (gru->state == RECOGNIZING &&
-	    frame->time > gru->start_time + stable_time &&
-	    check_potential_gestures(ge, frame) == 0)
-		gru->state = UNRECOGNIZED;
-
-	/* Process the frame for gestures unless we're sure there are none. */
-	if (gru->state != UNRECOGNIZED) {
-		gin_frame_begin(ge, frame);
-		gru_recognize(ge, frame);
-		gin_frame_end(ge, frame);
-	}
-
-	if (gru->state == RECOGNIZING) {
-		/* If a gesture is recognized and either all touches lifted or
-		 * we are within the recognition interval, set state to
-		 * recognized. Note that taps do not stay in the used array, so
-		 * we must check if any gesture events are buffered. */
-		if ((grail_mask_count(ge->gin->used, DIM_INSTANCE_BYTES) ||
-		     !grailbuf_empty(&impl->gbuf)) &&
-		    (frame->num_active == 0 ||
-		     (frame->time > gru->start_time + stable_time &&
-		      frame->time <= gru->start_time + recognition_time))) {
-			if (gru->global_client)
-				gru->state = GLOBAL;
-			else
-				gru->state = LOCAL;
-		}
-		/* If there is no gesture and all touches lifted, set state to
-		 * unrecognized. */
-		else if (frame->num_active == 0)
-			gru->state = UNRECOGNIZED;
-	}
-
-	/* Now we have the state set, process events. */
-	switch (gru->state) {
-		case LOCAL:
-		case GLOBAL:
-			while (!grailbuf_empty(&impl->gbuf)) {
-				grailbuf_get(&impl->gbuf, &gev);
-				if (ge->gesture &&
-				    ((gru->state == GLOBAL &&
-				      gev.client_id.client == gru->global_client) ||
-				     (gru->state == LOCAL &&
-				      gev.client_id.client != gru->global_client)))
-					ge->gesture(ge, &gev);
-			}
-			evbuf_clear(&impl->evbuf);
-
-			/* Once all touches are lifted and no gestures are
-			 * active, reset recognition state. */
-			if (grail_mask_count(ge->gin->used, DIM_INSTANCE_BYTES) == 0 &&
-			    frame->num_active == 0) {
-				gru->state = RECOGNIZING;
-				gru->global_client = 0;
-			}
-			break;
-
-		case RECOGNIZING:
-			/* If we're still actively recognizing, stop here. */
-			if (frame->time <= gru->start_time + recognition_time)
-				break;
-			gru->state = UNRECOGNIZED;
-
-		case UNRECOGNIZED:
-			while (!evbuf_empty(&impl->evbuf)) {
-				evbuf_get(&impl->evbuf, &iev);
-				if (ge->event)
-					ge->event(ge, &iev);
-			}
-			grailbuf_clear(&impl->gbuf);
-
-			if (frame->num_active == 0) {
-				gru->state = RECOGNIZING;
-				gru->global_client = 0;
-			}
-			break;
-	}
+	if (frame->num_active && !frame->prev->num_active) {
+		impl->ongoing = 1;
+		impl->gesture = 0;
+	}
+
+	if (!impl->ongoing)
+		return;
+
+	gin_frame_begin(ge, frame);
+	gru_recognize(ge, frame);
+	gin_frame_end(ge, frame);
+
+	if (!grailbuf_empty(&impl->gbuf))
+		impl->gesture = 1;
+
+	if (frame->num_active == 0 || gesture_timeout(ge, frame))
+		impl->ongoing &= impl->gesture;
 }
 
 static void grail_pump_mtdev(struct grail *ge, const struct input_event *ev)
@@ -292,21 +228,6 @@
 	struct grail_impl *impl = ge->impl;
 	const struct utouch_frame *frame;
 
-	if (ev->type == EV_KEY && (ev->code < BTN_DIGI ||
-                                   ev->code > BTN_TOOL_QUADTAP)) {
-		struct input_event sync_ev;
-
-		ge->event(ge, ev);
-
-		sync_ev.type = EV_SYN;
-		sync_ev.code = SYN_REPORT;
-		sync_ev.value = 1;
-		sync_ev.time = ev->time;
-		ge->event(ge, &sync_ev);
-
-		return;
-	}
-
 	evbuf_put(&impl->evbuf, ev);
 
 	if (ev->type == EV_SYN || ev->type == EV_ABS) {
@@ -314,6 +235,13 @@
 		if (frame)
 			report_frame(ge, frame, ev);
 	}
+
+	if (ev->type == EV_SYN) {
+		if (!impl->ongoing)
+			flush_events(ge);
+		if (impl->gesture)
+			flush_gestures(ge);
+	}
 }
 
 int grail_pull(struct grail *ge, int fd)

=== modified file 'src/grail-event.c'
--- src/grail-event.c	2011-02-09 15:12:13 +0000
+++ src/grail-event.c	2011-03-04 00:06:44 +0000
@@ -22,7 +22,6 @@
 
 #include "grail-inserter.h"
 #include "grail-impl.h"
-#include "grail-recognizer.h"
 #include <malloc.h>
 #include <string.h>
 #include <errno.h>
@@ -83,7 +82,7 @@
 		    const struct utouch_frame *frame)
 {
 	struct grail_coord pos[DIM_TOUCH];
-	int i, npos = 0, num_clients;
+	int i, npos = 0;
 	if (!ge->get_clients)
 		return 0;
 	grail_mask_foreach(i, span, bspan) {
@@ -91,20 +90,7 @@
 		pos[npos].y = gin_prop_y(ge->gin, frame->slots[i]->y);
 		npos++;
 	}
-
-	num_clients = ge->get_clients(ge, info, maxinfo, pos, npos, types,
-				      btypes);
-
-	/* Check if client is handling global gestures, using SYSFLAG1. */
-	if (num_clients > 0 && grail_mask_get(info[0].mask,
-					      GRAIL_TYPE_SYSFLAG1)) {
-		/* Save client id, and clear SYSFLAG1 as it isn't a real
-		 * gesture type. */
-		ge->gru->global_client = info[0].id.client;
-		grail_mask_clear(info[0].mask, GRAIL_TYPE_SYSFLAG1);
-	}
-
-	return num_clients;
+	return ge->get_clients(ge, info, maxinfo, pos, npos, types, btypes);
 }
 
 void gin_send_event(struct grail *ge, struct slot_state *s,

=== modified file 'src/grail-gestures.c'
--- src/grail-gestures.c	2011-01-02 12:08:08 +0000
+++ src/grail-gestures.c	2011-03-04 00:06:44 +0000
@@ -24,9 +24,10 @@
 #include "grail-impl.h"
 #include <math.h>
 
-static const float FM_SN[DIM_FM] = { 1000, 1000, 200, 1000 };
-static const float FM_BAR[DIM_FM] = { 50, 50, 30, 50 };
-static const grail_time_t FM_BAR_MS[DIM_FM] = { 300, 300, 10000, 10000 };
+static const float FM_SN[DIM_FM] = { 1000, 1000, 1000, 1000 };
+static const float FM_BAR[DIM_FM] = { 50, 50, 50, 50 };
+static const grail_time_t FM_HOLD_MS[DIM_FM] = { 60, 60, 60, 60 };
+static const grail_time_t FM_BAR_MS[DIM_FM] = { 300, 300, 500, 500 };
 static const grail_time_t SAMPLE_MS = 10;
 static const float EPS = 1e-3;
 
@@ -111,6 +112,7 @@
 	fm->sample_ms = t;
 	m->tickle &= ~(1 << i);
 	m->active &= ~(1 << i);
+	m->timeout &= ~(1 << i);
 }
 
 static void move_update(struct move_model *m, int i, float x, grail_time_t t)
@@ -132,11 +134,15 @@
 	if (m->active & (1 << i))
 		return;
 	fm->action_delta = x - fm->original;
-	if (fabs(fm->action_delta) > fm->bar ||
-	    t - fm->original_ms > fm->bar_ms)
-		m->active |= (1 << i);
-	else
+	if (t - fm->original_ms > fm->hold_ms &&
+	    fabs(fm->action_delta) > fm->bar) {
+		m->active |= (1 << i);
+	} else if (t - fm->original_ms > fm->bar_ms) {
+		m->active |= (1 << i);
+		m->timeout |= (1 << i);
+	} else {
 		fm->action_delta = 0;
+	}
 }
 
 void gru_init_motion(struct grail *ge)
@@ -153,6 +159,7 @@
 	for (i = 0; i < DIM_FM; i++) {
 		m->fm[i].fuzz = D[i] / FM_SN[i];
 		m->fm[i].bar = D[i] / FM_BAR[i];
+		m->fm[i].hold_ms = FM_HOLD_MS[i];
 		m->fm[i].bar_ms = FM_BAR_MS[i];
 	}
 }

=== modified file 'src/grail-gestures.h'
--- src/grail-gestures.h	2011-01-02 12:08:08 +0000
+++ src/grail-gestures.h	2011-03-04 00:06:44 +0000
@@ -49,12 +49,13 @@
 	float bar;
 	grail_time_t original_ms;
 	grail_time_t sample_ms;
+	grail_time_t hold_ms;
 	grail_time_t bar_ms;
 };
 
 struct move_model {
 	struct filter_model fm[DIM_FM];
-	int tickle, active;
+	int tickle, active, timeout;
 	int single, multi, ntouch;
 	grail_time_t time;
 };
@@ -97,7 +98,7 @@
 		  const struct utouch_frame *frame);
 
 struct tapping_model {
-	grail_time_t start, end;
+	grail_time_t start;
 	int mintouch, maxtouch;
 	int active, gid, tap;
 	int nprop;

=== modified file 'src/grail-impl.h'
--- src/grail-impl.h	2011-02-02 22:16:20 +0000
+++ src/grail-impl.h	2011-03-04 00:06:44 +0000
@@ -42,6 +42,8 @@
 	struct evbuf evbuf;
 	struct grailbuf gbuf;
 	int filter_abs;
+	int ongoing;
+	int gesture;
 };
 
 #endif

=== modified file 'src/grail-inserter.c'
--- src/grail-inserter.c	2011-01-02 12:08:08 +0000
+++ src/grail-inserter.c	2011-03-04 00:06:44 +0000
@@ -69,6 +69,13 @@
 		for (j = 0; j < nclient; j++) {
 			if (!grail_mask_get(info[j].mask, s->type))
 				continue;
+			if (gin->grab_active &&
+			    info[j].id.client != gin->grab_client)
+				continue;
+			if (grail_mask_get(info[j].mask, GRAIL_TYPE_SYSFLAG1)) {
+				gin->grab_active = 1;
+				gin->grab_client = info[j].id.client;
+			}
 			s->client_id[s->nclient++] = info[j].id;
 		}
 	}
@@ -105,6 +112,8 @@
 	struct gesture_inserter *gin = ge->gin;
 	memset(gin->types, 0, sizeof(gin->types));
 	gin->time = frame->time;
+	if (frame->num_active && !frame->prev->num_active)
+		gin->grab_active = 0;
 }
 
 void gin_frame_end(struct grail *ge, const struct utouch_frame *frame)

=== modified file 'src/grail-inserter.h'
--- src/grail-inserter.h	2011-01-02 12:08:08 +0000
+++ src/grail-inserter.h	2011-03-04 00:06:44 +0000
@@ -53,6 +53,8 @@
 	grail_mask_t used[DIM_INSTANCE_BYTES];
 	grail_time_t time;
 	int gestureid;
+	int grab_active;
+	int grab_client;
 	float scale_x, scale_y, scale_r;
 	float trans_x, trans_y;
 };

=== modified file 'src/grail-recognizer.h'
--- src/grail-recognizer.h	2011-02-09 15:12:13 +0000
+++ src/grail-recognizer.h	2011-03-04 00:06:44 +0000
@@ -25,13 +25,6 @@
 
 #include "grail-gestures.h"
 
-enum recognition_state {
-	RECOGNIZING,
-	LOCAL,
-	GLOBAL,
-	UNRECOGNIZED
-};
-
 struct gesture_recognizer {
 	struct move_model move;
 	struct combo_model drag;
@@ -41,9 +34,6 @@
 	struct combo_model winpinch;
 	struct combo_model winrotate;
 	struct tapping_model tapping;
-	utouch_frame_time_t start_time;
-	enum recognition_state state;
-	int global_client;
 };
 
 int gru_init(struct grail *ge);