Merge lp:~oif-team/grail/trunk.whatversion into lp:grail

[Henrik Rydberg]

Here is the first step in a series of transformations for grail. The major problem in this one is that the grail ABI is intact, but there are symbols in grail1 which never should have been exported: gin and gru. Also, the touch symbols were not really intended for public use. This patch series removes all gin/gru/touch symbols, and replaces the internal touch logic with utouch-frame. Removing symbols should normally warrant an ABI change. However, the grail usage in all our packages so far are intact. So what version to give this change?

[Stephen M. Webb (bregma)]

An ABI-breaking change becomes obvious fairly quickly if it affects a developer. If someone is using the undocumented API and their stuff breaks, they can use the readelf tool to determine the symbols are missing and we can point them at the changelogs. Leaving the library version unaltered can save a lot of grief with the downstream Ubuntu people.

This merge builds OK after pulling in the latest unpackaged mtdev, evemu, and frame libraries and runs alright with geistest and the grail-gesture tool on maverick, so I'd give it a pass.

review: Approve

[Chase Douglas (chasedouglas)]

I don't have bandwidth to do a real code review on this :(. We're still in development phase, so if any issues come out we can fix them up.

I agree with Stephen in that the major API number should be left the same. As for the intricate details of so versioning, I think Stephen understands them better than I do, so I'll defer to him there too.

[Henrik Rydberg (rydberg)]

Ok great - I will repackage using 1.0.18 to start with, and 1.1 once the actual api changes are in place.

[lp:~oif-team/grail/trunk.whatversion]

107. By Henrik Rydberg on 2011-01-03

Bump to v1.0.18

The grail symbols are intact and abi compatible, whereas the remaining
symbols, which should not really be present, have all been
removed. Since the remaining symbols represent the actual official
API, this is not considered an ABI breakage.

Unmerged revisions

=== modified file 'INSTALL'
--- INSTALL	2010-08-05 20:48:38 +0000
+++ INSTALL	2011-01-02 12:29:53 +0000
@@ -1,19 +1,12 @@
 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
    make
 
-To test the touch properties of an MT device at /dev/input/eventX, do
-
-   sudo ./test/grail-touch /dev/input/eventX
-
-You should be able to see touch events in the terminal. After five
-seconds of inactivity, the program exits.
-
 To test gestures, do
 
    sudo ./test/grail-gesture 0xffffffff /dev/input/eventX

=== modified file 'Makefile.am'
--- Makefile.am	2010-08-12 15:55:30 +0000
+++ Makefile.am	2011-01-02 12:29:53 +0000
@@ -1,4 +1,4 @@
-SUBDIRS = src test
+SUBDIRS = src test tools
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = utouch-grail.pc

=== modified file 'configure.ac'
--- configure.ac	2010-11-17 16:29:52 +0000
+++ configure.ac	2011-01-02 12:29:53 +0000
@@ -1,7 +1,7 @@
 # Initialize Autoconf
 AC_PREREQ([2.60])
 AC_INIT([Gesture Recognition And Instantiation Library],
-        [1.0.17],
+        [1.0.18],
         [],
         [utouch-grail])
 AC_CONFIG_SRCDIR([Makefile.am])
@@ -22,10 +22,14 @@
 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
+                 tools/Makefile
                  test/Makefile
+		 utouch-grail.sym
                  utouch-grail.pc])
 AC_OUTPUT

=== removed file 'include/grail-touch.h'
--- include/grail-touch.h	2010-09-10 12:00:27 +0000
+++ include/grail-touch.h	1970-01-01 00:00:00 +0000
@@ -1,85 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
- *
- * 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

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2010-08-20 06:45:26 +0000
+++ src/Makefile.am	2011-01-02 12:29:53 +0000
@@ -2,14 +2,16 @@
 
 libutouch_grail_la_LDFLAGS = \
 	-version-info @LIB_VERSION@ \
+	-export-symbols ../utouch-grail.sym \
 	-lm \
