1 files changed, 46 insertions, 127 deletions

diff --git a/src/grail-api.c b/src/grail-api.c
index 1071825..6521f84 100644
--- a/src/grail-api.c
+++ b/src/grail-api.c
@@ -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 = 200;
-
 void grail_filter_abs_events(struct grail *ge, int usage)
 {
         struct grail_impl *x = ge->impl;
@@ -132,62 +127,37 @@ 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)
+static void flush_events(struct grail *ge)
 {
-        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;
+        struct grail_impl *impl = ge->impl;
+        struct input_event ev;
+
+        grailbuf_clear(&impl->gbuf);
+        while (!evbuf_empty(&impl->evbuf)) {
+                evbuf_get(&impl->evbuf, &ev);
+                if (ge->event)
+                        ge->event(ge, &ev);
         }
+}
 
-        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);
+static void flush_gestures(struct grail *ge)
+{
+        struct grail_impl *impl = ge->impl;
+        struct grail_event ev;
+
+        evbuf_clear(&impl->evbuf);
+        while (!grailbuf_empty(&impl->gbuf)) {
+                grailbuf_get(&impl->gbuf, &ev);
+                if (ge->gesture)
+                        ge->gesture(ge, &ev);
         }
+}
 
-        return ge->get_clients(ge, &client, 1, pos, frame->num_active,
-                               types, DIM_GRAIL_TYPE_BYTES);
+static int gesture_timeout(struct grail *ge, const struct utouch_frame *frame)
+{
+        struct gesture_inserter *gin = ge->gin;
+
+        return grail_mask_count(gin->used, sizeof(gin->used)) == 0;
 }
 
 static void report_frame(struct grail *ge,
@@ -195,85 +165,27 @@ static void report_frame(struct grail *ge,
                          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;
+        if (frame->num_active && !frame->prev->num_active) {
+                impl->ongoing = 1;
+                impl->gesture = 0;
         }
 
-        /* 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 (!impl->ongoing)
+                return;
 
-        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;
-        }
+        gin_frame_begin(ge, frame);
+        gru_recognize(ge, frame);
+        gin_frame_end(ge, frame);
 
-        /* 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;
-        }
+        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)
@@ -288,6 +200,13 @@ static void grail_pump_mtdev(struct grail *ge, const struct input_event *ev)
                 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)