2 files changed, 144 insertions, 18 deletions

diff --git a/src/grail-api.c b/src/grail-api.c
index 22724ee..1071825 100644
--- a/src/grail-api.c
+++ b/src/grail-api.c
@@ -34,6 +34,11 @@
 #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 = 200;
+
 void grail_filter_abs_events(struct grail *ge, int usage)
 {
         struct grail_impl *x = ge->impl;
@@ -127,34 +132,147 @@ void grail_get_units(const struct grail *ge,
         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 report_frame(struct grail *ge,
                          const struct utouch_frame *frame,
                          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;
 
-        gin_frame_begin(ge, frame);
-        gru_recognize(ge, frame);
-        gin_frame_end(ge, frame);
-
-        if (grailbuf_empty(&impl->gbuf)) {
-                while (!evbuf_empty(&impl->evbuf)) {
-                        evbuf_get(&impl->evbuf, &iev);
-                        if (ge->event)
-                                ge->event(ge, &iev);
-                }
-        } else {
-                while (!grailbuf_empty(&impl->gbuf)) {
-                        grailbuf_get(&impl->gbuf, &gev);
-                        if (ge->gesture)
-                                ge->gesture(ge, &gev);
-                }
-                evbuf_clear(&impl->evbuf);
+        /* 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)))
+                        gru->state = RECOGNIZED;
+                /* 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 RECOGNIZED:
+                        while (!grailbuf_empty(&impl->gbuf)) {
+                                grailbuf_get(&impl->gbuf, &gev);
+                                if (ge->gesture)
+                                        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;
+                        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);
+
+                        /* Once all touches are lifted, reset recognition
+                         * state. */
+                        if (frame->num_active == 0)
+                                gru->state = RECOGNIZING;
+                        break;
         }
 }
 
diff --git a/src/grail-recognizer.h b/src/grail-recognizer.h
index 56e5b8d..b08ff34 100644
--- a/src/grail-recognizer.h
+++ b/src/grail-recognizer.h
@@ -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 gesture_recognizer {
         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);