-	$(MTDEV_LIBS)
+	$(MTDEV_LIBS) \
+	$(EVEMU_LIBS) \
+	$(FRAME_LIBS)
 
 libutouch_grail_la_SOURCES = \
 	evbuf.h \
 	gebuf.h \
-	touch-dev.c \
-	touch-caps.c \
+	grailbuf.h \
 	grail-bits.c \
 	grail-inserter.c \
 	grail-inserter.h \
@@ -33,5 +35,4 @@
 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

=== modified file 'src/gebuf.h'
--- src/gebuf.h	2010-08-07 20:21:27 +0000
+++ src/gebuf.h	2011-01-02 12:29:53 +0000
@@ -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 @@
 	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];
 };

=== modified file 'src/gestures-drag.c'
--- src/gestures-drag.c	2010-08-26 14:39:58 +0000
+++ src/gestures-drag.c	2011-01-02 12:29:53 +0000
@@ -35,7 +35,7 @@
 
 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 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_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;

=== modified file 'src/gestures-pinch.c'
--- src/gestures-pinch.c	2010-08-19 20:36:11 +0000
+++ src/gestures-pinch.c	2011-01-02 12:29:53 +0000
@@ -38,7 +38,7 @@
 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 @@
 }
 
 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_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;

=== modified file 'src/gestures-rotate.c'
--- src/gestures-rotate.c	2010-08-19 20:36:11 +0000
+++ src/gestures-rotate.c	2011-01-02 12:29:53 +0000
@@ -37,7 +37,7 @@
 
 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 @@
 }
 
 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_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;

=== modified file 'src/gestures-tapping.c'
--- src/gestures-tapping.c	2010-09-21 11:26:43 +0000
+++ src/gestures-tapping.c	2011-01-02 12:29:53 +0000
@@ -30,7 +30,7 @@
 
 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 @@
 }
 
 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;

=== modified file 'src/grail-api.c'
--- src/grail-api.c	2010-11-17 16:29:28 +0000
+++ src/grail-api.c	2011-01-02 12:29:53 +0000
@@ -30,26 +30,123 @@
 #include <malloc.h>
 #include <errno.h>
 
-static void tp_event(struct touch_dev *dev,
-		     const struct input_event *ev)
-{
-	struct grail *ge = dev->priv;
-	struct grail_impl *x = ge->impl;
-	if (ev->type == EV_ABS) {
-		return;
-	}
-	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;
-		}
-	}
-	evbuf_put(&x->evbuf, ev);
-}
+#define DIM_FRAMES 100
+#define FRAME_RATE 100
+
+void grail_filter_abs_events(struct grail *ge, int usage)
+{
+	struct grail_impl *x = ge->impl;
+	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;
+	}
+}
+
+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;
+	}
+	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 @@
 	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,105 +250,75 @@
 	}
 }
 
-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 input_event ev;
-	struct grail *ge = dev->priv;
+
 	struct grail_impl *impl = ge->impl;
-	struct touch_frame *frame = &dev->frame;
-	int nevent = 0;
+	int head = impl->evbuf.head;
+	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 (!ge->event) {
-		evbuf_clear(&impl->evbuf);
-		return;
-	}
 	if (!impl->filter_abs)
 		handle_abs_events(ge, syn);
