Merge lp:~oif-team/grail/cooperate-with-xi2.1 into lp:grail

[Chase Douglas]

Before XI 2.1, we were fine just grabbing events and dropping them on the floor or emulating pointer motion. Now, we need to play nicely with X. This includes sending X the unadulterated event stream if there are no gestures found. This branch has two main commits: one to remove the old pointer emulation code, and one to add new code for sending events to X when appropriate.

I'll be pushing this to the xorg-unstable ppa soon.

[Stephen M. Webb (bregma)]

The changes look sensible, but the magic timing constants are buried in the code. I think it would be beneficial to future maintainers if they were moved to the top of the source file (as defines or static consts) and comments added to each reiterating what is in the change log.

Other than that stylistic suggestion this is good to go.

review: Approve

[Chase Douglas (chasedouglas)]

I liked the stylistic simplicity of having the consts within the function they are used. Keeping things in scope. But I also agree that it's nice having constants defined at the top. I'll move them up there when I merge it tomorrow.

Thanks!

[Chase Douglas (chasedouglas)]

I found a few issues, added comments, and cleaned up the code just a little bit more before merging. Nothing logically has changed though.

=== modified file 'src/grail-api.c'
--- src/grail-api.c	2011-01-02 12:08:08 +0000
+++ src/grail-api.c	2011-02-02 22:53:06 +0000
@@ -29,6 +29,7 @@
 #include <fcntl.h>
 #include <malloc.h>
 #include <errno.h>
+#include <stdlib.h>
 
 #define DIM_FRAMES 100
 #define FRAME_RATE 100
@@ -39,24 +40,6 @@
 	x->filter_abs = usage;
 }
 
