Introduce tapping

Simplify some common parts of the recognizer code and add tapping
to the gesture suite.

Signed-off-by: Henrik Rydberg <rydberg@bitmath.org>

1 files changed, 75 insertions, 32 deletions

diff --git a/src/grail-inserter.c b/src/grail-inserter.c
index 3927875..4bf78d3 100644
--- a/src/grail-inserter.c
+++ b/src/grail-inserter.c
@@ -29,6 +29,24 @@
 
 static const int MAX_GESTURE_ID = 0xfff;
 
+struct gesture_inserter {
+        struct slot_state state[DIM_INSTANCE];
+        grail_mask_t unused[DIM_INSTANCE_BYTES];
+        grail_mask_t fresh[DIM_INSTANCE_BYTES];
+        grail_mask_t used[DIM_INSTANCE_BYTES];
+        grail_time_t time;
+        int gestureid;
+};
+
+static int find_gslot(const struct gesture_inserter *gin, int gid)
+{
+        int i;
+        grail_mask_foreach(i, gin->used, sizeof(gin->used))
+                if (gin->state[i].id == gid)
+                        return i;
+        return -1;
+}
+
 static void send_event(struct grail *ge, struct slot_state *s,
                        const struct gesture_event *ev)
 {
@@ -151,7 +169,7 @@ void gin_frame_end(struct grail *ge,
         grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
                 struct slot_state *s = &gin->state[i];
                 if (!s->nclient || s->priority < discard)
-                        gin_gesture_discard(gin, i);
+                        gin_gid_discard(ge, s->id);
         }
 
         grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
@@ -169,22 +187,22 @@ void gin_frame_end(struct grail *ge,
         grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
                 struct slot_state *s = &gin->state[i];
                 if (s->status == GRAIL_STATUS_END)
-                        gin_gesture_discard(gin, i);
+                        gin_gid_discard(ge, s->id);
         }
 
         if (grail_mask_count(span, sizeof(span)))
                 grail_mask_set(filtered, EV_ABS);
 }
 
-int gin_gesture_begin(struct grail *ge, int type, int priority,
-                      const grail_mask_t *span, int nspan)
+int gin_gid_begin_select(struct grail *ge, int type, int priority,
+                         const grail_mask_t *span, int nspan)
 {
         struct gesture_inserter *gin = ge->gin;
         struct slot_state *s;
-        int geslot = grail_mask_get_first(gin->unused, sizeof(gin->unused));
-        if (geslot < 0)
+        int i = grail_mask_get_first(gin->unused, sizeof(gin->unused));
+        if (i < 0)
                 return -1;
-        s = &gin->state[geslot];
+        s = &gin->state[i];
         s->type = type;
         s->priority = priority;
         s->id = gin->gestureid++ & MAX_GESTURE_ID;
@@ -192,47 +210,72 @@ int gin_gesture_begin(struct grail *ge, int type, int priority,
         s->nclient = 0;
         memcpy(s->span, span, nspan);
         gebuf_clear(&s->buf);
-        grail_mask_clear(gin->unused, geslot);
-        grail_mask_set(gin->fresh, geslot);
-        grail_mask_set(gin->used, geslot);
-        return geslot;
-}
-
-void gin_gesture_end(struct gesture_inserter *gin, int geslot)
-{
-        gin->state[geslot].status = GRAIL_STATUS_END;
+        grail_mask_clear(gin->unused, i);
+        grail_mask_set(gin->fresh, i);
+        grail_mask_set(gin->used, i);
+        return s->id;
 }
 
-void gin_gesture_discard(struct gesture_inserter *gin, int geslot)
+int gin_gid_begin(struct grail *ge, int type, const struct touch_frame *frame)
 {
-        gebuf_clear(&gin->state[geslot].buf);
-        gin_gesture_end(gin, geslot);
-        grail_mask_clear(gin->used, geslot);
-        grail_mask_set(gin->unused, geslot);
+        return gin_gid_begin_select(ge, type, 1,
+                                    frame->touches, sizeof(frame->touches));
 }
 
-void gin_gesture_discard_type(struct gesture_inserter *gin, int type)
+void gin_gid_discard(struct grail *ge, int gid)
 {
-        int i;
-        grail_mask_foreach(i, gin->used, sizeof(gin->used))
-                if (gin->state[i].type == type)
-                        gin_gesture_discard(gin, i);
+        struct gesture_inserter *gin = ge->gin;
+        struct slot_state *s;
+        int i = find_gslot(gin, gid);
+        if (i < 0)
+                return;
+        s = &gin->state[i];
+        gebuf_clear(&s->buf);
+        s->status = GRAIL_STATUS_END;
+        grail_mask_clear(gin->used, i);
+        grail_mask_set(gin->unused, i);
 }
 
-void gin_gesture_event(struct gesture_inserter *gin, int geslot,
-                       float x, float y, int ntouch,
-                       const grail_prop_t *prop, int nprop)
+void gin_gid_event(struct grail *ge, int gid,
+                   float x, float y, int ntouch,
+                   const grail_prop_t *prop, int nprop,
+                   int status)
 {
-        struct slot_state *s = &gin->state[geslot];
+        struct gesture_inserter *gin = ge->gin;
         struct gesture_event ev;
+        struct slot_state *s;
+        int i = find_gslot(gin, gid);
+        if (i < 0)
+                return;
+        s = &gin->state[i];
         ev.ntouch = ntouch;
         ev.nprop = nprop;
         ev.time = gin->time;
         ev.pos.x = x;
         ev.pos.y = y;
         memcpy(ev.prop, prop, nprop * sizeof(grail_prop_t));
-        if (s->status == GRAIL_STATUS_BEGIN)
-                s->status = GRAIL_STATUS_UPDATE;
         gebuf_put(&s->buf, &ev);
+        if (s->status == GRAIL_STATUS_BEGIN)
+                s->status = status;
 }
 
+void gin_gid_end(struct grail *ge, int gid,
+                 float x, float y, int ntouch)
+{
+        struct gesture_inserter *gin = ge->gin;
+        struct gesture_event ev;
+        struct slot_state *s;
+        int i = find_gslot(gin, gid);
+        if (i < 0)
+                return;
+        s = &gin->state[i];
+        if (s->status != GRAIL_STATUS_BEGIN) {
+                ev.ntouch = ntouch;
+                ev.nprop = 0;
+                ev.time = gin->time;
+                ev.pos.x = x;
+                ev.pos.y = y;
+                gebuf_put(&s->buf, &ev);
+        }
+        s->status = GRAIL_STATUS_END;
+}