+	if (impl->evbuf.head != head)
+		evbuf_put(&impl->evbuf, syn);
+
+	while (!grailbuf_empty(&impl->gbuf)) {
+		grailbuf_get(&impl->gbuf, &gev);
+		if (ge->gesture)
+			ge->gesture(ge, &gev);
+	}
 	while (!evbuf_empty(&impl->evbuf)) {
-		evbuf_get(&impl->evbuf, &ev);
-		ge->event(ge, &ev);
-		nevent++;
-	}
-	if (nevent)
-		ge->event(ge, syn);
-}
-
-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)
-{
-	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;
-}
-
-int grail_idle(struct grail *ge, int fd, int ms)
-{
-	struct grail_impl *x = ge->impl;
-	return touch_dev_idle(&x->dev, fd, ms);
+		evbuf_get(&impl->evbuf, &iev);
+		if (ge->event)
+			ge->event(ge, &iev);
+	}
+}
+
+static void grail_pump_mtdev(struct grail *ge, const struct input_event *ev)
+{
+	struct grail_impl *impl = ge->impl;
+	const struct utouch_frame *frame;
+
+	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);
-}
-
-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;
-}
-
+	struct grail_impl *impl = ge->impl;
+	struct input_event ev;
+        int ret, count = 0;
+
+        while ((ret = mtdev_get(impl->mtdev, fd, &ev, 1)) > 0) {
+		grail_pump_mtdev(ge, &ev);
+                count++;
+        }
+
+        return count > 0 ? count : ret;
+}

=== modified file 'src/grail-event.c'
--- src/grail-event.c	2010-08-19 20:36:11 +0000
+++ src/grail-event.c	2011-01-02 12:29:53 +0000
@@ -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 @@
 }
 
 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 @@
 	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 @@
 		    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,8 +95,9 @@
 
 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;
 	struct grail_event gev;
 	int i;
@@ -113,22 +114,21 @@
 	memcpy(gev.prop, ev->prop, ev->nprop * sizeof(grail_prop_t));
 	for (i = 0; i < s->nclient; i++) {
 		gev.client_id = s->client_id[i];
-		ge->gesture(ge, &gev);
+		grailbuf_put(&impl->gbuf, &gev);
 	}
 }
 
 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);
@@ -137,8 +137,8 @@
 		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;
 }

=== modified file 'src/grail-gestures.c'
--- src/grail-gestures.c	2010-09-10 12:09:48 +0000
+++ src/grail-gestures.c	2011-01-02 12:29:53 +0000
@@ -31,15 +31,15 @@
 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 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_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 @@
 
 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_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 @@
 		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 @@
 		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 @@
 		m->single = 0;
 		m->multi = 1;
 	}
-	m->ntouch = frame->nactive;
+	m->ntouch = frame->num_active;
 	m->time = t;
 }
 

=== modified file 'src/grail-gestures.h'
--- src/grail-gestures.h	2010-09-21 11:26:43 +0000
+++ src/grail-gestures.h	2011-01-02 12:29:53 +0000
@@ -61,7 +61,7 @@
 
 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 @@
 };
 
 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 @@
 }
 
 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 @@
 };
 
 int gru_tapping(struct grail *ge,
-		const struct touch_frame *frame);
+		const struct utouch_frame *frame);
 
 #endif
 

=== modified file 'src/grail-impl.h'
--- src/grail-impl.h	2010-11-17 16:29:28 +0000
+++ src/grail-impl.h	2011-01-02 12:29:53 +0000
@@ -23,13 +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;

=== modified file 'src/grail-inserter.c'
--- src/grail-inserter.c	2010-09-21 11:23:35 +0000
+++ src/grail-inserter.c	2011-01-02 12:29:53 +0000
@@ -40,7 +40,7 @@
 
 // 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 @@
 	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 @@
 	}
 }
 
-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 @@
 	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 @@
 	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 @@
 		    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;
 }

=== modified file 'src/grail-inserter.h'
--- src/grail-inserter.h	2010-09-21 11:23:35 +0000
+++ src/grail-inserter.h	2011-01-02 12:29:53 +0000
@@ -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 @@
 }
 
 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,

=== modified file 'src/grail-recognizer.c'
--- src/grail-recognizer.c	2010-08-11 17:04:45 +0000
+++ src/grail-recognizer.c	2011-01-02 12:29:53 +0000
@@ -42,7 +42,7 @@
 	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 @@
 	gru_winpinch(ge, frame);
 	gru_winrotate(ge, frame);
 	gru_tapping(ge, frame);
-	ge->gru->frame = *frame;
 }