-static void init_impl(struct grail_impl *x)
-{
-	int i;
-
-	if (evemu_has_event(x->evemu, EV_ABS, ABS_X)) {
-		x->emin_x = evemu_get_abs_minimum(x->evemu, ABS_X);
-		x->emin_y = evemu_get_abs_minimum(x->evemu, ABS_Y);
-		x->emax_x = evemu_get_abs_maximum(x->evemu, ABS_X);
-		x->emax_y = evemu_get_abs_maximum(x->evemu, ABS_Y);
-	} else {
-		struct utouch_surface *s = utouch_frame_get_surface(x->fh);
-		x->emin_x = s->min_x;
-		x->emin_y = s->min_y;
-		x->emax_x = s->max_x;
-		x->emax_y = s->max_y;
-	}
-}
-
 int grail_open(struct grail *ge, int fd)
 {
 	struct grail_impl *x;
@@ -92,7 +75,6 @@
 	if (ret)
 		goto freeframe;
 
-	init_impl(x);
 	ge->impl = x;
 
 	ret = gin_init(ge);
@@ -120,7 +102,6 @@
 void grail_close(struct grail *ge, int fd)
 {
 	struct grail_impl *x = ge->impl;
-	void *status;
 	gru_destroy(ge);
 	gin_destroy(ge);
 	utouch_frame_delete_engine(x->fh);
@@ -146,140 +127,120 @@
 	max->y = s->max_y;
 }
 
-// legacy glue below
-
-static void evput(struct grail_impl *x, struct timeval time,
-		  unsigned type, unsigned code, int value)
-{
-	struct input_event ev = { time, type, code, value };
-	evbuf_put(&x->evbuf, &ev);
-}
-
-static void report_down(struct grail_impl *impl)
-{
-	if (impl->report_status)
-		return;
-	evput(impl, impl->report_time, EV_KEY, BTN_TOUCH, 1);
-	evput(impl, impl->report_time, EV_ABS, ABS_X, impl->report_x);
-	evput(impl, impl->report_time, EV_ABS, ABS_Y, impl->report_y);
-	impl->report_status = 1;
-}
-
-static void report_up(struct grail_impl *impl, const struct input_event *syn)
-{
-	if (!impl->report_status)
-		return;
-	evput(impl, syn->time, EV_KEY, BTN_TOUCH, 0);
-	impl->report_status = 0;
-}
-
-static void set_pointer(struct grail_impl *impl)
-{
-	struct utouch_surface *s = utouch_frame_get_surface(impl->fh);
-	const struct utouch_frame *frame = impl->frame;
-	int best_x, best_y, best_d = -1;
+static void check_potential_gestures(struct grail *ge,
+				     const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	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++) {
-		const struct utouch_contact *t = frame->active[i];
-		float u = (t->x - s->min_x) / (s->max_x - s->min_x);
-		float v = (t->y - s->min_y) / (s->max_y - s->min_y);
-		int x = impl->emin_x + u * (impl->emax_x - impl->emin_x);
-		int y = impl->emin_y + v * (impl->emax_y - impl->emin_y);
-		int d = abs(x - impl->pointer_x) + abs(y - impl->pointer_y);
-		if (best_d < 0 || d < best_d) {
-			best_x = x;
-			best_y = y;
-			best_d = d;
-		}
-	}
-	if (best_d >= 0) {
-		impl->pointer_x = best_x;
-		impl->pointer_y = best_y;
-	}
-}
-
-static void handle_abs_events(struct grail *ge, const struct input_event *syn)
-{
-	static const int fm_mask = 0x03;
-	struct grail_impl *impl = ge->impl;
-	struct gesture_inserter *gin = ge->gin;
-	struct gesture_recognizer *gru = ge->gru;
-	struct move_model *move = &gru->move;
-	struct tapping_model *tap = &gru->tapping;
-	int used_move = grail_mask_count(gin->types, sizeof(gin->types));
-	int used_tap = grail_mask_get(gin->types, GRAIL_TYPE_TAP1);
-	int pointer = move->ntouch == 1;
-	int ismove = pointer && (move->active & fm_mask) && !used_move;
-	int ishold = pointer && tap->active && !used_move;
-	int istap = gru->tapping.tap == 1 && !used_tap;
-
-	set_pointer(impl);
-	if (!impl->pointer_status && pointer) {
-		impl->report_x = impl->pointer_x;
-		impl->report_y = impl->pointer_y;
-		impl->report_time = syn->time;
-		impl->pointer_status = 1;
-		if (!used_move)
-			report_down(impl);
-		return;
-	}
-
-	if (ishold)
-		return;
-
-	if (istap) {
-		report_down(impl);
-		evput(impl, impl->report_time, EV_KEY, BTN_LEFT, 1);
-		evput(impl, impl->report_time, EV_SYN, SYN_REPORT, 0);
-		evput(impl, syn->time, EV_KEY, BTN_LEFT, 0);
-	} else if (ismove) {
-		report_down(impl);
-		if (impl->report_x != impl->pointer_x) {
-			evput(impl, syn->time, EV_ABS, ABS_X, impl->pointer_x);
-			impl->report_x = impl->pointer_x;
-		}
-		if (impl->report_y != impl->pointer_y) {
-			evput(impl, syn->time, EV_ABS, ABS_Y, impl->pointer_y);
-			impl->report_y = impl->pointer_y;
-		}
-	}
-	if (impl->pointer_status && !pointer) {
-		impl->pointer_status = 0;
-		report_up(impl, syn);
-	}
+		pos[i].x = frame->active[i]->x;
+		pos[i].y = frame->active[i]->y;
+	}
+
+	if (ge->get_clients(ge, &client, 1, pos, frame->num_active,
+			    types, DIM_GRAIL_TYPE_BYTES) == 0)
+		gru->state = UNRECOGNIZED;
 }
 
 static void report_frame(struct grail *ge,
 			 const struct utouch_frame *frame,
 			 const struct input_event *syn)
 {
-
+	static const int stable_time = 50;
+	static const int recognition_time = 200;
 	struct grail_impl *impl = ge->impl;
-	int head = impl->evbuf.head;
+	struct gesture_recognizer *gru = ge->gru;
 	struct input_event iev;
 	struct grail_event gev;
 
 	ge->impl->frame = frame;
 
-	gin_frame_begin(ge, frame);
-	gru_recognize(ge, frame);
-	gin_frame_end(ge, frame);
-
-	if (!impl->filter_abs)
-		handle_abs_events(ge, syn);
-	if (impl->evbuf.head != head)
-		evbuf_put(&impl->evbuf, syn);
-
-	while (!grailbuf_empty(&impl->gbuf)) {
-		grailbuf_get(&impl->gbuf, &gev);
-		if (ge->gesture)
-			ge->gesture(ge, &gev);
-	}
-	while (!evbuf_empty(&impl->evbuf)) {
-		evbuf_get(&impl->evbuf, &iev);
-		if (ge->event)
-			ge->event(ge, &iev);
+	if (frame->prev->revision != frame->revision && frame->num_active) {
+		ge->gru->start_time = frame->time;
+	}
+
+	if (gru->state == RECOGNIZING &&
+	    frame->time > ge->gru->start_time + stable_time)
+		check_potential_gestures(ge, frame);
+
+	if (gru->state == RECOGNIZED ||
+	    (gru->state == RECOGNIZING &&
+	     frame->time > ge->gru->start_time + stable_time &&
+	     frame->time < ge->gru->start_time + recognition_time)) {
+		gin_frame_begin(ge, frame);
+		gru_recognize(ge, frame);
+		gin_frame_end(ge, frame);
+
+		if (grail_mask_count(ge->gin->used, DIM_INSTANCE_BYTES))
+			gru->state = RECOGNIZED;
+	}
+
+	if (gru->state == UNRECOGNIZED ||
+	    (gru->state == RECOGNIZING &&
+	     (frame->time >= ge->gru->start_time + recognition_time ||
+	      (frame->num_active == 0 && grailbuf_empty(&impl->gbuf))))) {
+		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;
+	} else if (gru->state == RECOGNIZED) {
+		while (!grailbuf_empty(&impl->gbuf)) {
+			grailbuf_get(&impl->gbuf, &gev);
+			if (ge->gesture)
+				ge->gesture(ge, &gev);
+		}
+		evbuf_clear(&impl->evbuf);
+
+		if (grail_mask_count(ge->gin->used, DIM_INSTANCE_BYTES) == 0 &&
+		    frame->num_active == 0)
+			gru->state = RECOGNIZING;
 	}
 }
 
@@ -289,6 +250,7 @@
 	const struct utouch_frame *frame;
 
 	if (ev->type == EV_SYN || ev->type == EV_ABS) {
+		evbuf_put(&impl->evbuf, ev);
 		frame = utouch_frame_pump_mtdev(impl->fh, ev);
 		if (frame)
 			report_frame(ge, frame, ev);
 
=== modified file 'src/grail-impl.h'
--- src/grail-impl.h	2011-01-02 12:08:08 +0000
+++ src/grail-impl.h	2011-02-02 22:53:06 +0000
@@ -41,14 +41,7 @@
 	const struct utouch_frame *frame;
 	struct evbuf evbuf;
 	struct grailbuf gbuf;
-	float emin_x, emin_y;
-	float emax_x, emax_y;
 	int filter_abs;
-	int pointer_status;
-	int pointer_x, pointer_y;
-	int report_status;
-	int report_x, report_y;
-	struct timeval report_time;
 };
 
 #endif
 
=== modified file 'src/grail-recognizer.h'
--- src/grail-recognizer.h	2011-01-02 12:08:08 +0000
+++ src/grail-recognizer.h	2011-02-02 22:53:06 +0000
@@ -25,6 +25,12 @@
 
 #include "grail-gestures.h"
 
+enum recognition_state {
+	RECOGNIZING,
+	RECOGNIZED,
+	UNRECOGNIZED
+};
+
 struct gesture_recognizer {
 	struct move_model move;
 	struct combo_model drag;
@@ -34,6 +40,8 @@
 	struct combo_model winpinch;
 	struct combo_model winrotate;
 	struct tapping_model tapping;
+	utouch_frame_time_t start_time;
+	enum recognition_state state;
 };
 
 int gru_init(struct grail *ge);
 
=== modified file 'tools/grail-gesture.c'
--- tools/grail-gesture.c	2011-01-02 12:06:04 +0000
+++ tools/grail-gesture.c	2011-02-02 22:53:06 +0000
@@ -27,6 +27,7 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <stdlib.h>
 
 static grail_mask_t flag_mask[DIM_GRAIL_TYPE_BYTES];