Replace touch logic with utouch frame engine

The original grail uses an internal touch framework and exports some
touch information as extended attributes to gesture events. This was
never quite the intention, but rather to expose gestures and touches
on a similar footing, such that grail can be input agnostic. This
patch starts off by replacing the internal touch framework with the
utouch-frame engine.

Signed-off-by: Henrik Rydberg <rydberg@euromail.se>

21 files changed, 259 insertions, 688 deletions

diff --git a/INSTALL b/INSTALL
index caaad65..629f0b8 100644
--- a/INSTALL
+++ b/INSTALL
@@ -1,7 +1,7 @@
 grail - Gesture Recognition And Instantiation Library
 
-To build, you need to have the autoconf, libtool and mtdev-dev packages
-installed. Then, do
+To build, you need to have the autoconf, libtool, mtdev-dev,
+libutouch-evemu-dev and libutouch-frame packages installed. Then, do
 
    ./autogen.sh
    ./configure
diff --git a/configure.ac b/configure.ac
index 0f75818..ceb9258 100644
--- a/configure.ac
+++ b/configure.ac
@@ -22,7 +22,9 @@ AC_PROG_LIBTOOL
 AC_PROG_CC
 AC_PROG_INSTALL
 
-PKG_CHECK_MODULES([MTDEV], [mtdev >= 1.0])
+PKG_CHECK_MODULES([MTDEV], [mtdev >= 1.1])
+PKG_CHECK_MODULES([EVEMU], [utouch-evemu >= 1.0])
+PKG_CHECK_MODULES([FRAME], [utouch-frame >= 1.0])
 
 AC_CONFIG_FILES([Makefile
                  src/Makefile
diff --git a/include/grail-touch.h b/include/grail-touch.h
deleted file mode 100644
index 9c63c80..0000000
--- a/include/grail-touch.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <rydberg@bitmath.org>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef _GRAIL_TOUCH_H
-#define _GRAIL_TOUCH_H
-
-#include <grail-bits.h>
-#include <mtdev.h>
-
-#define DIM_TOUCH 32
-#define DIM_TOUCH_BYTES ((DIM_TOUCH + 7) >> 3)
-
-typedef __u64 touch_time_t;
-
-struct touch {
-        int active;
-        int slot;
-        int id;
-        int tool_type;
-        int x, y;
-        int touch_major;
-        int touch_minor;
-        int width_major;
-        int width_minor;
-        int orientation;
-        int pressure;
-};
-
-struct touch_frame {
-        int nactive;
-        int ncreate, nmodify, ndestroy;
-        touch_time_t time;
-        grail_mask_t touches[DIM_TOUCH_BYTES];
-        struct touch *active[DIM_TOUCH];
-        struct touch touch[DIM_TOUCH];
-};
-
-struct touch_caps {
-        float min_x, max_x;
-        float min_y, max_y;
-        float min_orient, max_orient;
-        float min_press, max_press;
-};
-
-struct touch_dev {
-        void (*event)(struct touch_dev *dev, const struct input_event *ev);
-        void (*sync)(struct touch_dev *dev, const struct input_event *syn);
-        void *priv;
-        struct mtdev mtdev;
-        struct touch_frame frame;
-        struct touch_caps caps;
-        int slot;
-        int state;
-};
-
-int touch_caps_is_supported(struct touch_dev *dev, int fd);
-void touch_caps_init(struct touch_dev *dev);
-float touch_angle(const struct touch_dev *dev, int orientation);
-float touch_pressure(const struct touch_dev *dev, int pressure);
-
-int touch_dev_open(struct touch_dev *dev, int fd);
-int touch_dev_idle(struct touch_dev *dev, int fd, int ms);
-int touch_dev_pull(struct touch_dev *dev, int fd);
-void touch_dev_close(struct touch_dev *dev, int fd);
-
-#endif
diff --git a/src/Makefile.am b/src/Makefile.am
index dd2af2b..bb1c4c5 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -3,14 +3,14 @@ lib_LTLIBRARIES = libutouch-grail.la
 libutouch_grail_la_LDFLAGS = \
         -version-info @LIB_VERSION@ \
         -lm \
-        $(MTDEV_LIBS)
+        $(MTDEV_LIBS) \
+        $(EVEMU_LIBS) \
+        $(FRAME_LIBS)
 
 libutouch_grail_la_SOURCES = \
         evbuf.h \
         gebuf.h \
         grailbuf.h \
-        touch-dev.c \
-        touch-caps.c \
         grail-bits.c \
         grail-inserter.c \
         grail-inserter.h \
@@ -34,5 +34,4 @@ libutouch_grailincludedir = $(includedir)
 libutouch_grailinclude_HEADERS = \
         $(top_srcdir)/include/grail-bits.h \
         $(top_srcdir)/include/grail-types.h \
-        $(top_srcdir)/include/grail-touch.h \
         $(top_srcdir)/include/grail.h
diff --git a/src/gebuf.h b/src/gebuf.h
index 460e134..0cd9219 100644
--- a/src/gebuf.h
+++ b/src/gebuf.h
@@ -23,7 +23,7 @@
 #ifndef _GRAIL_GESTURE_BUFFER_H
 #define _GRAIL_GESTURE_BUFFER_H
 
-#include <grail.h>
+#include "grail-impl.h"
 
 #define DIM_GESTURE_EVENTS 512
 
@@ -31,7 +31,7 @@ struct gesture_event {
         int status;
         int ntouch;
         int nprop;
-        touch_time_t time;
+        utouch_frame_time_t time;
         struct grail_coord pos;
         grail_prop_t prop[DIM_GRAIL_PROP];
 };
diff --git a/src/gestures-drag.c b/src/gestures-drag.c
index 2ced765..05272da 100644
--- a/src/gestures-drag.c
+++ b/src/gestures-drag.c
@@ -35,7 +35,7 @@ static const int getype[DIM_TOUCH + 1] = {
 
 static void set_props(const struct gesture_inserter *gin,
                       struct combo_model *s, const struct move_model *m,
-                      const struct touch_frame *frame)
+                      const struct utouch_frame *frame)
 {
         if (m->single) {
                 s->prop[GRAIL_PROP_DRAG_DX] =
@@ -59,7 +59,7 @@ static void set_props(const struct gesture_inserter *gin,
 static const int fm_mask = 0x03;
 
 int gru_drag(struct grail *ge,
-            const struct touch_frame *frame)
+            const struct utouch_frame *frame)
 {
         struct gesture_recognizer *gru = ge->gru;
         struct combo_model *state = &gru->drag;
@@ -89,7 +89,7 @@ int gru_drag(struct grail *ge,
 }
 
 int gru_windrag(struct grail *ge,
-                const struct touch_frame *frame)
+                const struct utouch_frame *frame)
 {
         struct gesture_recognizer *gru = ge->gru;
         struct combo_model *state = &gru->windrag;
diff --git a/src/gestures-pinch.c b/src/gestures-pinch.c
index 45f1cb3..fa8a626 100644
--- a/src/gestures-pinch.c
+++ b/src/gestures-pinch.c
@@ -38,7 +38,7 @@ static const int fm_mask = 0x04;
 static void set_props(const struct gesture_inserter *gin,
                       struct combo_model *s,
                       const struct move_model *m,
-                      const struct touch_frame *frame)
+                      const struct utouch_frame *frame)
 {
         s->prop[GRAIL_PROP_PINCH_DR] = gin->scale_r * m->fm[FM_R].action_delta;
         s->prop[GRAIL_PROP_PINCH_VR] = gin->scale_r * m->fm[FM_R].velocity;
@@ -48,7 +48,7 @@ static void set_props(const struct gesture_inserter *gin,
 }
 
 int gru_pinch(struct grail *ge,
-              const struct touch_frame *frame)
+              const struct utouch_frame *frame)
 {
         struct gesture_recognizer *gru = ge->gru;
         struct combo_model *state = &gru->pinch;
@@ -79,7 +79,7 @@ int gru_pinch(struct grail *ge,
 }
 
 int gru_winpinch(struct grail *ge,
-                 const struct touch_frame *frame)
+                 const struct utouch_frame *frame)
 {
         struct gesture_recognizer *gru = ge->gru;
         struct combo_model *state = &gru->winpinch;
diff --git a/src/gestures-rotate.c b/src/gestures-rotate.c
index 8985257..fde0db8 100644
--- a/src/gestures-rotate.c
+++ b/src/gestures-rotate.c
@@ -37,7 +37,7 @@ static const int fm_mask = 0x08;
 
 static void set_props(const struct gesture_inserter *gin,
                       struct combo_model *s, const struct move_model *m,
-                      const struct touch_frame *frame)
+                      const struct utouch_frame *frame)
 {
         s->prop[GRAIL_PROP_ROTATE_DA] = m->fm[FM_A].action_delta;
         s->prop[GRAIL_PROP_ROTATE_VA] = m->fm[FM_A].velocity;
@@ -47,7 +47,7 @@ static void set_props(const struct gesture_inserter *gin,
 }
 
 int gru_rotate(struct grail *ge,
-               const struct touch_frame *frame)
+               const struct utouch_frame *frame)
 {
         struct gesture_recognizer *gru = ge->gru;
         struct combo_model *state = &gru->rotate;
@@ -78,7 +78,7 @@ int gru_rotate(struct grail *ge,
 }
 
 int gru_winrotate(struct grail *ge,
-                  const struct touch_frame *frame)
+                  const struct utouch_frame *frame)
 {
         struct gesture_recognizer *gru = ge->gru;
         struct combo_model *state = &gru->winrotate;
diff --git a/src/gestures-tapping.c b/src/gestures-tapping.c
index aa8e6d6..6d71642 100644
--- a/src/gestures-tapping.c
+++ b/src/gestures-tapping.c
@@ -30,7 +30,7 @@ static const int fm_mask = 0x07;
 
 static void set_props(const struct gesture_inserter *gin,
                       struct tapping_model *s, const struct move_model *m,
-                      const struct touch_frame *frame)
+                      const struct utouch_frame *frame)
 {
         s->prop[GRAIL_PROP_TAP_DT] = m->time - s->start;
         s->prop[GRAIL_PROP_TAP_X] = gin_prop_x(gin, m->fm[FM_X].value);
@@ -40,7 +40,7 @@ static void set_props(const struct gesture_inserter *gin,
 }
 
 int gru_tapping(struct grail *ge,
-                const struct touch_frame *frame)
+                const struct utouch_frame *frame)
 {
         struct gesture_recognizer *gru = ge->gru;
         struct tapping_model *state = &gru->tapping;
diff --git a/src/grail-api.c b/src/grail-api.c
index f38ca18..3aca75d 100644
--- a/src/grail-api.c
+++ b/src/grail-api.c
@@ -30,27 +30,124 @@
 #include <malloc.h>
 #include <errno.h>
 
-static void tp_event(struct touch_dev *dev,
-                     const struct input_event *ev)
+#define DIM_FRAMES 100
+#define FRAME_RATE 100
+
+void grail_filter_abs_events(struct grail *ge, int usage)
 {
-        struct grail *ge = dev->priv;
         struct grail_impl *x = ge->impl;
-        if (ev->type == EV_ABS) {
-                return;
+        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;
         }
-        if (ev->type == EV_KEY) {
-                switch (ev->code) {
-                case BTN_TOUCH:
-                case BTN_TOOL_FINGER:
-                case BTN_TOOL_DOUBLETAP:
-                case BTN_TOOL_TRIPLETAP:
-                case BTN_TOOL_QUADTAP:
-                        return;
-                }
+}
+
+int grail_open(struct grail *ge, int fd)
+{
+        struct grail_impl *x;
+        int ret;
+        x = calloc(1, sizeof(*x));
+        if (!x)
+                return -ENOMEM;
+
+        x->evemu = evemu_new(0);
+        if (!x->evemu) {
+                ret = -ENOMEM;
+                goto freemem;
         }
-        evbuf_put(&x->evbuf, ev);
+        ret = evemu_extract(x->evemu, fd);
+        if (ret)
+                goto freemem;
+        if (!utouch_frame_is_supported_mtdev(x->evemu)) {
+                ret = -ENODEV;
+                goto freemem;
+        }
+        x->mtdev = mtdev_new_open(fd);
+        if (!x->mtdev) {
+                ret = -ENOMEM;
+                goto freemem;
+        }
+
+        x->fh = utouch_frame_new_engine(DIM_FRAMES, DIM_TOUCH, FRAME_RATE);
+        if (!x->fh) {
+                ret = -ENOMEM;
+                goto freedev;
+        }
+        ret = utouch_frame_init_mtdev(x->fh, x->evemu);
+        if (ret)
+                goto freeframe;
+
+        init_impl(x);
+        ge->impl = x;
+
+        ret = gin_init(ge);
+        if (ret)
+                goto freeframe;
+
+        ret = gru_init(ge);
+        if (ret)
+                goto freegin;
+
+        return 0;
+ freegin:
+        gin_destroy(ge);
+ freeframe:
+        utouch_frame_delete_engine(x->fh);
+ freedev:
+        mtdev_close_delete(x->mtdev);
+ freemem:
+        evemu_delete(x->evemu);
+        free(x);
+        ge->impl = 0;
+        return ret;
+}
+
+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);
+        mtdev_close_delete(x->mtdev);
+        evemu_delete(x->evemu);
+        free(x);
+        ge->impl = 0;
 }
 
+int grail_idle(struct grail *ge, int fd, int ms)
+{
+        struct grail_impl *x = ge->impl;
+        return mtdev_idle(x->mtdev, fd, ms);
+}
+
+void grail_get_units(const struct grail *ge,
+                     struct grail_coord *min, struct grail_coord *max)
+{
+        struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
+        min->x = s->min_x;
+        min->y = s->min_y;
+        max->x = s->max_x;
+        max->y = s->max_y;
+}
+
+// legacy glue below
+
 static void evput(struct grail_impl *x, struct timeval time,
                   unsigned type, unsigned code, int value)
 {
@@ -76,47 +173,19 @@ static void report_up(struct grail_impl *impl, const struct input_event *syn)
         impl->report_status = 0;
 }
 
-#define SYSCALL(call) while (((call) == -1) && (errno == EINTR))
-
-static int getabs(struct input_absinfo *abs, int key, int fd)
-{
-        int rc;
-        SYSCALL(rc = ioctl(fd, EVIOCGABS(key), abs));
-        return rc >= 0;
-}
-
-static void set_emulation_caps(struct grail_impl *impl, int fd)
-{
-        struct touch_caps *emu = &impl->emu;
-        struct input_absinfo info;
-
-        memset(emu, 0, sizeof(*emu));
-
-        if (getabs(&info, ABS_X, fd)) {
-                emu->min_x = info.minimum;
-                emu->max_x = info.maximum;
-        }
-        if (getabs(&info, ABS_Y, fd)) {
-                emu->min_y = info.minimum;
-                emu->max_y = info.maximum;
-        }
-}
-
 static void set_pointer(struct grail_impl *impl)
 {
-        struct touch_dev *dev = &impl->dev;
-        struct touch_caps *caps = &dev->caps;
-        struct touch_caps *emu = &impl->emu;
-        struct touch_frame *frame = &dev->frame;
+        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;
         int i;
 
-        for (i = 0; i < frame->nactive; i++) {
-                struct touch *t = frame->active[i];
-                float u = (t->x - caps->min_x) / (caps->max_x - caps->min_x);
-                float v = (t->y - caps->min_y) / (caps->max_y - caps->min_y);
-                int x = emu->min_x + u * (emu->max_x - emu->min_x);
-                int y = emu->min_y + v * (emu->max_y - emu->min_y);
+        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;
@@ -181,15 +250,18 @@ static void handle_abs_events(struct grail *ge, const struct input_event *syn)
         }
 }
 
-static void tp_sync(struct touch_dev *dev,
-                    const struct input_event *syn)
+static void report_frame(struct grail *ge,
+                         const struct utouch_frame *frame,
+                         const struct input_event *syn)
 {
-        struct grail *ge = dev->priv;
+
         struct grail_impl *impl = ge->impl;
         int head = impl->evbuf.head;
         struct input_event iev;
         struct grail_event gev;
-        struct touch_frame *frame = &dev->frame;
+
+        ge->impl->frame = frame;
+
         gin_frame_begin(ge, frame);
         gru_recognize(ge, frame);
         gin_frame_end(ge, frame);
@@ -211,78 +283,42 @@ static void tp_sync(struct touch_dev *dev,
         }
 }
 
-void grail_filter_abs_events(struct grail *ge, int usage)
-{
-        struct grail_impl *x = ge->impl;
-        x->filter_abs = usage;
-}
-
-int grail_open(struct grail *ge, int fd)
-{
-        struct grail_impl *x;
-        int ret;
-        x = calloc(1, sizeof(*x));
-        if (!x)
-                return -ENOMEM;
-        ge->impl = x;
-
-        ret = touch_dev_open(&x->dev, fd);
-        if (ret)
-                goto freemem;
-        set_emulation_caps(x, fd);
-        x->dev.event = tp_event;
-        x->dev.sync = tp_sync;
-        x->dev.priv = ge;
-
-        ret = gin_init(ge);
-        if (ret)
-                goto freedev;
-
-        ret = gru_init(ge);
-        if (ret)
-                goto freegin;
-
-        return 0;
- freegin:
-        gin_destroy(ge);
- freedev:
-        touch_dev_close(&x->dev, fd);
- freemem:
-        free(x);
-        ge->impl = 0;
-        return ret;
-}
-
-void grail_close(struct grail *ge, int fd)
+static void grail_pump_mtdev(struct grail *ge, const struct input_event *ev)
 {
-        struct grail_impl *x = ge->impl;
-        void *status;
-        gru_destroy(ge);
-        gin_destroy(ge);
-        touch_dev_close(&x->dev, fd);
-        free(ge->impl);
-        ge->impl = 0;
-}
+        struct grail_impl *impl = ge->impl;
+        const struct utouch_frame *frame;
 
-int grail_idle(struct grail *ge, int fd, int ms)
-{
-        struct grail_impl *x = ge->impl;
-        return touch_dev_idle(&x->dev, fd, ms);
+        if (ev->type == EV_SYN || ev->type == EV_ABS) {
+                frame = utouch_frame_pump_mtdev(impl->fh, ev);
+                if (frame)
+                        report_frame(ge, frame, ev);
+        } else if (ev->type == EV_KEY) {
+                switch (ev->code) {
+                case BTN_TOUCH:
+                case BTN_TOOL_FINGER:
+                case BTN_TOOL_DOUBLETAP:
+                case BTN_TOOL_TRIPLETAP:
+                case BTN_TOOL_QUADTAP:
+                        break;
+                default:
+                        evbuf_put(&impl->evbuf, ev);
+                        break;
+                }
+        } else {
+                evbuf_put(&impl->evbuf, ev);
+        }
 }
 
 int grail_pull(struct grail *ge, int fd)
 {
-        struct grail_impl *x = ge->impl;
-        return touch_dev_pull(&x->dev, fd);
-}
+        struct grail_impl *impl = ge->impl;
+        struct input_event ev;
+        int ret, count = 0;
 
-void grail_get_units(const struct grail *ge,
-                     struct grail_coord *min, struct grail_coord *max)
-{
-        const struct touch_caps *caps = &ge->impl->dev.caps;
-        min->x = caps->min_x;
-        min->y = caps->min_y;
-        max->x = caps->max_x;
-        max->y = caps->max_y;
-}
+        while ((ret = mtdev_get(impl->mtdev, fd, &ev, 1)) > 0) {
+                grail_pump_mtdev(ge, &ev);
+                count++;
+        }
 
+        return count > 0 ? count : ret;
+}
diff --git a/src/grail-event.c b/src/grail-event.c
index 23fdbb3..9c0e437 100644
--- a/src/grail-event.c
+++ b/src/grail-event.c
@@ -28,17 +28,17 @@
 #include <math.h>
 
 static void compute_bbox(struct grail_coord *min, struct grail_coord *max,
-                         const struct touch_frame *frame)
+                         const struct utouch_frame *frame)
 {
         float x, y;
         int i;
-        if (frame->nactive < 1)
+        if (frame->num_active < 1)
                 return;
         x = frame->active[0]->x;
         y = frame->active[0]->y;
         min->x = max->x = x;
         min->y = max->y = y;
-        for (i = 1; i < frame->nactive; i++) {
+        for (i = 1; i < frame->num_active; i++) {
                 x = frame->active[i]->x;
                 y = frame->active[i]->y;
                 if (x < min->x)
@@ -53,10 +53,10 @@ static void compute_bbox(struct grail_coord *min, struct grail_coord *max,
 }
 
 int gin_add_contact_props(const struct gesture_inserter *gin,
-                          grail_prop_t *prop, const struct touch_frame *frame)
+                          grail_prop_t *prop, const struct utouch_frame *frame)
 {
         struct grail_coord min, max;
-        int i, n = 0, ntouch = frame->nactive;
+        int i, n = 0, ntouch = frame->num_active;
         if (!ntouch)
                 return n;
         if (ntouch > 5)
@@ -67,7 +67,7 @@ int gin_add_contact_props(const struct gesture_inserter *gin,
         prop[n++] = gin_prop_x(gin, max.x);
         prop[n++] = gin_prop_y(gin, max.y);
         for (i = 0; i < ntouch; i++) {
-                const struct touch *ct = frame->active[i];
+                const struct utouch_contact *ct = frame->active[i];
                 prop[n++] = ct->id;
                 prop[n++] = gin_prop_x(gin, ct->x);
                 prop[n++] = gin_prop_y(gin, ct->y);
@@ -79,15 +79,15 @@ int gin_get_clients(struct grail *ge,
                     struct grail_client_info *info, int maxinfo,
                     const grail_mask_t* types, int btypes,
                     const grail_mask_t* span, int bspan,
-                    const struct touch_frame *frame)
+                    const struct utouch_frame *frame)
 {
         struct grail_coord pos[DIM_TOUCH];
         int i, npos = 0;
         if (!ge->get_clients)
                 return 0;
         grail_mask_foreach(i, span, bspan) {
-                pos[npos].x = gin_prop_x(ge->gin, frame->touch[i].x);
-                pos[npos].y = gin_prop_y(ge->gin, frame->touch[i].y);
+                pos[npos].x = gin_prop_x(ge->gin, frame->slots[i]->x);
+                pos[npos].y = gin_prop_y(ge->gin, frame->slots[i]->y);
                 npos++;
         }
         return ge->get_clients(ge, info, maxinfo, pos, npos, types, btypes);
@@ -95,7 +95,7 @@ int gin_get_clients(struct grail *ge,
 
 void gin_send_event(struct grail *ge, struct slot_state *s,
                     const struct gesture_event *ev,
-                    const struct touch_frame *frame)
+                    const struct utouch_frame *frame)
 {
         struct grail_impl *impl = ge->impl;
         const struct gesture_inserter *gin = ge->gin;
@@ -121,15 +121,14 @@ void gin_send_event(struct grail *ge, struct slot_state *s,
 int grail_get_contacts(const struct grail *ge,
                        struct grail_contact *touch, int max_touch)
 {
-        const struct touch_dev *dev = &ge->impl->dev;
         const struct gesture_inserter *gin = ge->gin;
-        const struct touch_frame *frame = &dev->frame;
+        const struct utouch_frame *frame = ge->impl->frame;
         int i;
-        if (frame->nactive < max_touch)
-                max_touch = frame->nactive;
+        if (frame->num_active < max_touch)
+                max_touch = frame->num_active;
         for (i = 0; i < max_touch; i++) {
                 struct grail_contact *t = &touch[i];
-                const struct touch *ct = frame->active[i];
+                const struct utouch_contact *ct = frame->active[i];
                 t->id = ct->id;
                 t->tool_type = ct->tool_type;
                 t->pos.x = gin_prop_x(gin, ct->x);
@@ -138,8 +137,8 @@ int grail_get_contacts(const struct grail *ge,
                 t->touch_minor = gin->scale_r * ct->touch_minor;
                 t->width_major = gin->scale_r * ct->width_major;
                 t->width_minor = gin->scale_r * ct->width_minor;
-                t->angle = touch_angle(dev, ct->orientation);
-                t->pressure = touch_pressure(dev, ct->pressure);
+                t->angle = ct->orientation;
+                t->pressure = ct->pressure;
         }
         return max_touch;
 }
diff --git a/src/grail-gestures.c b/src/grail-gestures.c
index ed937a4..035a199 100644
--- a/src/grail-gestures.c
+++ b/src/grail-gestures.c
@@ -31,15 +31,15 @@ static const grail_time_t SAMPLE_MS = 10;
 static const float EPS = 1e-3;
 
 static void compute_position(float *x, float *y,
-                             const struct touch_frame *frame)
+                             const struct utouch_frame *frame)
 {
-        int i, n = frame->nactive;
+        int i, n = frame->num_active;
         *x = 0;
         *y = 0;
         if (n < 1)
                 return;
         for (i = 0; i < n; i++) {
-                const struct touch *t = frame->active[i];
+                const struct utouch_contact *t = frame->active[i];
                 *x += t->x;
                 *y += t->y;
         }
@@ -48,14 +48,14 @@ static void compute_position(float *x, float *y,
 }
 
 static float compute_radius(float x, float y,
-                            const struct touch_frame *frame)
+                            const struct utouch_frame *frame)
 {
-        int i, n = frame->nactive;
+        int i, n = frame->num_active;
         float r = 0, r2 = 0;
         if (n < 2)
                 return r;
         for (i = 0; i < n; i++) {
-                const struct touch *t = frame->active[i];
+                const struct utouch_contact *t = frame->active[i];
                 float dx = t->x - x;
                 float dy = t->y - y;
                 r2 += dx * dx + dy * dy;
@@ -66,16 +66,15 @@ static float compute_radius(float x, float y,
 }
 
 static float compute_rotation(float x, float y, float r,
-                              const struct touch_frame *prev,
-                              const struct touch_frame *frame)
+                              const struct utouch_frame *frame)
 {
-        int i, n = frame->nactive;
+        int i, n = frame->num_active;
         float da = 0, darc2 = 0;
         if (n < 2)
                 return da;
         for (i = 0; i < n; i++) {
-                const struct touch *t = frame->active[i];
-                const struct touch *ot = &prev->touch[t->slot];
+                const struct utouch_contact *t = frame->active[i];
+                const struct utouch_contact *ot = t->prev;
                 float dx = t->x - x;
                 float dy = t->y - y;
                 float mx = t->x - ot->x;
@@ -142,13 +141,13 @@ static void move_update(struct move_model *m, int i, float x, grail_time_t t)
 
 void gru_init_motion(struct grail *ge)
 {
-        struct touch_caps *caps = &ge->impl->dev.caps;
+        struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
         struct gesture_recognizer *gru = ge->gru;
         struct move_model *m = &gru->move;
         float D[DIM_FM];
         int i;
-        D[FM_X] = caps->max_x - caps->min_x;
-        D[FM_Y] = caps->max_y - caps->min_y;
+        D[FM_X] = s->max_x - s->min_x;
+        D[FM_Y] = s->max_y - s->min_y;
         D[FM_R] = sqrt(D[FM_X] * D[FM_X] + D[FM_Y] * D[FM_Y]);
         D[FM_A] = 2 * M_PI;
         for (i = 0; i < DIM_FM; i++) {
@@ -159,14 +158,15 @@ void gru_init_motion(struct grail *ge)
 }
 
 void gru_motion(struct grail *ge,
-                const struct touch_frame *frame)
+                const struct utouch_frame *frame)
 {
         struct gesture_recognizer *gru = ge->gru;
         struct move_model *m = &gru->move;
         grail_time_t t = frame->time;
         float x, y, r, a;
+
         compute_position(&x, &y, frame);
-        if (frame->ncreate || frame->ndestroy) {
+        if (frame->prev->revision != frame->revision) {
                 r = compute_radius(x, y, frame);
                 a = 0;
                 move_reset(m, FM_X, x, t);
@@ -175,7 +175,7 @@ void gru_motion(struct grail *ge,
                 move_reset(m, FM_A, a, t);
                 m->single = 0;
                 m->multi = 0;
-        } else if (frame->nactive < 2) {
+        } else if (frame->num_active < 2) {
                 r = 0;
                 a = 0;
                 move_update(m, FM_X, x, t);
@@ -190,7 +190,7 @@ void gru_motion(struct grail *ge,
                 r = compute_radius(x, y, frame);
                 r = move_filter(&m->fm[FM_R], r);
                 a = m->fm[FM_A].value;
-                a += compute_rotation(x, y, r, &gru->frame, frame);
+                a += compute_rotation(x, y, r, frame);
                 a = move_filter(&m->fm[FM_A], a);
                 move_update(m, FM_X, x, t);
                 move_update(m, FM_Y, y, t);
@@ -199,7 +199,7 @@ void gru_motion(struct grail *ge,
                 m->single = 0;
                 m->multi = 1;
         }
-        m->ntouch = frame->nactive;
+        m->ntouch = frame->num_active;
         m->time = t;
 }
 
diff --git a/src/grail-gestures.h b/src/grail-gestures.h
index 27108e9..69dd7e4 100644
--- a/src/grail-gestures.h
+++ b/src/grail-gestures.h
@@ -61,7 +61,7 @@ struct move_model {
 
 void gru_init_motion(struct grail *ge);
 void gru_motion(struct grail *ge,
-                const struct touch_frame *frame);
+                const struct utouch_frame *frame);
 void gru_event(struct grail *ge, int gid,
                const struct move_model *move,
                const grail_prop_t *prop, int nprop);
@@ -77,11 +77,11 @@ struct combo_model {
 };
 
 int gru_drag(struct grail *ge,
-             const struct touch_frame *frame);
+             const struct utouch_frame *frame);
 int gru_pinch(struct grail *ge,
-              const struct touch_frame *frame);
+              const struct utouch_frame *frame);
 int gru_rotate(struct grail *ge,
-               const struct touch_frame *frame);
+               const struct utouch_frame *frame);
 
 static inline int out_of_bounds(const struct combo_model *s,
                                 const struct move_model *m)
@@ -90,11 +90,11 @@ static inline int out_of_bounds(const struct combo_model *s,
 }
 
 int gru_windrag(struct grail *ge,
-                const struct touch_frame *frame);
+                const struct utouch_frame *frame);
 int gru_winpinch(struct grail *ge,
-                 const struct touch_frame *frame);
+                 const struct utouch_frame *frame);
 int gru_winrotate(struct grail *ge,
-                  const struct touch_frame *frame);
+                  const struct utouch_frame *frame);
 
 struct tapping_model {
         grail_time_t start, end;
@@ -105,7 +105,7 @@ struct tapping_model {
 };
 
 int gru_tapping(struct grail *ge,
-                const struct touch_frame *frame);
+                const struct utouch_frame *frame);
 
 #endif
 
diff --git a/src/grail-impl.h b/src/grail-impl.h
index 2859186..dcbaedd 100644
--- a/src/grail-impl.h
+++ b/src/grail-impl.h
@@ -23,15 +23,26 @@
 #ifndef _GRAIL_IMPL_H
 #define _GRAIL_IMPL_H
 
-#include <grail-touch.h>
+#define MTDEV_NO_LEGACY_API
+#define GRAIL_NO_LEGACY_API
+
+#include <grail.h>
+#include <utouch/frame-mtdev.h>
 #include "evbuf.h"
 #include "grailbuf.h"
 
+#define DIM_TOUCH               32
+#define DIM_TOUCH_BYTES         ((DIM_TOUCH + 7) >> 3)
+
 struct grail_impl {
-        struct touch_dev dev;
-        struct touch_caps emu;
+        struct evemu_device *evemu;
+        struct mtdev *mtdev;
+        utouch_frame_handle fh;
+        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;
diff --git a/src/grail-inserter.c b/src/grail-inserter.c
index 847995a..6f9a034 100644
--- a/src/grail-inserter.c
+++ b/src/grail-inserter.c
@@ -40,7 +40,7 @@ static int find_gslot(const struct gesture_inserter *gin, int gid)
 
 // todo: spanning tree for multi-user case
 static void setup_new_gestures(struct grail *ge,
-                               const struct touch_frame *frame)
+                               const struct utouch_frame *frame)
 {
         struct gesture_inserter *gin = ge->gin;
         grail_mask_t types[DIM_GRAIL_TYPE_BYTES];
@@ -100,14 +100,14 @@ void gin_destroy(struct grail *ge)
         ge->gin = NULL;
 }
 
-void gin_frame_begin(struct grail *ge, const struct touch_frame *frame)
+void gin_frame_begin(struct grail *ge, const struct utouch_frame *frame)
 {
         struct gesture_inserter *gin = ge->gin;
         memset(gin->types, 0, sizeof(gin->types));
         gin->time = frame->time;
 }
 
-void gin_frame_end(struct grail *ge, const struct touch_frame *frame)
+void gin_frame_end(struct grail *ge, const struct utouch_frame *frame)
 {
         struct gesture_inserter *gin = ge->gin;
         int i, hold = 0, discard = 0;
@@ -151,11 +151,12 @@ void gin_frame_end(struct grail *ge, const struct touch_frame *frame)
         }
 }
 
-int gin_gid_begin_select(struct grail *ge, int type, int priority,
-                         const grail_mask_t *span, int nspan)
+int gin_gid_begin(struct grail *ge, int type, int priority,
+                  const struct utouch_frame *frame)
 {
         struct gesture_inserter *gin = ge->gin;
         struct slot_state *s;
+        int slot;
         int i = grail_mask_get_first(gin->unused, sizeof(gin->unused));
         if (i < 0)
                 return -1;
@@ -165,7 +166,8 @@ int gin_gid_begin_select(struct grail *ge, int type, int priority,
         s->id = gin->gestureid++ & MAX_GESTURE_ID;
         s->status = GRAIL_STATUS_BEGIN;
         s->nclient = 0;
-        memcpy(s->span, span, nspan);
+        for (slot = 0; slot < DIM_TOUCH; slot++)
+                grail_mask_modify(s->span, slot, frame->slots[slot]->active);
         gebuf_clear(&s->buf);
         grail_mask_clear(gin->unused, i);
         grail_mask_set(gin->fresh, i);
@@ -173,13 +175,6 @@ int gin_gid_begin_select(struct grail *ge, int type, int priority,
         return s->id;
 }
 
-int gin_gid_begin(struct grail *ge, int type, int priority,
-                  const struct touch_frame *frame)
-{
-        return gin_gid_begin_select(ge, type, priority,
-                                    frame->touches, sizeof(frame->touches));
-}
-
 void gin_gid_discard(struct grail *ge, int gid)
 {
         struct gesture_inserter *gin = ge->gin;
@@ -248,18 +243,18 @@ void grail_set_bbox(struct grail *ge,
                     const struct grail_coord *tmin,
                     const struct grail_coord *tmax)
 {
-        struct touch_caps *caps = &ge->impl->dev.caps;
+        struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
         struct gesture_inserter *gin = ge->gin;
         double tx, ty, dx, dy, sx, sy;
         tx = tmax->x - tmin->x;
         ty = tmax->y - tmin->y;
-        dx = caps->max_x - caps->min_x;
-        dy = caps->max_y - caps->min_y;
+        dx = s->max_x - s->min_x;
+        dy = s->max_y - s->min_y;
         sx = tx / dx;
         sy = ty / dy;
         gin->scale_x = sx;
         gin->scale_y = sy;
         gin->scale_r = sqrt((tx * tx + ty * ty) / (dx * dx + dy * dy));
-        gin->trans_x = tmin->x - caps->min_x * sx;
-        gin->trans_y = tmin->y - caps->min_y * sy;
+        gin->trans_x = tmin->x - s->min_x * sx;
+        gin->trans_y = tmin->y - s->min_y * sy;
 }
diff --git a/src/grail-inserter.h b/src/grail-inserter.h
index 9baecb7..3b8cd77 100644
--- a/src/grail-inserter.h
+++ b/src/grail-inserter.h
@@ -23,8 +23,7 @@
 #ifndef _GRAIL_INSERTER_H
 #define _GRAIL_INSERTER_H
 
-#include <grail-touch.h>
-#include <grail.h>
+#include "grail-impl.h"
 #include "gebuf.h"
 
 #define DIM_EV_TYPE             EV_CNT
@@ -69,27 +68,25 @@ static inline float gin_prop_y(const struct gesture_inserter *gin, float y)
 }
 
 int gin_add_contact_props(const struct gesture_inserter *gin,
-                          grail_prop_t *prop, const struct touch_frame *frame);
+                          grail_prop_t *prop, const struct utouch_frame *frame);
 
 int gin_get_clients(struct grail *ge,
                     struct grail_client_info *info, int maxinfo,
                     const grail_mask_t* types, int btypes,
                     const grail_mask_t* span, int bspan,
-                    const struct touch_frame *frame);
+                    const struct utouch_frame *frame);
 void gin_send_event(struct grail *ge, struct slot_state *s,
                     const struct gesture_event *ev,
-                    const struct touch_frame *frame);
+                    const struct utouch_frame *frame);
 
 int gin_init(struct grail *ge);
 void gin_destroy(struct grail *ge);
 
-void gin_frame_begin(struct grail *ge, const struct touch_frame *frame);
-void gin_frame_end(struct grail *ge, const struct touch_frame *frame);
+void gin_frame_begin(struct grail *ge, const struct utouch_frame *frame);
+void gin_frame_end(struct grail *ge, const struct utouch_frame *frame);
 
-int gin_gid_begin_select(struct grail *ge, int type, int priority,
-                         const grail_mask_t *span, int nspan);
 int gin_gid_begin(struct grail *ge, int type, int priority,
-                  const struct touch_frame *frame);
+                  const struct utouch_frame *frame);
 void gin_gid_discard(struct grail *ge, int gid);
 
 void gin_gid_event(struct grail *ge, int gid,
diff --git a/src/grail-recognizer.c b/src/grail-recognizer.c
index 932f28a..fb0ae85 100644
--- a/src/grail-recognizer.c
+++ b/src/grail-recognizer.c
@@ -42,7 +42,7 @@ void gru_destroy(struct grail *ge)
         ge->gru = NULL;
 }
 
-void gru_recognize(struct grail *ge, const struct touch_frame *frame)
+void gru_recognize(struct grail *ge, const struct utouch_frame *frame)
 {
         if (!ge->gin || !ge->gru)
                 return;
@@ -54,5 +54,4 @@ void gru_recognize(struct grail *ge, const struct touch_frame *frame)
         gru_winpinch(ge, frame);
         gru_winrotate(ge, frame);
         gru_tapping(ge, frame);
-        ge->gru->frame = *frame;
 }
diff --git a/src/grail-recognizer.h b/src/grail-recognizer.h
index 1a9edd1..56e5b8d 100644
--- a/src/grail-recognizer.h
+++ b/src/grail-recognizer.h
@@ -26,7 +26,6 @@
 #include "grail-gestures.h"
 
 struct gesture_recognizer {
-        struct touch_frame frame;
         struct move_model move;
         struct combo_model drag;
         struct combo_model pinch;
@@ -38,7 +37,7 @@ struct gesture_recognizer {
 };
 
 int gru_init(struct grail *ge);
-void gru_recognize(struct grail *ge, const struct touch_frame *frame);
+void gru_recognize(struct grail *ge, const struct utouch_frame *frame);
 void gru_destroy(struct grail *ge);
 
 #endif
diff --git a/src/touch-caps.c b/src/touch-caps.c
deleted file mode 100644
index f99b0d7..0000000
--- a/src/touch-caps.c
+++ /dev/null
@@ -1,117 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <rydberg@bitmath.org>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include <grail-touch.h>
-#include <errno.h>
-#include <math.h>
-
-/* see mtdev-mapping.h */
-#define MTDEV_POSITION_X        5
-#define MTDEV_POSITION_Y        6
-#define MTDEV_ORIENTATION       4
-#define MTDEV_PRESSURE          10
-
-#define SYSCALL(call) while (((call) == -1) && (errno == EINTR))
-
-static const int bits_per_long = 8 * sizeof(long);
-
-static inline int nlongs(int nbit)
-{
-        return (nbit + bits_per_long - 1) / bits_per_long;
-}
-
-static inline int getbit(const unsigned long *map, int key)
-{
-        return (map[key / bits_per_long] >> (key % bits_per_long)) & 0x01;
-}
-
-int touch_caps_is_supported(struct touch_dev *dev, int fd)
-{
-        unsigned long keybits[nlongs(KEY_MAX)];
-        unsigned long absbits[nlongs(ABS_MAX)];
-        unsigned long relbits[nlongs(REL_CNT)];
-        int rc;
-
-        SYSCALL(rc = ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits));
-        if (rc < 0)
-                return 0;
-        SYSCALL(rc = ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbits)), absbits));
-        if (rc < 0)
-                return 0;
-        SYSCALL(rc = ioctl(fd, EVIOCGBIT(EV_REL, sizeof(relbits)), relbits));
-        if (rc < 0)
-                return 0;
-
-        /* only support pure absolute devices at this time */
-        if (getbit(relbits, REL_X) || getbit(relbits, REL_Y))
-                return 0;
-
-        if (dev->mtdev.caps.has_mtdata)
-                return 1;
-
-        return getbit(absbits, ABS_X) &&
-                getbit(absbits, ABS_Y) &&
-                getbit(keybits, BTN_TOUCH) &&
-                getbit(keybits, BTN_TOOL_DOUBLETAP);
-}
-
-void touch_caps_init(struct touch_dev *dev)
-{
-        const struct mtdev_caps *mt = &dev->mtdev.caps;
-        struct touch_caps *caps = &dev->caps;
-        caps->min_x = mt->abs[MTDEV_POSITION_X].minimum;
-        caps->max_x = mt->abs[MTDEV_POSITION_X].maximum;
-        caps->min_y = mt->abs[MTDEV_POSITION_Y].minimum;
-        caps->max_y = mt->abs[MTDEV_POSITION_Y].maximum;
-        caps->min_orient = mt->abs[MTDEV_ORIENTATION].minimum;
-        caps->max_orient = mt->abs[MTDEV_ORIENTATION].maximum;
-        caps->min_press = mt->abs[MTDEV_PRESSURE].minimum;
-        caps->max_press = mt->abs[MTDEV_PRESSURE].maximum;
-        if (caps->min_x == caps->max_x) {
-                caps->min_x = 0;
-                caps->max_x = 1024;
-        }
-        if (caps->min_y == caps->max_y) {
-                caps->min_y = 0;
-                caps->max_y = 768;
-        }
-        if (caps->min_orient == caps->max_orient)
-                caps->max_orient = 1;
-        if (caps->min_orient + caps->max_orient != 0)
-                caps->min_orient = -caps->max_orient;
-        if (caps->min_press == caps->max_press) {
-                caps->min_press = 0;
-                caps->max_press = 256;
-        }
-}
-
-float touch_angle(const struct touch_dev *dev, int orient)
-{
-        const struct touch_caps *caps = &dev->caps;
-        return orient / caps->max_orient * M_PI_2;
-}
-
-float touch_pressure(const struct touch_dev *dev, int press)
-{
-        const struct touch_caps *caps = &dev->caps;
-        return (press - caps->min_press) / (caps->max_press - caps->min_press);
-}
diff --git a/src/touch-dev.c b/src/touch-dev.c
deleted file mode 100644
index d8e192e..0000000
--- a/src/touch-dev.c
+++ /dev/null
@@ -1,264 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <rydberg@bitmath.org>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include <grail-touch.h>
-#include <malloc.h>
-#include <string.h>
-#include <errno.h>
-
-/* see mtdev-mapping.h */
-#define MTDEV_TOUCH_MINOR       1
-
-#define SET_PROP(name, value)                                           \
-        if (t->name != value) {                                         \
-                t->name = value;                                        \
-                frame->nmodify++;                                       \
-        }
-
-static void finish_touch(struct touch_dev *dev, struct touch_frame *frame)
-{
-        struct touch *t = &frame->touch[dev->slot];
-        if (t->touch_major && !t->touch_minor ||
-            !dev->mtdev.caps.has_abs[MTDEV_TOUCH_MINOR])
-                SET_PROP(touch_minor, t->touch_major);
-        if (dev->state > 0) {
-                t->active = 1;
-                grail_mask_set(frame->touches, dev->slot);
-                frame->ncreate++;
-        }
-        if (dev->state < 0) {
-                t->active = 0;
-                grail_mask_clear(frame->touches, dev->slot);
-                frame->ndestroy++;
-        }
-        dev->state = 0;
-}
-
-static void finish_legacy(struct touch_dev *dev, struct touch_frame *frame)
-{
-        static int trkid;
-        int i;
-        for (i = 0; i < frame->nactive; i++) {
-                struct touch *t = &frame->touch[i];
-                t->active = 1;
-                if (t->id < 0) {
-                        t->id = trkid++ & 0xffff;
-                        frame->ncreate++;
-                }
-                if (i > 0) {
-                        SET_PROP(x, frame->touch[0].x);
-                        SET_PROP(y, frame->touch[0].y);
-                        SET_PROP(pressure, frame->touch[0].pressure);
-                }
-                grail_mask_set(frame->touches, i);
-        }
-        for (i = frame->nactive; i < DIM_TOUCH; i++) {
-                struct touch *t = &frame->touch[i];
-                t->active = 0;
-                if (t->id >= 0) {
-                        t->id = -1;
-                        frame->ndestroy++;
-                }
-                grail_mask_clear(frame->touches, i);
-        }
-}
-
-static void finish_packet(struct touch_dev *dev,
-                          const struct input_event *syn)
-{
-        static const touch_time_t ms = 1000;
-        struct touch_frame *frame = &dev->frame;
-        int i, nslot = 0;
-        if (dev->mtdev.caps.has_mtdata)
-                finish_touch(dev, frame);
-        else
-                finish_legacy(dev, frame);
-        grail_mask_foreach(i, frame->touches, DIM_TOUCH_BYTES)
-                frame->active[nslot++] = &frame->touch[i];
-        frame->nactive = nslot;
-        frame->time = syn->time.tv_usec / ms + syn->time.tv_sec * ms;
-        if (dev->sync)
-                dev->sync(dev, syn);
-        frame->ncreate = 0;
-        frame->nmodify = 0;
-        frame->ndestroy = 0;
-}
-
-static int handle_abs_event(struct touch_dev *dev,
-                            const struct input_event *ev)
-{
-        struct touch_frame *frame = &dev->frame;
-        struct touch *t = &frame->touch[dev->slot];
-        switch (ev->code) {
-        case ABS_X:
-                if (dev->mtdev.caps.has_mtdata)
-                        return 0;
-                SET_PROP(x, ev->value);
-                return 0;
-        case ABS_Y:
-                if (dev->mtdev.caps.has_mtdata)
-                        return 0;
-                SET_PROP(y, ev->value);
-                return 0;
-        case ABS_PRESSURE:
-                if (dev->mtdev.caps.has_mtdata)
-                        return 0;
-                SET_PROP(pressure, ev->value);
-                return 0;
-        case ABS_MT_SLOT:
-                if (ev->value >= 0 && ev->value < DIM_TOUCH) {
-                        if (dev->slot != ev->value)
-                                finish_touch(dev, frame);
-                        dev->slot = ev->value;
-                        t = &frame->touch[dev->slot];
-                }
-                return 1;
-        case ABS_MT_POSITION_X:
-                SET_PROP(x, ev->value);
-                return 1;
-        case ABS_MT_POSITION_Y:
-                SET_PROP(y, ev->value);
-                return 1;
-        case ABS_MT_TOUCH_MAJOR:
-                SET_PROP(touch_major, ev->value);
-                return 1;
-        case ABS_MT_TOUCH_MINOR:
-                SET_PROP(touch_minor, ev->value);
-                return 1;
-        case ABS_MT_WIDTH_MAJOR:
-                SET_PROP(width_major, ev->value);
-                return 1;
-        case ABS_MT_WIDTH_MINOR:
-                SET_PROP(width_minor, ev->value);
-                return 1;
-        case ABS_MT_ORIENTATION:
-                SET_PROP(orientation, ev->value);
-                return 1;
-        case ABS_MT_PRESSURE:
-                SET_PROP(pressure, ev->value);
-                return 1;
-        case ABS_MT_TOOL_TYPE:
-                SET_PROP(tool_type, ev->value);
-                return 1;
-        case ABS_MT_TRACKING_ID:
-                if (t->id != ev->value) {
-                        if (t->id != MT_ID_NULL) {
-                                dev->state = -1;
-                                finish_touch(dev, frame);
-                        }
-                        if (ev->value != MT_ID_NULL)
-                                dev->state = 1;
-                        t->id = ev->value;
-                }
-                return 1;
-        default:
-                return 0;
-        }
-}
-
-static int handle_key_event(struct touch_dev *dev,
-                            const struct input_event *ev)
-{
-        struct touch_frame *frame = &dev->frame;
-        if (dev->mtdev.caps.has_mtdata)
-                return 0;
-        switch (ev->code) {
-        case BTN_TOUCH:
-                if (ev->value && !frame->nactive)
-                    frame->nactive = 1;
-                else if (!ev->value && frame->nactive)
-                    frame->nactive = 0;
-                return 0;
-        case BTN_TOOL_FINGER:
-                if (ev->value)
-                        frame->nactive = 1;
-                return 0;
-        case BTN_TOOL_DOUBLETAP:
-                if (ev->value)
-                        frame->nactive = 2;
-                return 0;
-        case BTN_TOOL_TRIPLETAP:
-                if (ev->value)
-                        frame->nactive = 3;
-                return 0;
-        case BTN_TOOL_QUADTAP:
-                if (ev->value)
-                        frame->nactive = 4;
-                return 0;
-        default:
-                return 0;
-        }
-}
-
-int touch_dev_open(struct touch_dev *dev, int fd)
-{
-        struct touch_frame *frame = &dev->frame;
-        int ret, i;
-        memset(dev, 0, sizeof(*dev));
-        for (i = 0; i < DIM_TOUCH; i++) {
-                struct touch *t = &frame->touch[i];
-                t->slot = i;
-                t->id = MT_ID_NULL;
-        }
-        ret = mtdev_open(&dev->mtdev, fd);
-        if (!ret && !touch_caps_is_supported(dev, fd))
-                ret = -ENODEV;
-        if (ret)
-                goto error;
-        touch_caps_init(dev);
-        return 0;
- error:
-        return ret;
-}
-
-int touch_dev_idle(struct touch_dev *dev, int fd, int ms)
-{
-        return mtdev_idle(&dev->mtdev, fd, ms);
-}
-
-int touch_dev_pull(struct touch_dev *dev, int fd)
-{
-        struct input_event ev;
-        int ret, count = 0, consumed;
-        while ((ret = mtdev_get(&dev->mtdev, fd, &ev, 1)) > 0) {
-                consumed = 0;
-                if (ev.type == EV_SYN) {
-                        if (ev.code == SYN_REPORT)
-                                finish_packet(dev, &ev);
-                        consumed++;
-                } else if (ev.type == EV_ABS) {
-                        consumed += handle_abs_event(dev, &ev);
-                } else if (ev.type == EV_KEY) {
-                        consumed += handle_key_event(dev, &ev);
-                }
-                if (!consumed && dev->event)
-                        dev->event(dev, &ev);
-                count++;
-        }
-        return count > 0 ? count : ret;
-}
-
-void touch_dev_close(struct touch_dev *dev, int fd)
-{
-        mtdev_close(&dev->mtdev);
-        memset(dev, 0, sizeof(*dev));
-}
diff --git a/tools/Makefile.am b/tools/Makefile.am
index ae6866c..303f70d 100644
--- a/tools/Makefile.am
+++ b/tools/Makefile.am
@@ -4,4 +4,4 @@ INCLUDES=-I$(top_srcdir)/include/
 
 grail_gesture_SOURCES = grail-gesture.c
 grail_gesture_LDFLAGS = -L$(top_builddir)/src/.libs/ \
-        -lutouch-grail -lmtdev -lm
+        -lutouch-grail -lutouch-frame -lutouch-evemu -lmtdev -lm