=== modified file 'src/grail-recognizer.h'
--- src/grail-recognizer.h	2010-08-11 17:04:45 +0000
+++ src/grail-recognizer.h	2011-01-02 12:29:53 +0000
@@ -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 @@
 };
 
 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

=== added file 'src/grailbuf.h'
--- src/grailbuf.h	1970-01-01 00:00:00 +0000
+++ src/grailbuf.h	2011-01-02 12:29:53 +0000
@@ -0,0 +1,60 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2010 Canonical Ltd.
+ * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ *
+ * 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_BUFFER_H
+#define _GRAIL_BUFFER_H
+
+#include <grail.h>
+
+#define DIM_GRAIL_EVENTS 512
+
+struct grailbuf {
+	int head;
+	int tail;
+	struct grail_event buffer[DIM_GRAIL_EVENTS];
+};
+
+static inline void grailbuf_clear(struct grailbuf *buf)
+{
+	buf->head = buf->tail = 0;
+}
+
+static inline int grailbuf_empty(const struct grailbuf *buf)
+{
+	return buf->head == buf->tail;
+}
+
+static inline void grailbuf_put(struct grailbuf *buf,
+				const struct grail_event *ev)
+{
+	buf->buffer[buf->head++] = *ev;
+	buf->head &= DIM_GRAIL_EVENTS - 1;
+}
+
+static inline void grailbuf_get(struct grailbuf *buf,
+				struct grail_event *ev)
+{
+	*ev = buf->buffer[buf->tail++];
+	buf->tail &= DIM_GRAIL_EVENTS - 1;
+}
+
+#endif

=== removed file 'src/touch-caps.c'
--- src/touch-caps.c	2010-09-28 09:33:20 +0000
+++ src/touch-caps.c	1970-01-01 00:00:00 +0000
@@ -1,117 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
- *
- * 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);
-}

=== removed file 'src/touch-dev.c'
--- src/touch-dev.c	2010-09-10 12:00:27 +0000
+++ src/touch-dev.c	1970-01-01 00:00:00 +0000
@@ -1,264 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
- *
- * 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));
-}

=== modified file 'test/Makefile.am'
--- test/Makefile.am	2010-08-12 15:55:30 +0000
+++ test/Makefile.am	2011-01-02 12:29:53 +0000
@@ -1,9 +0,0 @@
-bin_PROGRAMS = grail-touch grail-gesture
-
-INCLUDES=-I$(top_srcdir)/include/
-
-grail_touch_SOURCES = grail-touch.c
-grail_touch_LDFLAGS = -L$(top_builddir)/src/.libs/ -lutouch-grail -lmtdev -lm
-
-grail_gesture_SOURCES = grail-gesture.c
-grail_gesture_LDFLAGS = -L$(top_builddir)/src/.libs/ -lutouch-grail -lmtdev -lm

