Split the code into recognizer and inserter

Refactor code to make more room for gesture recognition. Also simplify
public headers.

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

1 files changed, 43 insertions, 90 deletions

diff --git a/src/grail-api.c b/src/grail-api.c
index dbe4977..19b66aa 100644
--- a/src/grail-api.c
+++ b/src/grail-api.c
@@ -1,4 +1,5 @@
-#include <grail-gesture.h>
+#include "grail-inserter.h"
+#include "grail-recognizer.h"
 #include <grail.h>
 #include <string.h>
 #include <stdio.h>
@@ -6,93 +7,46 @@
 #include <fcntl.h>
 #include <malloc.h>
 #include <errno.h>
+#include "evbuf.h"
 
 struct grail_impl {
         struct touch_dev dev;
         struct touch_engine engine;
-        struct touch_frame frame;
-        struct gesture_dev gedev;
-        struct gesture_client client;
-        touch_time_t last_scroll;
+        struct evbuf evbuf;
 };
 
-static void gh_handle(struct grail_impl *gh,
-                      const struct touch_frame *frame,
-                      touch_time_t time)
-{
-#if 0
-        struct gesture_flag flag;
-        struct grail_event ev;
-        if (frame->ntouch == 1 || frame->ntouch == 2) {
-                flag.type = GE_MOVE;
-                flag.time = time;
-                flag.state = GS_BEGIN;
-                gedev_flag(&gh->dev, &flag);
-
-                ev.type = GE_MOVE;
-                ev.time = time;
-                ev.prop[0] =
-                        frame->touch[0].prop[TP_POS_X] -
-                        gh->frame.touch[0].prop[TP_POS_X];
-                ev.prop[1] =
-                        frame->touch[0].prop[TP_POS_Y] -
-                        gh->frame.touch[0].prop[TP_POS_Y];
-                if (ev.prop[0] || ev.prop[1])
-                        gedev_event(&gh->dev, &ev);
-
-                flag.time = time + 1;
-                flag.state = GS_END;
-                gedev_flag(&gh->dev, &flag);
-        }
-        if (frame->ntouch == 2) {
-                flag.type = GE_VSCROLL;
-                flag.time = time;
-                flag.state = GS_BEGIN;
-                gedev_flag(&gh->dev, &flag);
-
-                ev.type = GE_VSCROLL;
-                ev.time = time;
-                ev.prop[0] =
-                        frame->touch[0].prop[TP_POS_Y] -
-                        gh->frame.touch[0].prop[TP_POS_Y];
-
-                if (ev.prop[0])
-                        gedev_event(&gh->dev, &ev);
-
-                if (time > gh->last_scroll + 100) {
-                        flag.time = time + 1;
-                        flag.state = GS_END;
-                        gedev_flag(&gh->dev, &flag);
-                        gh->last_scroll = time;
-                }
-        } else {
-                flag.type = GE_VSCROLL;
-                flag.time = time;
-                flag.state = GS_CANCEL;
-                gedev_flag(&gh->dev, &flag);
-        }
-        gedev_sync(&gh->dev);
-        gh->frame = *frame;
-#endif
-}
-
 static void tp_event(struct touch_engine *engine,
                      const struct input_event *ev)
 {
         struct grail *ge = engine->priv;
-        if (ge->event)
-                ge->event(ge, ev);
+        struct grail_impl *x = ge->impl;
+        evbuf_put(&x->evbuf, ev);
 }
 
 static void tp_sync(struct touch_engine *engine,
                     const struct input_event *syn)
 {
+        struct input_event ev;
         struct grail *ge = engine->priv;
-#if 0
+        struct grail_impl *x = ge->impl;
         struct touch_frame *frame = &engine->frame;
-        gh_handle(ge, frame, frame->time);
-#endif
-        if (ge->event)
+        grail_mask_t filtered[DIM_EV_TYPE_BYTES];
+        int nevent = 0;
+        gin_frame_begin(ge, frame->time);
+        gru_recognize(ge, frame);
+        gin_frame_end(ge, filtered);
+        if (!ge->event) {
+                evbuf_clear(&x->evbuf);
+                return;
+        }
+        while (!evbuf_empty(&x->evbuf)) {
+                evbuf_get(&x->evbuf, &ev);
+                if (grail_get_mask(filtered, ev.type))
+                        continue;
+                ge->event(ge, &ev);
+                nevent++;
+        }
+        if (nevent)
                 ge->event(ge, syn);
 }
 
@@ -103,49 +57,48 @@ int grail_open(struct grail *ge, int fd)
         x = calloc(1, sizeof(*x));
         if (!x)
                 return -ENOMEM;
+        ret = gin_init(ge);
+        if (ret)
+                goto freemem;
+        ret = gru_init(ge);
+        if (ret)
+                goto freedev;
         ret = touch_dev_open(&x->dev, fd);
         if (ret)
-                goto error;
+                goto freegru;
         touch_engine_init(&x->engine, tp_event, tp_sync, ge);
         touch_engine_attach(&x->engine, &x->dev);
         ge->impl = x;
         return 0;
- error:
+ freegru:
+        gru_destroy(ge);
+ freedev:
+        gin_destroy(ge);
+ freemem:
         free(x);
         return ret;
 }
 
-int grail_idle(struct grail *ge, int fd, int ms)
-{
-        struct grail_impl *x = ge->impl;
-        return touch_dev_idle(&x->dev, fd, ms);
-}
-
-int grail_pull(struct grail *ge, int fd)
-{
-        struct grail_impl *x = ge->impl;
-        return touch_dev_pull(&x->dev, fd);
-}
-
 void grail_close(struct grail *ge, int fd)
 {
         struct grail_impl *x = ge->impl;
         touch_engine_detach(&x->engine, &x->dev);
         touch_dev_close(&x->dev, fd);
+        gru_destroy(ge);
+        gin_destroy(ge);
         free(ge->impl);
         ge->impl = 0;
 }
 
-void grail_add_client(struct grail *ge, grail_clientid_t id,
-                      const int *types, const int *priority, int ntypes)
+int grail_idle(struct grail *ge, int fd, int ms)
 {
         struct grail_impl *x = ge->impl;
-        //gedev_attach_client(&x->dev, &x->client);
+        return touch_dev_idle(&x->dev, fd, ms);
 }
 
-void grail_remove_client(struct grail *ge, grail_clientid_t id)
+int grail_pull(struct grail *ge, int fd)
 {
         struct grail_impl *x = ge->impl;
-        //gedev_detach_client(&x->dev, &x->client);
+        return touch_dev_pull(&x->dev, fd);
 }