=== removed file 'test/grail-gesture.c'
--- test/grail-gesture.c	2010-09-21 11:27:02 +0000
+++ test/grail-gesture.c	1970-01-01 00:00:00 +0000
@@ -1,126 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010 Canonical Ltd.
- *
- * 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/>.
- *
- * Authors:
- *      Henrik Rydberg <[e-mail]>
- *
- ****************************************************************************/
-
-#include <grail.h>
-#include <string.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-static grail_mask_t flag_mask[DIM_GRAIL_TYPE_BYTES];
-
-static int tp_get_clients(struct grail *ge,
-			  struct grail_client_info *clients, int max_clients,
-			  const struct grail_coord *coords, int num_coords,
-			  const grail_mask_t *types, int type_bytes)
-{
-	memset(&clients[0], 0, sizeof(clients[0]));
-	clients[0].id.client = 345;
-	clients[0].id.root = 1;
-	clients[0].id.event = 2;
-	clients[0].id.child = 3;
-	memcpy(clients[0].mask, flag_mask, sizeof(flag_mask));
-	return 1;
-}
-
-static void tp_event(struct grail *ge, const struct input_event *ev)
-{
-	fprintf(stderr, "%lu.%06u %04x %04x %d\n",
-		ev->time.tv_sec, (unsigned)ev->time.tv_usec,
-		ev->type, ev->code, ev->value);
-}
-
-static void tp_gesture(struct grail *ge, const struct grail_event *ev)
-{
-	struct grail_contact touch[32];
-	int i, ntouch;
-	fprintf(stderr, "gesture %d %d %d %d - %f %f %d - %d\n",
-		ev->type, ev->id, ev->client_id.client, ev->client_id.event,
-		ev->pos.x, ev->pos.y, ev->ntouch,
-		ev->status);
-	ntouch = grail_get_contacts(ge, touch, 32);
-	for (i = 0; i < ntouch; i++) {
-		const struct grail_contact *t = &touch[i];
-		fprintf(stderr, "\t%d: %d %d\n", i, t->id, t->tool_type);
-		fprintf(stderr, "\t   %f %f\n", t->pos.x, t->pos.y);
-		fprintf(stderr, "\t   %f %f %f %f\n", t->touch_major,
-			t->touch_minor, t->width_major, t->width_minor);
-		fprintf(stderr, "\t   %f %f\n", t->angle, t->pressure);
-	}
-	for (i = 0; i < ev->nprop; i++)
-		fprintf(stderr, "\t%d: %f\n", i, ev->prop[i]);
-}
-
-static void loop_device(struct grail *ge, int fd)
-{
-	while (!grail_idle(ge, fd, 5000))
-		grail_pull(ge, fd);
-}
-
-int main(int argc, char *argv[])
-{
-	struct grail ge;
-	int i, fd;
-
-	if (argc < 3) {
-		fprintf(stderr, "Usage: %s <mask> <device>\n", argv[0]);
-		return -1;
-	}
-
-	memset(&ge, 0, sizeof(ge));
-	ge.get_clients = tp_get_clients;
-	ge.event = tp_event;
-	ge.gesture = tp_gesture;
-
-	unsigned long mask = strtoull(argv[1], 0, 0);
-	for (i = 0; i < DIM_GRAIL_TYPE; i++)
-		if ((mask >> i) & 1)
-			grail_mask_set(flag_mask, i);
-
-	fd = open(argv[2], O_RDONLY | O_NONBLOCK);
-	if (fd < 0) {
-		fprintf(stderr, "error: could not open device\n");
-		return -1;
-	}
-	if (ioctl(fd, EVIOCGRAB, 1)) {
-		fprintf(stderr, "error: could not grab the device\n");
-		return -1;
-	}
-
-	if (grail_open(&ge, fd)) {
-		fprintf(stderr, "error: could not open touch device\n");
-		return -1;
-	}
-	//grail_filter_abs_events(&ge, 1);
-
-	struct grail_coord min = { -2, -1 }, max = { 2, 1 };
-	grail_set_bbox(&ge, &min, &max);
-
-	loop_device(&ge, fd);
-	grail_close(&ge, fd);
-
-	ioctl(fd, EVIOCGRAB, 0);
-	close(fd);
-	return 0;
-}

=== removed file 'test/grail-touch.c'
--- test/grail-touch.c	2010-08-19 20:26:11 +0000
+++ test/grail-touch.c	1970-01-01 00:00:00 +0000
@@ -1,97 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010 Canonical Ltd.
- *
- * 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/>.
- *
- * Authors:
- *      Henrik Rydberg <[e-mail]>
- *
- ****************************************************************************/
-
-#include <grail-touch.h>
-#include <string.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-static void tp_event(struct touch_dev *dev,
-		     const struct input_event *ev)
-{
-	fprintf(stderr, "event %d 0x%x %d\n", ev->type, ev->code, ev->value);
-}
-
-static void tp_sync(struct touch_dev *dev,
-		    const struct input_event *syn)
-{
-	struct touch_frame *frame = &dev->frame;
-	int i, j;
-	for (i = 0; i < frame->nactive; i++) {
-		struct touch *t = frame->active[i];
-		fprintf(stderr, "touch %d\n", i);
-		fprintf(stderr, "  slot:         %d\n", t->slot);
-		fprintf(stderr, "  id:           %d\n", t->id);
-		fprintf(stderr, "  tool_type:    %d\n", t->tool_type);
-		fprintf(stderr, "  x:            %d\n", t->x);
-		fprintf(stderr, "  y:            %d\n", t->y);
-		fprintf(stderr, "  touch_major:  %d\n", t->touch_major);
-		fprintf(stderr, "  touch_minor:  %d\n", t->touch_minor);
-		fprintf(stderr, "  width_major:  %d\n", t->width_major);
-		fprintf(stderr, "  width_minor:  %d\n", t->width_minor);
-		fprintf(stderr, "  angle:        %f\n",
-			touch_angle(dev, t->orientation));
-		fprintf(stderr, "  pressure:     %f\n",
-			touch_pressure(dev, t->pressure));
-	}
-	fprintf(stderr, "sync %d %lld %d %d\n",
-		frame->nactive, frame->time, frame->ncreate, frame->ndestroy);
-}
-
-static void loop_device(struct touch_dev *dev, int fd)
-{
-	dev->event = tp_event;
-	dev->sync = tp_sync;
-	while (!touch_dev_idle(dev, fd, 5000))
-		touch_dev_pull(dev, fd);
-}
-
-int main(int argc, char *argv[])
-{
-	struct touch_dev dev;
-	int fd;
-	if (argc < 2) {
-		fprintf(stderr, "Usage: %s <device>\n", argv[0]);
-		return -1;
-	}
-	fd = open(argv[1], O_RDONLY | O_NONBLOCK);
-	if (fd < 0) {
-		fprintf(stderr, "error: could not open device\n");
-		return -1;
-	}
-	if (ioctl(fd, EVIOCGRAB, 1)) {
-		fprintf(stderr, "error: could not grab the device\n");
-		return -1;
-	}
-	if (touch_dev_open(&dev, fd)) {
-		fprintf(stderr, "error: could not open touch device\n");
-		return -1;
-	}
-	loop_device(&dev, fd);
-	touch_dev_close(&dev, fd);
-	ioctl(fd, EVIOCGRAB, 0);
-	close(fd);
-	return 0;
-}

=== added directory 'tools'
=== added file 'tools/Makefile.am'
--- tools/Makefile.am	1970-01-01 00:00:00 +0000
+++ tools/Makefile.am	2011-01-02 12:29:53 +0000
@@ -0,0 +1,7 @@
+bin_PROGRAMS = grail-gesture
+
+INCLUDES=-I$(top_srcdir)/include/
+
+grail_gesture_SOURCES = grail-gesture.c
+grail_gesture_LDFLAGS = -L$(top_builddir)/src/.libs/ \
+	-lutouch-grail -lutouch-frame -lutouch-evemu -lmtdev -lm

=== added file 'tools/grail-gesture.c'
--- tools/grail-gesture.c	1970-01-01 00:00:00 +0000
+++ tools/grail-gesture.c	2011-01-02 12:29:53 +0000
@@ -0,0 +1,126 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2010 Canonical Ltd.
+ *
+ * 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/>.
+ *
+ * Authors:
+ *      Henrik Rydberg <[e-mail]>
+ *
+ ****************************************************************************/
+
+#include <grail.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+static grail_mask_t flag_mask[DIM_GRAIL_TYPE_BYTES];
+
+static int tp_get_clients(struct grail *ge,
+			  struct grail_client_info *clients, int max_clients,
+			  const struct grail_coord *coords, int num_coords,
+			  const grail_mask_t *types, int type_bytes)
+{
+	memset(&clients[0], 0, sizeof(clients[0]));
+	clients[0].id.client = 345;
+	clients[0].id.root = 1;
+	clients[0].id.event = 2;
+	clients[0].id.child = 3;
+	memcpy(clients[0].mask, flag_mask, sizeof(flag_mask));
+	return 1;
+}
+
+static void tp_event(struct grail *ge, const struct input_event *ev)
+{
+	fprintf(stderr, "%lu.%06u %04x %04x %d\n",
+		ev->time.tv_sec, (unsigned)ev->time.tv_usec,
+		ev->type, ev->code, ev->value);
+}
+
+static void tp_gesture(struct grail *ge, const struct grail_event *ev)
+{
+	struct grail_contact touch[32];
+	int i, ntouch;
+	fprintf(stderr, "gesture %d %d %d %d - %f %f %d - %d\n",
+		ev->type, ev->id, ev->client_id.client, ev->client_id.event,
+		ev->pos.x, ev->pos.y, ev->ntouch,
+		ev->status);
+	ntouch = grail_get_contacts(ge, touch, 32);
+	for (i = 0; i < ntouch; i++) {
+		const struct grail_contact *t = &touch[i];
+		fprintf(stderr, "\t%d: %d %d\n", i, t->id, t->tool_type);
+		fprintf(stderr, "\t   %f %f\n", t->pos.x, t->pos.y);
+		fprintf(stderr, "\t   %f %f %f %f\n", t->touch_major,
+			t->touch_minor, t->width_major, t->width_minor);
+		fprintf(stderr, "\t   %f %f\n", t->angle, t->pressure);
+	}
+	for (i = 0; i < ev->nprop; i++)
+		fprintf(stderr, "\t%d: %f\n", i, ev->prop[i]);
+}
+
+static void loop_device(struct grail *ge, int fd)
+{
+	while (!grail_idle(ge, fd, 5000))
+		grail_pull(ge, fd);
+}
+
+int main(int argc, char *argv[])
+{
+	struct grail ge;
+	int i, fd;
+
+	if (argc < 3) {
+		fprintf(stderr, "Usage: %s <mask> <device>\n", argv[0]);
+		return -1;
+	}
+
+	memset(&ge, 0, sizeof(ge));
+	ge.get_clients = tp_get_clients;
+	ge.event = tp_event;
+	ge.gesture = tp_gesture;
+
+	unsigned long mask = strtoull(argv[1], 0, 0);
+	for (i = 0; i < DIM_GRAIL_TYPE; i++)
+		if ((mask >> i) & 1)
+			grail_mask_set(flag_mask, i);
+
+	fd = open(argv[2], O_RDONLY | O_NONBLOCK);
+	if (fd < 0) {
+		fprintf(stderr, "error: could not open device\n");
+		return -1;
+	}
+	if (ioctl(fd, EVIOCGRAB, 1)) {
+		fprintf(stderr, "error: could not grab the device\n");
+		return -1;
+	}
+
+	if (grail_open(&ge, fd)) {
+		fprintf(stderr, "error: could not open touch device\n");
+		return -1;
+	}
+	//grail_filter_abs_events(&ge, 1);
+
+	struct grail_coord min = { -2, -1 }, max = { 2, 1 };
+	grail_set_bbox(&ge, &min, &max);
+
+	loop_device(&ge, fd);
+	grail_close(&ge, fd);
+
+	ioctl(fd, EVIOCGRAB, 0);
+	close(fd);
+	return 0;
+}

=== added file 'utouch-grail.sym.in'
--- utouch-grail.sym.in	1970-01-01 00:00:00 +0000
+++ utouch-grail.sym.in	2011-01-02 12:29:53 +0000
@@ -0,0 +1,13 @@
+grail_close
+grail_filter_abs_events
+grail_get_contacts
+grail_get_units
+grail_idle
+grail_mask_clear_mask
+grail_mask_count
+grail_mask_get_first
+grail_mask_get_next
+grail_mask_set_mask
+grail_open
+grail_pull
+grail_set_bbox