Merge lp:~chasedouglas/grail/remove-v2 into lp:grail

[Chase Douglas]

Remove v2 implementation.

[lp:~chasedouglas/grail/remove-v2]

230. By Chase Douglas on 2012-05-09

Update library and symbol versioning

[Stephen M. Webb (bregma)]

OK by me.

This requires some changes to the utouch-grail packaging (mostly due to the bumped SONAME) and a small change to utouch-geis, but in and of itself looks correct and builds cleanly.

review: Approve

=== modified file 'configure.ac'
--- configure.ac	2012-04-03 19:47:33 +0000
+++ configure.ac	2012-05-09 17:32:19 +0000
@@ -14,7 +14,7 @@
 AM_SILENT_RULES([yes])
 AM_MAINTAINER_MODE([enable])
 
-LIB_VERSION=4:0:3
+LIB_VERSION=5:0:0
 AC_SUBST([LIB_VERSION])
 
 # Initialize libtool
@@ -30,10 +30,7 @@
 PKG_CHECK_MODULES([FRAME], [utouch-frame >= 2.2.0])
 
 PKG_CHECK_MODULES([XINPUT],
-                  [x11] [xext] [xi >= 1.5.99.1] [inputproto >= 2.1.99.6],
-                  [have_xi22="yes"],
-                  [have_xi22="no"]);
-AM_CONDITIONAL([HAVE_XI22], [test "x$have_xi22" = xyes])
+                  [x11] [xext] [xi >= 1.5.99.1] [inputproto >= 2.1.99.6])
 
 # Check for TDD tools
 AC_ARG_ENABLE([integration-tests],

=== removed file 'include/grail-bits.h'
--- include/grail-bits.h	2011-05-27 09:22:36 +0000
+++ include/grail-bits.h	1970-01-01 00:00:00 +0000
@@ -1,95 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 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/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_BITS_H
-#define GRAIL_BITS_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Macros that set symbol visibilities in shared libraries properly.
- * Adapted from http://gcc.gnu.org/wiki/Visibility
- */
-
-#if defined _WIN32 || defined __CYGWIN__
-        #ifdef BUILDING_GRAIL
-                #define GRAIL_PUBLIC __declspec(dllexport)
-        #else
-                #define GRAIL_PUBLIC __declspec(dllimport)
-        #endif
-        #define GRAIL_PRIVATE
-#else
-        #if defined __GNUC__
-                #define GRAIL_PUBLIC __attribute__ ((visibility("default")))
-                #define GRAIL_PRIVATE  __attribute__ ((visibility("hidden")))
-        #else
-                #pragma message ("Compiler does not support symbol visibility.")
-                #define GRAIL_PUBLIC
-                #define GRAIL_PRIVATE
-        #endif
-#endif
-
-typedef unsigned char grail_mask_t;
-
-static inline void grail_mask_set(grail_mask_t *mask, int i)
-{
-	mask[i >> 3] |= (1 << (i & 7));
-}
-
-static inline void grail_mask_clear(grail_mask_t *mask, int i)
-{
-	mask[i >> 3] &= ~(1 << (i & 7));
-}
-
-static inline void grail_mask_modify(grail_mask_t *mask, int i, int v)
-{
-	if (v)
-		grail_mask_set(mask, i);
-	else
-		grail_mask_clear(mask, i);
-}
-
-static inline int grail_mask_get(const grail_mask_t *mask, int i)
-{
-	return (mask[i >> 3] >> (i & 7)) & 1;
-}
-
-void GRAIL_PUBLIC grail_mask_set_mask(grail_mask_t *a, const grail_mask_t *b,
-				      int bytes);
-void GRAIL_PUBLIC grail_mask_clear_mask(grail_mask_t *a, const grail_mask_t *b,
-					int bytes);
-
-int GRAIL_PUBLIC grail_mask_count(const grail_mask_t *mask, int bytes);
-int GRAIL_PUBLIC grail_mask_get_first(const grail_mask_t *mask, int bytes);
-int GRAIL_PUBLIC grail_mask_get_next(int i, const grail_mask_t *mask,
-				     int bytes);
-
-#define grail_mask_foreach(i, mask, bytes)				\
-	for (i = grail_mask_get_first(mask, bytes);			\
-	     i >= 0;							\
-	     i = grail_mask_get_next(i, mask, bytes))
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

=== removed file 'include/grail-types.h'
--- include/grail-types.h	2011-06-06 14:42:39 +0000
+++ include/grail-types.h	1970-01-01 00:00:00 +0000
@@ -1,195 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 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/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_TYPES_H
-#define GRAIL_TYPES_H
-
-#define GRAIL_TYPE_DRAG1	0	/* one-finger drag/pan/scroll */
-#define GRAIL_TYPE_PINCH1	1	/* one-finger pinch-to-zoom */
-#define GRAIL_TYPE_ROTATE1	2	/* one-finger rotation */
-
-#define GRAIL_TYPE_DRAG2	3	/* two-finger drag/pan/scroll */
-#define GRAIL_TYPE_PINCH2	4	/* two-finger pinch-to-zoom */
-#define GRAIL_TYPE_ROTATE2	5	/* two-finger rotation */
-
-#define GRAIL_TYPE_DRAG3	6	/* three-finger drag/pan */
-#define GRAIL_TYPE_PINCH3	7	/* three-finger pinch */
-#define GRAIL_TYPE_ROTATE3	8	/* three-finger rotate */
-
-#define GRAIL_TYPE_DRAG4	9	/* four-finger drag/pan */
-#define GRAIL_TYPE_PINCH4	10	/* four-finger pinch */
-#define GRAIL_TYPE_ROTATE4	11	/* four-finger rotate */
-
-#define GRAIL_TYPE_DRAG5	12	/* five-finger drag/pan */
-#define GRAIL_TYPE_PINCH5	13	/* five-finger pinch */
-#define GRAIL_TYPE_ROTATE5	14	/* five-finger rotate */
-
-#define GRAIL_TYPE_TAP1		15	/* one-finger single tap */
-#define GRAIL_TYPE_TAP2		16	/* two-finger single tap */
-#define GRAIL_TYPE_TAP3		17	/* three-finger single tap */
-#define GRAIL_TYPE_TAP4		18	/* four-finger single tap */
-#define GRAIL_TYPE_TAP5		19	/* five-finger single tap */
-
-#define GRAIL_TYPE_EDRAG	20	/* three-finger environment drag */
-#define GRAIL_TYPE_EPINCH	21	/* three-finger environment drag */
-#define GRAIL_TYPE_EROTATE	22	/* three-finger environment drag */
-
-#define GRAIL_TYPE_MDRAG	23	/* four-finger meta drag */
-#define GRAIL_TYPE_MPINCH	24	/* four-finger meta drag */
-#define GRAIL_TYPE_MROTATE	25	/* four-finger meta drag */
-
-#define GRAIL_TYPE_SYSFLAG1	26	/* reserved system flag */
-
-#define GRAIL_TYPE_TOUCH1	32	/* one-finger touch */
-#define GRAIL_TYPE_TOUCH2	33	/* two-finger touch */
-#define GRAIL_TYPE_TOUCH3	34	/* three-finger touch */
-#define GRAIL_TYPE_TOUCH4	35	/* four-finger touch */
-#define GRAIL_TYPE_TOUCH5	36	/* five-finger touch */
-#define GRAIL_TYPE_ETOUCH	37	/* three-finger environment touch */
-#define GRAIL_TYPE_MTOUCH	38	/* four-finger meta touch */
-
-#define GRAIL_MAIN_DRAG		0
-#define GRAIL_MAIN_PINCH	1
-#define GRAIL_MAIN_ROTATE	2
-#define GRAIL_MAIN_TAP		3
-#define GRAIL_MAIN_SYSFLAG	4
-#define GRAIL_MAIN_TOUCH	5
-
-#define GRAIL_PROP_DRAG_DX	0	/* horizontal position delta */
-#define GRAIL_PROP_DRAG_DY	1	/* vertical position delta */
-#define GRAIL_PROP_DRAG_VX	2	/* horizontal velocity */
-#define GRAIL_PROP_DRAG_VY	3	/* vertical velocity */
-#define GRAIL_PROP_DRAG_X	4	/* horizontal position */
-#define GRAIL_PROP_DRAG_Y	5	/* vertical position */
-#define GRAIL_PROP_DRAG_X1	6	/* bounding box x1 */
-#define GRAIL_PROP_DRAG_Y1	7	/* bounding box y1 */
-#define GRAIL_PROP_DRAG_X2	8	/* bounding box x2 */
-#define GRAIL_PROP_DRAG_Y2	9	/* bounding box y2 */
-#define GRAIL_PROP_DRAG_ID_T0	10	/* first touch id */
-#define GRAIL_PROP_DRAG_X_T0	11	/* first touch horizontal position */
-#define GRAIL_PROP_DRAG_Y_T0	12	/* first touch vertical position */
-#define GRAIL_PROP_DRAG_ID_T1	13
-#define GRAIL_PROP_DRAG_X_T1	14
-#define GRAIL_PROP_DRAG_Y_T1	15
-#define GRAIL_PROP_DRAG_ID_T2	16
-#define GRAIL_PROP_DRAG_X_T2	17
-#define GRAIL_PROP_DRAG_Y_T2	18
-#define GRAIL_PROP_DRAG_ID_T3	19
-#define GRAIL_PROP_DRAG_X_T3	20
-#define GRAIL_PROP_DRAG_Y_T3	21
-#define GRAIL_PROP_DRAG_ID_T4	22
-#define GRAIL_PROP_DRAG_X_T4	23
-#define GRAIL_PROP_DRAG_Y_T4	24
-
-#define GRAIL_PROP_PINCH_DR	0	/* radius delta */
-#define GRAIL_PROP_PINCH_VR	1	/* radial velocity */
-#define GRAIL_PROP_PINCH_R	2	/* radius */
-#define GRAIL_PROP_PINCH_X	3	/* centroid x */
-#define GRAIL_PROP_PINCH_Y	4	/* centroid y */
-#define GRAIL_PROP_PINCH_X1	5	/* bounding box x1 */
-#define GRAIL_PROP_PINCH_Y1	6	/* bounding box y1 */
-#define GRAIL_PROP_PINCH_X2	7	/* bounding box x2 */
-#define GRAIL_PROP_PINCH_Y2	8	/* bounding box y2 */
-#define GRAIL_PROP_PINCH_ID_T0	9	/* first touch id */
-#define GRAIL_PROP_PINCH_X_T0	10	/* first touch horizontal position */
-#define GRAIL_PROP_PINCH_Y_T0	11	/* first touch vertical position */
-#define GRAIL_PROP_PINCH_ID_T1	12
-#define GRAIL_PROP_PINCH_X_T1	13
-#define GRAIL_PROP_PINCH_Y_T1	14
-#define GRAIL_PROP_PINCH_ID_T2	15
-#define GRAIL_PROP_PINCH_X_T2	16
-#define GRAIL_PROP_PINCH_Y_T2	17
-#define GRAIL_PROP_PINCH_ID_T3	18
-#define GRAIL_PROP_PINCH_X_T3	19
-#define GRAIL_PROP_PINCH_Y_T3	20
-#define GRAIL_PROP_PINCH_ID_T4	21
-#define GRAIL_PROP_PINCH_X_T4	22
-#define GRAIL_PROP_PINCH_Y_T4	23
-
-#define GRAIL_PROP_ROTATE_DA	0	/* angle delta */
-#define GRAIL_PROP_ROTATE_VA	1	/* angular velocity */
-#define GRAIL_PROP_ROTATE_A	2	/* angle */
-#define GRAIL_PROP_ROTATE_X	3	/* centroid x coordinate */
-#define GRAIL_PROP_ROTATE_Y	4	/* centroid y coordinate */
-#define GRAIL_PROP_ROTATE_X1	5	/* bounding box x1 */
-#define GRAIL_PROP_ROTATE_Y1	6	/* bounding box y1 */
-#define GRAIL_PROP_ROTATE_X2	7	/* bounding box x2 */
-#define GRAIL_PROP_ROTATE_Y2	8	/* bounding box y2 */
-#define GRAIL_PROP_ROTATE_ID_T0	9	/* first touch id */
-#define GRAIL_PROP_ROTATE_X_T0	10	/* first touch horizontal position */
-#define GRAIL_PROP_ROTATE_Y_T0	11	/* first touch vertical position */
-#define GRAIL_PROP_ROTATE_ID_T1	12
-#define GRAIL_PROP_ROTATE_X_T1	13
-#define GRAIL_PROP_ROTATE_Y_T1	14
-#define GRAIL_PROP_ROTATE_ID_T2	15
-#define GRAIL_PROP_ROTATE_X_T2	16
-#define GRAIL_PROP_ROTATE_Y_T2	17
-#define GRAIL_PROP_ROTATE_ID_T3	18
-#define GRAIL_PROP_ROTATE_X_T3	19
-#define GRAIL_PROP_ROTATE_Y_T3	20
-#define GRAIL_PROP_ROTATE_ID_T4	21
-#define GRAIL_PROP_ROTATE_X_T4	22
-#define GRAIL_PROP_ROTATE_Y_T4	23
-
-#define GRAIL_PROP_TAP_DT	0	/* tap time (ms) */
-#define GRAIL_PROP_TAP_X	1	/* horizontal position */
-#define GRAIL_PROP_TAP_Y	2	/* vertical position */
-#define GRAIL_PROP_TAP_X1	3	/* bounding box x1 */
-#define GRAIL_PROP_TAP_Y1	4	/* bounding box y1 */
-#define GRAIL_PROP_TAP_X2	5	/* bounding box x2 */
-#define GRAIL_PROP_TAP_Y2	6	/* bounding box y2 */
-#define GRAIL_PROP_TAP_ID_T0	7	/* first touch id */
-#define GRAIL_PROP_TAP_X_T0	8	/* first touch horizontal position */
-#define GRAIL_PROP_TAP_Y_T0	9	/* first touch vertical position */
-#define GRAIL_PROP_TAP_ID_T1	10
-#define GRAIL_PROP_TAP_X_T1	11
-#define GRAIL_PROP_TAP_Y_T1	12
-#define GRAIL_PROP_TAP_ID_T2	13
-#define GRAIL_PROP_TAP_X_T2	14
-#define GRAIL_PROP_TAP_Y_T2	15
-#define GRAIL_PROP_TAP_ID_T3	16
-#define GRAIL_PROP_TAP_X_T3	17
-#define GRAIL_PROP_TAP_Y_T3	18
-#define GRAIL_PROP_TAP_ID_T4	19
-#define GRAIL_PROP_TAP_X_T4	20
-#define GRAIL_PROP_TAP_Y_T4	21
-
-#define GRAIL_PROP_TOUCH_X1	0	/* bounding box x1 */
-#define GRAIL_PROP_TOUCH_Y1	1	/* bounding box y1 */
-#define GRAIL_PROP_TOUCH_X2	2	/* bounding box x2 */
-#define GRAIL_PROP_TOUCH_Y2	3	/* bounding box y2 */
-#define GRAIL_PROP_TOUCH_ID_T0	4	/* first touch id */
-#define GRAIL_PROP_TOUCH_X_T0	5	/* first touch horizontal position */
-#define GRAIL_PROP_TOUCH_Y_T0	6	/* first touch vertical position */
-#define GRAIL_PROP_TOUCH_ID_T1	7
-#define GRAIL_PROP_TOUCH_X_T1	8
-#define GRAIL_PROP_TOUCH_Y_T1	9
-#define GRAIL_PROP_TOUCH_ID_T2	10
-#define GRAIL_PROP_TOUCH_X_T2	11
-#define GRAIL_PROP_TOUCH_Y_T2	12
-#define GRAIL_PROP_TOUCH_ID_T3	13
-#define GRAIL_PROP_TOUCH_X_T3	14
-#define GRAIL_PROP_TOUCH_Y_T3	15
-#define GRAIL_PROP_TOUCH_ID_T4	16
-#define GRAIL_PROP_TOUCH_X_T4	17
-#define GRAIL_PROP_TOUCH_Y_T4	18
-
-#endif

=== removed file 'include/grail.h'
--- include/grail.h	2011-08-30 15:10:16 +0000
+++ include/grail.h	1970-01-01 00:00:00 +0000
@@ -1,480 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 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/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_H
-#define GRAIL_H
-
-#include <linux/input.h>
-#include <grail-bits.h>
-#include <grail-types.h>
-#include <utouch/frame.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define GRAIL_VERSION           0x00011000
-
-#define DIM_GRAIL_TYPE		64
-#define DIM_GRAIL_TYPE_BYTES	((DIM_GRAIL_TYPE + 7) >> 3)
-
-#define DIM_GRAIL_PROP		32
-#define DIM_GRAIL_PROP_BYTES	((DIM_GRAIL_PROP + 7) >> 3)
-
-#define GRAIL_STATUS_BEGIN	0
-#define GRAIL_STATUS_UPDATE	1
-#define GRAIL_STATUS_END	2
-
-#define GRAIL_EXPECT_DRAG_X	0x0001
-#define GRAIL_EXPECT_DRAG_Y	0x0002
-#define GRAIL_EXPECT_SCALE	0x0004
-#define GRAIL_EXPECT_ANGLE	0x0008
-#define GRAIL_EXPECT_MASK	0x000f
-
-typedef float grail_prop_t;			/* gesture properties */
-typedef utouch_frame_time_t grail_time_t;	/* time in milliseconds */
-typedef struct grail *grail_handle;		/* the grail instance handle */
-
-/**
- * struct grail_get_version - get grail library version
- *
- * Report the version of the grail library, which can be different from
- * the value of GRAIL_VERSION in this header file.
- *
- * This function allows for fallback options from major interface
- * extensions within the same ABI version. For the normal cases of ABI
- * agnostic or backwards incompatible changes, this function is not
- * needed.
- */
-unsigned int GRAIL_PUBLIC grail_get_version(void);
-
-/**
- * struct grail_coord - coordinate in bounding box units
- * @x: the horizontal position (bbox units)
- * @y: the vertical position (bbox units)
- */
-struct grail_coord {
-	float x, y;
-};
-
-grail_handle GRAIL_PUBLIC grail_new_raw(utouch_frame_handle fh,
-					unsigned int num_frames,
-					void *select,
-					unsigned int version,
-					unsigned int control_size,
-					unsigned int frame_size,
-					unsigned int slot_size);
-
-/**
- * grail_new - allocate and initialize a new grail instance
- * @fh: utouch frame handle to use
- * @num_frames: number of frames in cyclic buffer
- * @select: client selection callback
- *
- * Initialize the internal grail structures.
- *
- * Returns zero in case of failure.
- */
-#define grail_new(fh, num_frames, select)		\
-	grail_new_raw(fh, num_frames, select,		\
-		      GRAIL_VERSION,			\
-		      sizeof(struct grail_control),	\
-		      sizeof(struct grail_frame),	\
-		      sizeof(struct grail_element))
-
-/**
- * grail_delete - destroy and delete grail instance
- * @ge: grail instance in use
- *
- * Deallocates all internal memory structures.
- */
-void GRAIL_PUBLIC grail_delete(grail_handle ge);
-
-/**
- * grail_get_control - get mutable control structure
- * @ge: the grail device in use
- *
- * Return the control struct of the grail instance.
- *
- * The control pointer is ABI agnostic, owned by the grail instance, and
- * has grail scope.
- */
-struct grail_control GRAIL_PUBLIC *grail_get_control(grail_handle ge);
-
-/**
- * grail_pump_frame - insert touch frames into grail
- * @ge: the grail device in use
- * @frame: the touch frame to insert
- *
- * Insert a new touch frame into the grail engine. If the frame induces a
- * new gesture frame, a pointer to the frame is returned.
- *
- * The grail frame pointer is ABI agnostic, owned by the grail instance, and
- * has grail scope.
- */
-const struct grail_frame GRAIL_PUBLIC *
-grail_pump_frame(grail_handle ge, const struct utouch_frame *frame);
-
-/**
- * struct grail_client_id - Gesture client information
- * @client: Client id
- * @root: Root window
- * @event: Window to route events to
- * @child: Window the event occured in
- *
- * This struct is treated opaquely, and only has meaning to the gesture
- * client. Details are subject to change.
- */
-struct grail_client_id {
-	int client;
-	int root, event, child;
-};
-
-/**
- * struct grail_client_info - Gesture request information
- * @id: Gesture client id
- * @mask: Gestures the client is listening to
- */
-struct grail_client_info {
-	struct grail_client_id id;
-	grail_mask_t mask[DIM_GRAIL_TYPE_BYTES];
-};
-
-/**
- * struct grail_control - control parameters of grail
- * @glue_ms: minimum time to hold activation (ms)
- * @bar_drag_x: horizontal distance to activate (surface width fraction)
- * @bar_drag_y: vertical distance to activate (surface height fraction)
- * @bar_scale: minimum scaling to activate (fraction)
- * @bar_angle: minimum angle to activate (radians)
- * @drop_x_ms: horizontal expect timeout (ms)
- * @drop_y_ms: vertical expect timeout (ms)
- * @drop_scale_ms: scaling expect timeout (ms)
- * @drop_angle_ms: rotation expect timeout (ms)
- *
- * The parameters are used to tune the behavior of the gesture recognition.
- *
- * The moveness is a number between zero and one denoting the
- * character of the current transform. Zero means pure rotate and
- * scale, one means pure drag.
- *
- * Later versions of this struct may grow in size, but will remain
- * binary compatible with older versions.
- */
-struct grail_control {
-	float glue_ms;
-	float bar_drag_x;
-	float bar_drag_y;
-	float bar_scale;
-	float bar_angle;
-	float drop_x_ms;
-	float drop_y_ms;
-	float drop_scale_ms;
-	float drop_angle_ms;
-};
-
-/**
- * struct grail_frame - frame of ongoing elementary transformations
- * @prev: pointer to the previous gesture frame
- * @touch: pointer to the touch frame triggering this gesture frame
- * @num_ongoing: number of elements in the ongoing array
- * @ongoing: array of ongoing transformation elements
- * @slots: array of all transformation slots
- *
- * A gesture frame consists of one or several touch frames glued
- * together into a stable transition, combined with information on
- * ongoing elementary gestural transformations. The array of ongoing
- * elements contains all elements with a nonzero expect mask.
- *
- * Later versions of this struct may grow in size, but will remain
- * binary compatible with older versions.
- */
-struct grail_frame {
-	const struct grail_frame *prev;
-	const struct utouch_frame *touch;
-	unsigned int num_ongoing;
-	struct grail_element **ongoing;
-	struct grail_element **slots;
-};
-
-/**
- * struct grail_element - elementary gesture transformation
- * @prev: respective element of previous frame
- * @slot: the transformation slot occupied by this element
- * @id: unique identifier of the ongoing transformation
- * @num_touches: number of contacts of this element
- * @touches: array of contacts of this element
- * @start_time: start time of this element
- * @expect_mask: bitmask of expected gestures (grail main types)
- * @active_mask: bitmask of activated gestures (grail main types)
- * @center: gesture center position (surface units)
- * @velocity: current center velocity (surface units per second)
- * @radius: gesture radius from center (surface units)
- * @transform: the transformation matrix of the gesture
- * @rotation_center: current instant center of rotation (surface units)
- * @drag: accumulated transformation displacement (surface units)
- * @scale: accumulated scale (dimensionless)
- * @angle: accumulated rotation angle (radians)
- *
- * The grail element describes the ongoing gestural transformation of
- * a particular set of contacts. The expect mask describes which
- * gestural transformations may become active during the course of
- * events, and the active mask describes which have passed their
- * respective activation threshold. The set of expected gestures can
- * change over time, for instance by exclusion or timeout.
- *
- * Applications handling rotation, either by transformation matrix or
- * angle, should use the drag displacement. For other applications,
- * the center displacement may be used instead, as to not lose
- * movement accuracy.
- *
- * Later versions of this struct may grow in size, but will remain
- * binary compatible with older versions.
- */
-struct grail_element {
-	const struct grail_element *prev;
-	int slot;
-	int id;
-	int num_touches;
-	const struct utouch_contact **touches;
-	grail_time_t start_time;
-	unsigned int expect_mask;
-	unsigned int active_mask;
-	struct grail_coord center;
-	struct grail_coord velocity;
-	float radius2;
-	float transform[6];
-	struct grail_coord rotation_center;
-	struct grail_coord drag;
-	float scale2;
-	float angle;
-};
-
-/**
- * grail_element_transform - transform coordinates using element
- * @slot: the transformation element to use
- * @q: the grail coordinate to fill
- * @x: the grail coordinate to transform
- *
- * Performs the 3x3 transform *q = T *p, where T is the element
- * transform.
- */
-static inline void grail_element_transform(const struct grail_element *slot,
-					   struct grail_coord *q,
-					   const struct grail_coord *p)
-{
-	const float *T = slot->transform;
-	q->x = T[0] * (p->x - slot->center.x) +
-	       T[1] * (p->y - slot->center.y) +
-	       T[2] + slot->center.x;
-	q->y = T[3] * (p->x - slot->center.x) +
-	       T[4] * (p->y - slot->center.y) +
-	       T[5] + slot->center.y;
-}
-
-/**
- * struct grail_event - Gesture event
- * @type: The gesture type
- * @id: Unique identifier foof the gesture instance
- * @status: Gesture status (begin, update, end)
- * @ntouch: Number of current touches
- * @nprop: Number of properties in the gesture
- * @pos: Focus point of the gesture (bbox coordinates)
- * @touch: Array of individual touch information
- * @client_id: The gesture client to route the gesture to
- * @time: Time of event (milliseconds)
- * @prop: Array of properties of the event
- *
- * Gesture events are passed to the client via the gesture() callback.
- */
-struct grail_event {
-	int type;
-	int id;
-	int status;
-	int ntouch;
-	int nprop;
-	struct grail_coord pos;
-	struct grail_client_id client_id;
-	grail_time_t time;
-	grail_prop_t prop[DIM_GRAIL_PROP];
-};
-
-/**
- * struct grail - Main grail device
- * @get_clients: Called at the onset of new gestures to retrieve the list
- * of listening clients.
- * @event: Callback for kernel events passing through grail.
- * @gesture: Main gesture callback.
- * @impl: Grail implementation details.
- * @gin: Gesture instatiation details.
- * @gru: Gesture recognition details.
- * @priv: Generic pointer to user-defined content.
- *
- * The grail device pulls events from the underlying device, detects
- * gestures, and passes them on to the client via the gesture()
- * callback. Events that are not gesture or for other reasons held back are
- * passed on via the event() callback. The user provides information about
- * windows and listening clients via the get_clients callback, which is
- * called during gesture instantiation.
- *
- */
-struct grail {
-	int (*get_clients)(struct grail *ge,
-			   struct grail_client_info *client, int max_clients,
-			   const struct grail_coord *coords, int num_coords,
-			   const grail_mask_t *types, int type_bytes);
-	void (*event)(struct grail *ge,
-		      const struct input_event *ev);
-	void (*gesture)(struct grail *ge,
-			const struct grail_event *ev);
-	struct grail_impl *impl;
-	struct gesture_inserter *gin;
-	struct gesture_recognizer *gru;
-	void *priv;
-};
-
-/**
- * grail_open - open a grail device
- * @ge: the grail device to open
- * @fd: file descriptor of the kernel device
- *
- * Initialize the internal grail structures and configure it by reading the
- * protocol capabilities through the file descriptor.
- *
- * The callbacks, parameters and priv pointer should be set prior to this
- * call.
- *
- * Returns zero on success, negative error number otherwise.
- */
-int GRAIL_PUBLIC grail_open(struct grail *ge, int fd);
-
-/**
- * grail_idle - check state of kernel device
- * @ge: the grail device in use
- * @fd: file descriptor of the kernel device
- * @ms: number of milliseconds to wait for activity
- *
- * Returns true if the device is idle, i.e., there are no fetched
- * events in the pipe and there is nothing to fetch from the device.
- */
-int GRAIL_PUBLIC grail_idle(struct grail *ge, int fd, int ms);
-
-/**
- * grail_pull - pull and process available events from the kernel device
- * @ge: the grail device in use
- * @fd: file descriptor of the kernel device
- *
- * Pull all available events and process them. The grail callbacks are
- * invoked during this call.
- *
- * The underlying file descriptor must have O_NONBLOCK set, or this method
- * will not return until the file is closed.
- *
- * On success, returns the number of events read. Otherwise,
- * a standard negative error number is returned.
- */
-int GRAIL_PUBLIC grail_pull(struct grail *ge, int fd);
-
-/**
- * grail_close - close the grail device
- * @ge: the grail device to close
- * @fd: file descriptor of the kernel device
- *
- * Deallocates all memory associated with grail, and clears the grail
- * structure.
- */
-void GRAIL_PUBLIC grail_close(struct grail *ge, int fd);
-
-/**
- * grail_set_bbox - set the grail unit bounding box
- * @ge: the grail device in use
- * @min: the minimum (lower-left) corner of the bounding box
- * @max: the maximum (upper-right) corner of the bounding box
- *
- * Sets the box within which the device coordinates should be presented.
- */
-void GRAIL_PUBLIC grail_set_bbox(struct grail *ge,
-				 const struct grail_coord *min,
-				 const struct grail_coord *max);
-
-/**
- * grail_get_units - get device coordinate ranges
- * @ge: the grail device in use
- * @min: minimum x and y coordinates
- * @max: maximum x and y coordinates
- *
- * The grail event attributes pos, touch_major, touch_minor,
- * width_major, and width_minor are all given in device coordinate
- * units, unless specified otherwise using the grail_set_bbox()
- * function. This function reports the device coordinate ranges.
- *
- */
-void GRAIL_PUBLIC grail_get_units(const struct grail *ge,
-				  struct grail_coord *min, struct grail_coord *max);
-
-/**
- * grail_get_contact_frame - get current contact frame
- * @ge: the grail device in use
- *
- * Return the contact frame current being processed. If called from
- * within a gesture callback, it is guaranteed to return the frame
- * corresponding to the gesture.
- *
- * The returned pointer can be NULL if no input has yet been extracted
- * through the grail instance.
- *
- * The frame pointer is ABI agnostic, owned by the grail instance, and
- * has grail scope.
- */
-const struct utouch_frame GRAIL_PUBLIC *
-grail_get_contact_frame(const struct grail *ge);
-
-#ifndef GRAIL_NO_LEGACY_API
-
-struct grail_contact {
-	int id;
-	int tool_type;
-	struct grail_coord pos;
-	float touch_major;
-	float touch_minor;
-	float width_major;
-	float width_minor;
-	float angle;
-	float pressure;
-};
-
-void GRAIL_PUBLIC grail_filter_abs_events(struct grail *ge, int usage);
-
-int GRAIL_PUBLIC grail_get_contacts(const struct grail *ge,
-				    struct grail_contact *touch, int max_touch);
-
-#endif
-
-void GRAIL_PUBLIC grail_set_coordinate_transform_callback(struct grail *ge,
-							  utouch_coordinate_transform_cb callback,
-							  void *user_data);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2012-03-29 18:02:09 +0000
+++ src/Makefile.am	2012-05-09 17:32:19 +0000
@@ -1,5 +1,3 @@
-AUTOMAKE_OPTIONS = subdir-objects
-
 lib_LTLIBRARIES = libutouch-grail.la
 version_script = $(srcdir)/libutouch-grail.ver
 
@@ -20,69 +18,34 @@
 	$(COVERAGE_LIBS) \
 	-lm
 
-v2dir = v2
 libutouch_grail_la_SOURCES = \
-	v2/evbuf.h \
-	v2/gebuf.h \
-	v2/grailbuf.h \
-	v2/grail-bits.c \
-	v2/grail-inserter.c \
-	v2/grail-inserter.h \
-	v2/grail-gestures.c \
-	v2/grail-gestures.h \
-	v2/gestures-touch.c \
-	v2/gestures-drag.c \
-	v2/gestures-pinch.c \
-	v2/gestures-rotate.c \
-	v2/gestures-tapping.c \
-	v2/grail-recognizer.c \
-	v2/grail-recognizer.h \
-	v2/grail-event.c \
-	v2/grail-impl.h \
-	v2/grail-api.c \
-	v2/grail-legacy.c \
-	v2/grail-init.c \
-	v2/grail-frame.c
-
-if HAVE_XI22
-v3dir = v3
-libutouch_grail_la_SOURCES += \
-	v3/atomic-recognizer.cpp \
-	v3/atomic-recognizer.h \
-	v3/event.cpp \
-	v3/event.h \
-	v3/forward.h \
-	v3/gesture.cpp \
-	v3/gesture.h \
-	v3/handle.cpp \
-	v3/handle.h \
-	v3/log.cpp \
-	v3/log.h \
-	v3/recognizer.cpp \
-	v3/recognizer.h \
-	v3/regular-recognizer.cpp \
-	v3/regular-recognizer.h \
-	v3/slice.cpp \
-	v3/slice.h \
-	v3/subscription.cpp \
-	v3/subscription.h \
-	v3/touch.cpp \
-	v3/touch.h
-endif
+	atomic-recognizer.cpp \
+	atomic-recognizer.h \
+	event.cpp \
+	event.h \
+	forward.h \
+	gesture.cpp \
+	gesture.h \
+	handle.cpp \
+	handle.h \
+	log.cpp \
+	log.h \
+	recognizer.cpp \
+	recognizer.h \
+	regular-recognizer.cpp \
+	regular-recognizer.h \
+	slice.cpp \
+	slice.h \
+	subscription.cpp \
+	subscription.h \
+	touch.cpp \
+	touch.h
 
 INCLUDES = -I$(top_srcdir)/include/ $(FRAME_CFLAGS)
 
-libutouch_grailincludedir = $(includedir)
-libutouch_grailinclude_HEADERS = \
-	$(top_srcdir)/include/grail-bits.h \
-	$(top_srcdir)/include/grail-types.h \
-	$(top_srcdir)/include/grail.h
-
-if HAVE_XI22
-libutouch_grail_v3includedir = $(includedir)/utouch
-libutouch_grail_v3include_HEADERS = \
+libutouch_grail_includedir = $(includedir)/utouch
+libutouch_grail_include_HEADERS = \
 	$(top_srcdir)/include/utouch/grail.h
-endif
 
 EXTRA_DIST = $(version_script)
 

=== renamed file 'src/v3/atomic-recognizer.cpp' => 'src/atomic-recognizer.cpp'
--- src/v3/atomic-recognizer.cpp	2012-04-03 14:24:54 +0000
+++ src/atomic-recognizer.cpp	2012-05-09 17:32:19 +0000
@@ -18,7 +18,7 @@
  *
  ****************************************************************************/
 
-#include "v3/atomic-recognizer.h"
+#include "atomic-recognizer.h"
 
 #include <algorithm>
 #include <cassert>
@@ -29,10 +29,10 @@
 #include <utouch/frame.h>
 #include <utouch/frame_x11.h>
 
-#include "v3/handle.h"
-#include "v3/gesture.h"
-#include "v3/log.h"
-#include "v3/touch.h"
+#include "handle.h"
+#include "gesture.h"
+#include "log.h"
+#include "touch.h"
 
 namespace {
 const uint64_t MAX_TOUCHES_FOR_GESTURES = 5;

=== renamed file 'src/v3/atomic-recognizer.h' => 'src/atomic-recognizer.h'
--- src/v3/atomic-recognizer.h	2012-04-03 14:24:54 +0000
+++ src/atomic-recognizer.h	2012-05-09 17:32:19 +0000
@@ -21,7 +21,7 @@
 #ifndef UTOUCH_GRAIL_ATOMIC_RECOGNIZER_H_
 #define UTOUCH_GRAIL_ATOMIC_RECOGNIZER_H_
 
-#include "v3/recognizer.h"
+#include "recognizer.h"
 
 namespace utouch {
 namespace grail {

=== renamed file 'src/v3/event.cpp' => 'src/event.cpp'
--- src/v3/event.cpp	2012-03-26 12:57:55 +0000
+++ src/event.cpp	2012-05-09 17:32:19 +0000
@@ -18,11 +18,11 @@
  *
  ****************************************************************************/
 
-#include "v3/event.h"
+#include "event.h"
 
 #include <cassert>
 
-#include "v3/slice.h"
+#include "slice.h"
 
 namespace utouch {
 namespace grail {

=== renamed file 'src/v3/event.h' => 'src/event.h'
--- src/v3/event.h	2012-03-26 12:57:55 +0000
+++ src/event.h	2012-05-09 17:32:19 +0000
@@ -25,7 +25,7 @@
 #include <memory>
 
 #include "utouch/grail.h"
-#include "v3/forward.h"
+#include "forward.h"
 
 struct UGEvent_ {};
 

=== renamed file 'src/v3/forward.h' => 'src/forward.h'
=== renamed file 'src/v3/gesture.cpp' => 'src/gesture.cpp'
--- src/v3/gesture.cpp	2012-03-26 19:29:08 +0000
+++ src/gesture.cpp	2012-05-09 17:32:19 +0000
@@ -18,19 +18,19 @@
  *
  ****************************************************************************/
 
-#include "v3/gesture.h"
+#include "gesture.h"
 
 #include <cstdio>
 #include <stdexcept>
 
 #include "utouch/grail.h"
 
-#include "v3/event.h"
-#include "v3/handle.h"
-#include "v3/log.h"
-#include "v3/recognizer.h"
-#include "v3/slice.h"
-#include "v3/touch.h"
+#include "event.h"
+#include "handle.h"
+#include "log.h"
+#include "recognizer.h"
+#include "slice.h"
+#include "touch.h"
 
 namespace utouch {
 namespace grail {

=== renamed file 'src/v3/gesture.h' => 'src/gesture.h'
--- src/v3/gesture.h	2012-03-27 15:52:30 +0000
+++ src/gesture.h	2012-05-09 17:32:19 +0000
@@ -29,7 +29,7 @@
 #include <utouch/frame.h>
 
 #include "utouch/grail.h"
-#include "v3/forward.h"
+#include "forward.h"
 
 namespace utouch {
 namespace grail {

=== renamed file 'src/v3/handle.cpp' => 'src/handle.cpp'
--- src/v3/handle.cpp	2012-03-26 12:57:55 +0000
+++ src/handle.cpp	2012-05-09 17:32:19 +0000
@@ -18,7 +18,7 @@
  *
  ****************************************************************************/
 
-#include "v3/handle.h"
+#include "handle.h"
 
 #include <sys/eventfd.h>
 #include <unistd.h>
@@ -31,11 +31,11 @@
 
 #include <utouch/frame_x11.h>
 
-#include "v3/atomic-recognizer.h"
-#include "v3/event.h"
-#include "v3/log.h"
-#include "v3/regular-recognizer.h"
-#include "v3/subscription.h"
+#include "atomic-recognizer.h"
+#include "event.h"
+#include "log.h"
+#include "regular-recognizer.h"
+#include "subscription.h"
 
 namespace utouch {
 namespace grail {

=== renamed file 'src/v3/handle.h' => 'src/handle.h'
--- src/v3/handle.h	2012-03-26 12:57:55 +0000
+++ src/handle.h	2012-05-09 17:32:19 +0000
@@ -29,7 +29,7 @@
 #include <X11/X.h>
 
 #include "utouch/grail.h"
-#include "v3/forward.h"
+#include "forward.h"
 
 struct UGHandle_ {};
 

=== modified file 'src/libutouch-grail.ver'
--- src/libutouch-grail.ver	2012-01-25 17:49:58 +0000
+++ src/libutouch-grail.ver	2012-05-09 17:32:19 +0000
@@ -1,30 +1,3 @@
-UTOUCH_GRAIL_2.0 {
-  global:
-    grail_close;
-    grail_delete;
-    grail_filter_abs_events;
-    grail_get_contact_frame;
-    grail_get_contacts;
-    grail_get_control;
-    grail_get_units;
-    grail_get_version;
-    grail_idle;
-    grail_mask_clear_mask;
-    grail_mask_count;
-    grail_mask_get_first;
-    grail_mask_get_next;
-    grail_mask_set_mask;
-    grail_new_raw;
-    grail_open;
-    grail_pull;
-    grail_pump_frame;
-    grail_set_bbox;
-    grail_set_coordinate_transform_callback;
-
-  local:
-    *;
-};
-
 UTOUCH_GRAIL_3.0 {
   global:
     grail_accept_gesture;
@@ -63,4 +36,7 @@
     grail_subscription_new;
     grail_subscription_set_property;
     grail_update_time;
-} UTOUCH_GRAIL_2.0;
+
+  local:
+    *;
+};

=== renamed file 'src/v3/log.cpp' => 'src/log.cpp'
--- src/v3/log.cpp	2012-03-26 12:57:55 +0000
+++ src/log.cpp	2012-05-09 17:32:19 +0000
@@ -18,7 +18,7 @@
  *
  ****************************************************************************/
 
-#include "v3/log.h"
+#include "log.h"
 
 #include <cstdlib>
 

=== renamed file 'src/v3/log.h' => 'src/log.h'
=== renamed file 'src/v3/recognizer.cpp' => 'src/recognizer.cpp'
--- src/v3/recognizer.cpp	2012-04-03 14:22:54 +0000
+++ src/recognizer.cpp	2012-05-09 17:32:19 +0000
@@ -18,7 +18,7 @@
  *
  ****************************************************************************/
 
-#include "v3/recognizer.h"
+#include "recognizer.h"
 
 #include <algorithm>
 #include <cassert>
@@ -29,10 +29,10 @@
 #include <utouch/frame.h>
 #include <utouch/frame_x11.h>
 
-#include "v3/handle.h"
-#include "v3/gesture.h"
-#include "v3/log.h"
-#include "v3/touch.h"
+#include "handle.h"
+#include "gesture.h"
+#include "log.h"
+#include "touch.h"
 
 namespace utouch {
 namespace grail {

=== renamed file 'src/v3/recognizer.h' => 'src/recognizer.h'
--- src/v3/recognizer.h	2012-04-03 14:24:54 +0000
+++ src/recognizer.h	2012-05-09 17:32:19 +0000
@@ -29,8 +29,8 @@
 #include <utouch/frame.h>
 
 #include "utouch/grail.h"
-#include "v3/forward.h"
-#include "v3/subscription.h"
+#include "forward.h"
+#include "subscription.h"
 
 #define INSERT_TOUCH(touch, map) \
   { \

=== renamed file 'src/v3/regular-recognizer.cpp' => 'src/regular-recognizer.cpp'
--- src/v3/regular-recognizer.cpp	2012-04-03 14:24:54 +0000
+++ src/regular-recognizer.cpp	2012-05-09 17:32:19 +0000
@@ -18,7 +18,7 @@
  *
  ****************************************************************************/
 
-#include "v3/regular-recognizer.h"
+#include "regular-recognizer.h"
 
 #include <algorithm>
 #include <cassert>
@@ -29,10 +29,10 @@
 #include <utouch/frame.h>
 #include <utouch/frame_x11.h>
 
-#include "v3/handle.h"
-#include "v3/gesture.h"
-#include "v3/log.h"
-#include "v3/touch.h"
+#include "handle.h"
+#include "gesture.h"
+#include "log.h"
+#include "touch.h"
 
 namespace utouch {
 namespace grail {

=== renamed file 'src/v3/regular-recognizer.h' => 'src/regular-recognizer.h'
--- src/v3/regular-recognizer.h	2012-04-03 14:24:54 +0000
+++ src/regular-recognizer.h	2012-05-09 17:32:19 +0000
@@ -21,7 +21,7 @@
 #ifndef UTOUCH_GRAIL_REGULAR_RECOGNIZER_H_
 #define UTOUCH_GRAIL_REGULAR_RECOGNIZER_H_
 
-#include "v3/recognizer.h"
+#include "recognizer.h"
 
 namespace utouch {
 namespace grail {

=== renamed file 'src/v3/slice.cpp' => 'src/slice.cpp'
--- src/v3/slice.cpp	2012-03-26 19:29:08 +0000
+++ src/slice.cpp	2012-05-09 17:32:19 +0000
@@ -18,7 +18,7 @@
  *
  ****************************************************************************/
 
-#include "v3/slice.h"
+#include "slice.h"
 
 #include <cassert>
 #include <cmath>
@@ -28,11 +28,11 @@
 
 #include <utouch/frame.h>
 
-#include "v3/gesture.h"
-#include "v3/log.h"
-#include "v3/recognizer.h"
-#include "v3/subscription.h"
-#include "v3/touch.h"
+#include "gesture.h"
+#include "log.h"
+#include "recognizer.h"
+#include "subscription.h"
+#include "touch.h"
 
 namespace {
 

=== renamed file 'src/v3/slice.h' => 'src/slice.h'
--- src/v3/slice.h	2012-03-26 19:29:08 +0000
+++ src/slice.h	2012-05-09 17:32:19 +0000
@@ -25,7 +25,7 @@
 #include <set>
 
 #include "utouch/grail.h"
-#include "v3/forward.h"
+#include "forward.h"
 
 struct UGSlice_ {};
 

=== renamed file 'src/v3/subscription.cpp' => 'src/subscription.cpp'
--- src/v3/subscription.cpp	2012-03-26 12:57:55 +0000
+++ src/subscription.cpp	2012-05-09 17:32:19 +0000
@@ -18,7 +18,7 @@
  *
  ****************************************************************************/
 
-#include "v3/subscription.h"
+#include "subscription.h"
 
 #include <cmath>
 

=== renamed file 'src/v3/subscription.h' => 'src/subscription.h'
--- src/v3/subscription.h	2012-03-26 12:57:55 +0000
+++ src/subscription.h	2012-05-09 17:32:19 +0000
@@ -24,7 +24,7 @@
 #include <X11/X.h>
 
 #include "utouch/grail.h"
-#include "v3/forward.h"
+#include "forward.h"
 
 struct UGSubscription_ {};
 

=== renamed file 'src/v3/touch.cpp' => 'src/touch.cpp'
--- src/v3/touch.cpp	2012-03-27 15:52:30 +0000
+++ src/touch.cpp	2012-05-09 17:32:19 +0000
@@ -18,11 +18,11 @@
  *
  ****************************************************************************/
 
-#include "v3/touch.h"
+#include "touch.h"
 
 #include <utouch/frame_x11.h>
 
-#include "v3/log.h"
+#include "log.h"
 
 namespace utouch {
 namespace grail {

=== renamed file 'src/v3/touch.h' => 'src/touch.h'
=== removed directory 'src/v2'
=== removed file 'src/v2/evbuf.h'
--- src/v2/evbuf.h	2012-03-26 12:57:55 +0000
+++ src/v2/evbuf.h	1970-01-01 00:00:00 +0000
@@ -1,56 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_EVBUF_H
-#define GRAIL_EVBUF_H
-
-#define DIM_EVENTS 4096
-
-struct evbuf {
-	int head;
-	int tail;
-	struct input_event buffer[DIM_EVENTS];
-};
-
-static inline void evbuf_clear(struct evbuf *evbuf)
-{
-	evbuf->head = evbuf->tail = 0;
-}
-
-static inline int evbuf_empty(const struct evbuf *evbuf)
-{
-	return evbuf->head == evbuf->tail;
-}
-
-static inline void evbuf_put(struct evbuf *evbuf,
-			     const struct input_event *ev)
-{
-	evbuf->buffer[evbuf->head++] = *ev;
-	evbuf->head &= DIM_EVENTS - 1;
-}
-
-static inline void evbuf_get(struct evbuf *evbuf,
-			     struct input_event *ev)
-{
-	*ev = evbuf->buffer[evbuf->tail++];
-	evbuf->tail &= DIM_EVENTS - 1;
-}
-
-#endif

=== removed file 'src/v2/gebuf.h'
--- src/v2/gebuf.h	2012-03-26 12:57:55 +0000
+++ src/v2/gebuf.h	1970-01-01 00:00:00 +0000
@@ -1,67 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_GESTURE_BUFFER_H
-#define GRAIL_GESTURE_BUFFER_H
-
-#include "grail-impl.h"
-
-#define DIM_GESTURE_EVENTS 512
-
-struct gesture_event {
-	int status;
-	int ntouch;
-	int nprop;
-	utouch_frame_time_t time;
-	struct grail_coord pos;
-	grail_prop_t prop[DIM_GRAIL_PROP];
-};
-
-struct gebuf {
-	int head;
-	int tail;
-	struct gesture_event buffer[DIM_GESTURE_EVENTS];
-};
-
-static inline void gebuf_clear(struct gebuf *gebuf)
-{
-	gebuf->head = gebuf->tail = 0;
-}
-
-static inline int gebuf_empty(const struct gebuf *gebuf)
-{
-	return gebuf->head == gebuf->tail;
-}
-
-static inline void gebuf_put(struct gebuf *gebuf,
-			     const struct gesture_event *ev)
-{
-	gebuf->buffer[gebuf->head++] = *ev;
-	gebuf->head &= DIM_GESTURE_EVENTS - 1;
-}
-
-static inline void gebuf_get(struct gebuf *gebuf,
-			     struct gesture_event *ev)
-{
-	*ev = gebuf->buffer[gebuf->tail++];
-	gebuf->tail &= DIM_GESTURE_EVENTS - 1;
-}
-
-#endif

=== removed file 'src/v2/gestures-drag.c'
--- src/v2/gestures-drag.c	2012-03-26 12:57:55 +0000
+++ src/v2/gestures-drag.c	1970-01-01 00:00:00 +0000
@@ -1,134 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2013 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	-1,
-	GRAIL_TYPE_DRAG1,
-	GRAIL_TYPE_DRAG2,
-	GRAIL_TYPE_DRAG3,
-	GRAIL_TYPE_DRAG4,
-	GRAIL_TYPE_DRAG5,
-};
-
-static void set_props(const struct gesture_inserter *gin,
-		      struct combo_model *s, const struct move_model *m,
-		      const struct utouch_frame *frame)
-{
-	if (m->single) {
-		s->prop[GRAIL_PROP_DRAG_DX] = m->fm[FM_X].raw_delta;
-		s->prop[GRAIL_PROP_DRAG_DY] = m->fm[FM_Y].raw_delta;
-	} else {
-		s->prop[GRAIL_PROP_DRAG_DX] = m->fm[FM_X].action_delta;
-		s->prop[GRAIL_PROP_DRAG_DY] = m->fm[FM_Y].action_delta;
-	}
-	s->prop[GRAIL_PROP_DRAG_VX] = m->fm[FM_X].velocity;
-	s->prop[GRAIL_PROP_DRAG_VY] = m->fm[FM_Y].velocity;
-	s->prop[GRAIL_PROP_DRAG_X] = m->fm[FM_X].value;
-	s->prop[GRAIL_PROP_DRAG_Y] = m->fm[FM_Y].value;
-	s->nprop = 6;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-static const int fm_mask = 0x03;
-
-int gru_drag(struct grail *ge,
-	    const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->drag;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (type < 0)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_windrag(struct grail *ge,
-		const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->windrag;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MDRAG,
-						   PRIO_META, frame);
-			state->mintouch = 1;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EDRAG,
-						   PRIO_ENV, frame);
-			state->mintouch = 1;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-

=== removed file 'src/v2/gestures-pinch.c'
--- src/v2/gestures-pinch.c	2012-03-26 12:57:55 +0000
+++ src/v2/gestures-pinch.c	1970-01-01 00:00:00 +0000
@@ -1,130 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	0,
-	0,
-	GRAIL_TYPE_PINCH2,
-	GRAIL_TYPE_PINCH3,
-	GRAIL_TYPE_PINCH4,
-	GRAIL_TYPE_PINCH5,
-};
-
-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 utouch_frame *frame)
-{
-	s->prop[GRAIL_PROP_PINCH_DR] = m->fm[FM_R].action_delta;
-	s->prop[GRAIL_PROP_PINCH_VR] = m->fm[FM_R].velocity;
-	s->prop[GRAIL_PROP_PINCH_R] = m->fm[FM_R].value;
-	s->prop[GRAIL_PROP_PINCH_X] = m->fm[FM_X].value;
-	s->prop[GRAIL_PROP_PINCH_Y] = m->fm[FM_Y].value;
-	s->nprop = 5;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-int gru_pinch(struct grail *ge,
-	      const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->pinch;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (!type)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_winpinch(struct grail *ge,
-		 const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->winpinch;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MPINCH,
-						   PRIO_META, frame);
-			state->mintouch = 2;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EPINCH,
-						   PRIO_ENV, frame);
-			state->mintouch = 2;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}

=== removed file 'src/v2/gestures-rotate.c'
--- src/v2/gestures-rotate.c	2012-03-26 12:57:55 +0000
+++ src/v2/gestures-rotate.c	1970-01-01 00:00:00 +0000
@@ -1,129 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	0,
-	0,
-	GRAIL_TYPE_ROTATE2,
-	GRAIL_TYPE_ROTATE3,
-	GRAIL_TYPE_ROTATE4,
-	GRAIL_TYPE_ROTATE5,
-};
-
-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 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;
-	s->prop[GRAIL_PROP_ROTATE_A] = m->fm[FM_A].value;
-	s->prop[GRAIL_PROP_ROTATE_X] = m->fm[FM_X].value;
-	s->prop[GRAIL_PROP_ROTATE_Y] = m->fm[FM_Y].value;
-	s->nprop = 5;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-int gru_rotate(struct grail *ge,
-	       const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->rotate;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (!type)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_winrotate(struct grail *ge,
-		  const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->winrotate;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MROTATE,
-						   PRIO_META, frame);
-			state->mintouch = 2;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EROTATE,
-						   PRIO_ENV, frame);
-			state->mintouch = 2;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}

=== removed file 'src/v2/gestures-tapping.c'
--- src/v2/gestures-tapping.c	2012-03-26 12:57:55 +0000
+++ src/v2/gestures-tapping.c	1970-01-01 00:00:00 +0000
@@ -1,99 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-
-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 utouch_frame *frame)
-{
-	s->prop[GRAIL_PROP_TAP_DT] = m->time - s->start;
-	s->prop[GRAIL_PROP_TAP_X] = m->fm[FM_X].value;
-	s->prop[GRAIL_PROP_TAP_Y] = m->fm[FM_Y].value;
-	s->nprop = 3;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-int gru_tapping(struct grail *ge,
-		const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct tapping_model *state = &gru->tapping;
-	struct move_model *move = &gru->move;
-	state->tap = 0;
-	if (frame->num_active && !frame->prev->num_active) {
-		state->mintouch = 0;
-		state->maxtouch = 0;
-	}
-	if (move->ntouch > state->maxtouch) {
-		if (state->active) {
-			gin_gid_discard(ge, state->gid);
-			state->active = 0;
-		}
-		state->start = move->time;
-		state->maxtouch = move->ntouch;
-		set_props(ge->gin, state, move, frame);
-		if (state->maxtouch <= 5) {
-			int type = GRAIL_TYPE_TAP1 + state->maxtouch - 1;
-			state->gid = gin_gid_begin(ge, type, PRIO_TAP, frame);
-			state->active = 1;
-		}
-		return 0;
-	}
-	if (!state->active) {
-		state->mintouch = move->ntouch;
-		state->maxtouch = move->ntouch;
-		return 0;
-	}
-	if (move->ntouch <= state->mintouch) {
-		int x = state->prop[GRAIL_PROP_TAP_X];
-		int y = state->prop[GRAIL_PROP_TAP_Y];
-		int t = move->time - state->start;
-		if (t > move->fm[FM_X].bar_ms) {
-			gin_gid_discard(ge, state->gid);
-			state->mintouch = move->ntouch;
-			state->maxtouch = move->ntouch;
-			state->active = 0;
-			return 0;
-		}
-		state->tap = state->maxtouch;
-		state->prop[GRAIL_PROP_TAP_DT] = t;
-		gin_gid_event(ge, state->gid, x, y, state->maxtouch,
-			      state->prop, state->nprop, 1);
-		state->mintouch = move->ntouch;
-		state->maxtouch = move->ntouch;
-		state->active = 0;
-		return 1;
-	}
-	if (!move->ntouch)
-		return 0;
-	state->prop[GRAIL_PROP_TAP_DT] = move->time - state->start;
-	if ((move->active & fm_mask) ||
-	    move->time - state->start > move->fm[FM_X].bar_ms) {
-		gin_gid_discard(ge, state->gid);
-		state->mintouch = move->ntouch;
-		state->maxtouch = move->ntouch;
-		state->active = 0;
-	}
-	return 0;
-}

=== removed file 'src/v2/gestures-touch.c'
--- src/v2/gestures-touch.c	2012-03-26 12:57:55 +0000
+++ src/v2/gestures-touch.c	1970-01-01 00:00:00 +0000
@@ -1,97 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	-1,
-	GRAIL_TYPE_TOUCH1,
-	GRAIL_TYPE_TOUCH2,
-	GRAIL_TYPE_TOUCH3,
-	GRAIL_TYPE_TOUCH4,
-	GRAIL_TYPE_TOUCH5,
-};
-
-int gru_touch(struct grail *ge,
-	      const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->touch;
-	struct move_model *move = &gru->move;
-	if (frame->slot_revision != frame->prev->slot_revision) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (type <= 0)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, -PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (move->time - move->fm[FM_X].original_ms <= move->fm[FM_X].hold_ms)
-		return 0;
-	state->nprop = gin_add_contact_props(ge->gin, state->prop, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_wintouch(struct grail *ge,
-		 const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->wintouch;
-	struct move_model *move = &gru->move;
-	if (frame->slot_revision != frame->prev->slot_revision) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MTOUCH,
-						   -PRIO_META, frame);
-			state->mintouch = 1;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_ETOUCH,
-						   -PRIO_ENV, frame);
-			state->mintouch = 1;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (move->time - move->fm[FM_X].original_ms <= move->fm[FM_X].hold_ms)
-		return 0;
-	state->nprop = gin_add_contact_props(ge->gin, state->prop, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}

=== removed file 'src/v2/grail-api.c'
--- src/v2/grail-api.c	2012-03-26 12:57:55 +0000
+++ src/v2/grail-api.c	1970-01-01 00:00:00 +0000
@@ -1,327 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-impl.h"
-#include "grail-inserter.h"
-#include "grail-recognizer.h"
-#include <string.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <malloc.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-
-#define DIM_FRAMES 100
-#define FRAME_RATE 100
-
-unsigned int GRAIL_PUBLIC grail_get_version(void)
-{
-	return GRAIL_VERSION;
-}
-
-int GRAIL_PUBLIC grail_open(struct grail *ge, int fd)
-{
-	struct grail_impl *x;
-	struct stat fs;
-	int ret;
-
-	ret = fstat(fd, &fs);
-	if (ret)
-		return ret;
-
-	x = calloc(1, sizeof(*x));
-	if (!x)
-		return -ENOMEM;
-
-	if (!fs.st_rdev)
-		x->fptest = fdopen(fd, "r");
-
-	x->evemu = evemu_new(x->fptest ? "fptest" : 0);
-	if (!x->evemu) {
-		ret = -ENOMEM;
-		goto freemem;
-	}
-	if (x->fptest)
-		ret = evemu_read(x->evemu, x->fptest) <= 0;
-	else
-		ret = evemu_extract(x->evemu, fd);
-	if (ret)
-		goto freemem;
-	if (!utouch_frame_is_supported_mtdev(x->evemu)) {
-		ret = -ENODEV;
-		goto freemem;
-	}
-
-	if (!x->fptest) {
-		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;
-
-	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:
-	if (x->mtdev)
-		mtdev_close_delete(x->mtdev);
- freemem:
-	evemu_delete(x->evemu);
-	if (x->fptest)
-		fclose(x->fptest);
-	free(x);
-	ge->impl = 0;
-	return ret;
-}
-
-void GRAIL_PUBLIC grail_close(struct grail *ge, int fd)
-{
-	struct grail_impl *x = ge->impl;
-	gru_destroy(ge);
-	gin_destroy(ge);
-	utouch_frame_delete_engine(x->fh);
-	if (x->mtdev)
-		mtdev_close_delete(x->mtdev);
-	evemu_delete(x->evemu);
-	if (x->fptest)
-		fclose(x->fptest);
-	free(x);
-	ge->impl = 0;
-}
-
-int GRAIL_PUBLIC grail_idle(struct grail *ge, int fd, int ms)
-{
-	struct grail_impl *x = ge->impl;
-	if (x->fptest)
-		return 0;
-	if (x->mtdev)
-		return mtdev_idle(x->mtdev, fd, ms);
-	return 1;
-}
-
-void GRAIL_PUBLIC 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;
-}
-
-const struct utouch_frame GRAIL_PUBLIC *
-grail_get_contact_frame(const struct grail *ge)
-{
-	return ge->impl->touch;
-}
-
-static void flush_events(struct grail *ge)
-{
-	struct grail_impl *impl = ge->impl;
-	struct input_event iev;
-
-	grailbuf_clear(&impl->gbuf);
-	while (!evbuf_empty(&impl->evbuf)) {
-		evbuf_get(&impl->evbuf, &iev);
-		if (ge->event)
-			ge->event(ge, &iev);
-	}
-}
-
-static int skip_event(const struct input_event *ev, int count)
-{
-	switch (ev->type) {
-	case EV_ABS:
-		return 1;
-	case EV_KEY:
-		return ev->code >= BTN_DIGI && ev->code < BTN_WHEEL;
-	case EV_SYN:
-		switch (ev->code) {
-		case SYN_MT_REPORT:
-			return 1;
-		case SYN_REPORT:
-			return count == 0;
-		default:
-			return 0;
-		}
-	default:
-		return 0;
-	}
-}
-
-static void flush_gestures(struct grail *ge)
-{
-	struct grail_impl *impl = ge->impl;
-	struct input_event iev;
-	struct grail_event gev;
-	int count = 0;
-
-	while (!evbuf_empty(&impl->evbuf)) {
-		evbuf_get(&impl->evbuf, &iev);
-		if (skip_event(&iev, count))
-			continue;
-		if (ge->event)
-			ge->event(ge, &iev);
-		if (iev.type == EV_SYN && iev.code == SYN_REPORT)
-			count = 0;
-		else
-			count++;
-	}
-	while (!grailbuf_empty(&impl->gbuf)) {
-		grailbuf_get(&impl->gbuf, &gev);
-		if (ge->gesture)
-			ge->gesture(ge, &gev);
-	}
-}
-
-static int gesture_timeout(struct grail *ge, const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct gesture_inserter *gin = ge->gin;
-
-	return grail_mask_count(gin->used, sizeof(gin->used)) == 0 &&
-		frame->time - frame->mod_time > gru->move.fm[FM_X].hold_ms;
-}
-
-static void report_frame(struct grail *ge,
-			 const struct utouch_frame *touch,
-			 const struct input_event *syn)
-{
-	struct grail_impl *impl = ge->impl;
-
-	impl->touch = touch;
-
-	if (touch->num_active && !touch->prev->num_active) {
-		impl->ongoing = 1;
-		impl->gesture = 0;
-	}
-
-	if (!impl->ongoing)
-		return;
-
-	gin_frame_begin(ge, touch);
-	gru_recognize(ge, touch);
-	gin_frame_end(ge, touch);
-
-	if (!grailbuf_empty(&impl->gbuf))
-		impl->gesture = 1;
-
-	if (touch->num_active == 0 || gesture_timeout(ge, touch))
-		impl->ongoing &= impl->gesture;
-}
-
-static void grail_pump_mtdev(struct grail *ge, const struct input_event *ev)
-{
-	struct grail_impl *impl = ge->impl;
-	const struct utouch_frame *frame;
-
-	evbuf_put(&impl->evbuf, ev);
-
-	if (ev->type == EV_SYN || ev->type == EV_ABS || ev->type == EV_KEY) {
-		frame = utouch_frame_pump_mtdev(impl->fh, ev);
-		if (frame)
-			report_frame(ge, frame, ev);
-	}
-
-	if (ev->type == EV_SYN) {
-		if (!impl->ongoing)
-			flush_events(ge);
-		if (impl->gesture)
-			flush_gestures(ge);
-	}
-}
-
-/**
- * Read an event from the given file. If fast_fileread is true,
- * return immediately. If it is false, delay between events
- * so it looks like they are coming in real time.
- */
-static int grail_read_evemu_event(FILE *fp, struct input_event *ev,
-		      struct timeval *evtime, int fast_fileread) {
-	if (fast_fileread)
-		return evemu_read_event(fp, ev);
-	return evemu_read_event_realtime(fp, ev, evtime);
-}
-
-
-static int grail_pull_fstest(struct grail *ge, int fd)
-{
-	struct grail_impl *impl = ge->impl;
-	struct input_event ev;
-	struct timeval evtime;
-        int count = 0;
-
-	memset(&evtime, 0, sizeof(evtime));
-	while (grail_read_evemu_event(impl->fptest, &ev, &evtime, impl->fast_fileread) > 0) {
-		grail_pump_mtdev(ge, &ev);
-		count++;
-	}
-
-	fclose(impl->fptest);
-	impl->fptest = 0;
-
-        return count > 0 ? count : -1;
-}
-
-int GRAIL_PUBLIC grail_pull(struct grail *ge, int fd)
-{
-	struct grail_impl *impl = ge->impl;
-	struct input_event ev;
-        int ret, count = 0;
-
-	if (impl->fptest)
-		return grail_pull_fstest(ge, fd);
-
-        while ((ret = mtdev_get(impl->mtdev, fd, &ev, 1)) > 0) {
-		grail_pump_mtdev(ge, &ev);
-                count++;
-        }
-
-        return count > 0 ? count : ret;
-}
-
-void GRAIL_PUBLIC grail_set_coordinate_transform_callback(struct grail *ge,
-							  utouch_coordinate_transform_cb callback,
-							  void *user_data) {
-	utouch_frame_set_coordinate_transform_callback(ge->impl->fh, callback, user_data);
-}

=== removed file 'src/v2/grail-bits.c'
--- src/v2/grail-bits.c	2012-03-26 12:57:55 +0000
+++ src/v2/grail-bits.c	1970-01-01 00:00:00 +0000
@@ -1,92 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-bits.h"
-
-static const int grail_bits_in_byte[256] =
-{
-	0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
-	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
-	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
-	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
-	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
-	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
-	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
-	3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8,
-};
-
-static const int grail_first_set_bit[256] =
-{
-	-1,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-};
-
-void GRAIL_PUBLIC grail_mask_set_mask(grail_mask_t *a, const grail_mask_t *b,
-				      int bytes)
-{
-	while (bytes--)
-		*a++ |= *b++;
-}
-
-void GRAIL_PUBLIC grail_mask_clear_mask(grail_mask_t *a, const grail_mask_t *b,
-					int bytes)
-{
-	while (bytes--)
-		*a++ &= ~*b++;
-}
-
-int GRAIL_PUBLIC grail_mask_count(const grail_mask_t *mask, int bytes)
-{
-	int count = 0;
-	while (bytes--)
-		count += grail_bits_in_byte[*mask++];
-	return count;
-}
-
-int GRAIL_PUBLIC grail_mask_get_first(const grail_mask_t *mask, int bytes)
-{
-	int k;
-	for (k = 0; k < bytes; k++)
-		if (mask[k])
-			return (k << 3) | grail_first_set_bit[mask[k]];
-	return -1;
-}
-
-int GRAIL_PUBLIC grail_mask_get_next(int i, const grail_mask_t *mask, int bytes)
-{
-	int k = ++i >> 3;
-	if (k < bytes) {
-		i = grail_first_set_bit[mask[k] & (~0 << (i & 7))];
-		if (i >= 0)
-			return (k << 3) | i;
-		while (++k < bytes) {
-			i = grail_first_set_bit[mask[k]];
-			if (i >= 0)
-				return (k << 3) | i;
-		}
-	}
-	return -1;
-}

=== removed file 'src/v2/grail-event.c'
--- src/v2/grail-event.c	2012-03-26 12:57:55 +0000
+++ src/v2/grail-event.c	1970-01-01 00:00:00 +0000
@@ -1,117 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-inserter.h"
-#include "grail-impl.h"
-#include <malloc.h>
-#include <string.h>
-#include <errno.h>
-#include <math.h>
-
-static void compute_bbox(struct grail_coord *min, struct grail_coord *max,
-			 const struct utouch_frame *frame)
-{
-	float x, y;
-	int i;
-	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->num_active; i++) {
-		x = frame->active[i]->x;
-		y = frame->active[i]->y;
-		if (x < min->x)
-			min->x = x;
-		if (y < min->y)
-			min->y = y;
-		if (x > max->x)
-			max->x = x;
-		if (y > max->y)
-			max->y = y;
-	}
-}
-
-int gin_add_contact_props(const struct gesture_inserter *gin,
-			  grail_prop_t *prop, const struct utouch_frame *frame)
-{
-	struct grail_coord min = { 0, 0 };
-	struct grail_coord max = { 0, 0 };
-	int i, n = 0, ntouch = frame->num_active;
-	if (!ntouch)
-		return n;
-	if (ntouch > 5)
-		ntouch = 5;
-	compute_bbox(&min, &max, frame);
-	prop[n++] = min.x;
-	prop[n++] = min.y;
-	prop[n++] = max.x;
-	prop[n++] = max.y;
-	for (i = 0; i < ntouch; i++) {
-		const struct utouch_contact *ct = frame->active[i];
-		prop[n++] = ct->id;
-		prop[n++] = ct->x;
-		prop[n++] = ct->y;
-	}
-	return n;
-}
-
-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 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 = frame->slots[i]->x;
-		pos[npos].y = frame->slots[i]->y;
-		npos++;
-	}
-	return ge->get_clients(ge, info, maxinfo, pos, npos, types, btypes);
-}
-
-void gin_send_event(struct grail *ge, struct slot_state *s,
-		    const struct gesture_event *ev,
-		    const struct utouch_frame *frame)
-{
-	struct grail_impl *impl = ge->impl;
-	struct grail_event gev;
-	int i;
-	if (!ge->gesture)
-		return;
-	gev.type = s->type;
-	gev.id = s->id;
-	gev.status = ev->status;
-	gev.ntouch = ev->ntouch;
-	gev.nprop = ev->nprop;
-	gev.time = ev->time;
-	gev.pos.x = ev->pos.x;
-	gev.pos.y = ev->pos.y;
-	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];
-		grailbuf_put(&impl->gbuf, &gev);
-	}
-}

=== removed file 'src/v2/grail-frame.c'
--- src/v2/grail-frame.c	2012-03-26 12:57:55 +0000
+++ src/v2/grail-frame.c	1970-01-01 00:00:00 +0000
@@ -1,409 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-impl.h"
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-
-static void set_center_velocity_and_radius(struct grail_impl *impl,
-					   struct grail_element *slot)
-{
-	const struct utouch_contact **tc = slot->touches;
-	double x, y, vx, vy, r2, dx, dy;
-	int i;
-
-	switch (slot->num_touches) {
-	case 1:
-		x = tc[0]->x;
-		y = tc[0]->y;
-		vx = tc[0]->vx;
-		vy = tc[0]->vy;
-		r2 = 0;
-		break;
-	case 2:
-		dx = 0.5 * (tc[1]->x - tc[0]->x);
-		dy = 0.5 * (tc[1]->y - tc[0]->y);
-		x = tc[0]->x + dx;
-		y = tc[0]->y + dy;
-		vx = 0.5 * (tc[0]->vx + tc[1]->vx);
-		vy = 0.5 * (tc[0]->vy + tc[1]->vy);
-		r2 = dx * dx + dy * dy;
-		break;
-	default:
-		x = y = vx = vy = r2 = 0;
-		for (i = 0; i < slot->num_touches; i++) {
-			x += tc[i]->x;
-			y += tc[i]->y;
-			vx += tc[i]->vx;
-			vy += tc[i]->vy;
-		}
-		x /= slot->num_touches;
-		y /= slot->num_touches;
-		vx /= slot->num_touches;
-		vy /= slot->num_touches;
-		for (i = 0; i < slot->num_touches; i++) {
-			dx = tc[i]->x - x;
-			dy = tc[i]->y - y;
-			r2 += dx * dx + dy * dy;
-		}
-		r2 /= slot->num_touches;
-		break;
-	}
-
-	slot->center.x = x;
-	slot->center.y = y;
-	slot->velocity.x = 1000 * vx;
-	slot->velocity.y = 1000 * vy;
-	slot->radius2 = r2;
-}
-
-static void set_transform(struct grail_impl *impl, struct grail_element *slot,
-			  double ds, double dc)
-{
-	const struct grail_element *pslot = slot->prev;
-	double dx = slot->center.x - pslot->center.x;
-	double dy = slot->center.y - pslot->center.y;
-	float *T = slot->transform;
-
-	T[0] = dc;
-	T[1] = ds;
-	T[2] = dx;
-	T[3] = -ds;
-	T[4] = dc;
-	T[5] = dy;
-
-	slot->drag.x = pslot->drag.x + dx;
-	slot->drag.y = pslot->drag.y + dy;
-}
-
-static void start_slot(struct grail_impl *impl,
-		       struct grail_element *slot,
-		       const struct utouch_frame *touch)
-{
-	float *T = slot->transform;
-
-	slot->id = impl->seqid++ & GRAIL_ID_MAX;
-	slot->expect_mask = GRAIL_EXPECT_MASK;
-	slot->active_mask = 0;
-	slot->start_time = touch->time;
-	set_center_velocity_and_radius(impl, slot);
-	T[0] = T[4] = 1;
-	T[1] = T[2] = T[3] = T[5] = 0;
-	slot->drag.x = 0;
-	slot->drag.y = 0;
-	slot->scale2 = 1;
-	slot->angle = 0;
-}
-
-static void update_slot(struct grail_impl *impl,
-			struct grail_element *slot,
-			double ds, double dc)
-{
-	const struct grail_element *pslot = slot->prev;
-
-	slot->id = pslot->id;
-	slot->start_time = pslot->start_time;
-	slot->expect_mask = pslot->expect_mask;
-	slot->active_mask = pslot->active_mask;
-
-	set_center_velocity_and_radius(impl, slot);
-	set_transform(impl, slot, ds, dc);
-
-	slot->scale2 = pslot->scale2 * (ds * ds + dc * dc);
-	slot->angle = pslot->angle + ds / dc; /* atan2(ds, dc) */
-}
-
-static void stop_slot(struct grail_impl *impl,
-		      struct grail_element *slot)
-{
-	const struct grail_element *pslot = slot->prev;
-	float *T = slot->transform;
-
-	slot->id = -1;
-	slot->num_touches = 0;
-	slot->start_time = pslot->start_time;
-	slot->expect_mask = 0;
-	slot->active_mask = pslot->active_mask;
-	slot->center = pslot->center;
-	slot->velocity = pslot->velocity;
-	slot->radius2 = pslot->radius2;
-	T[0] = T[4] = 1;
-	T[1] = T[2] = T[3] = T[5] = 0;
-	slot->drag = pslot->drag;
-	slot->scale2 = pslot->scale2;
-	slot->angle = pslot->angle;
-}
-
-static void set_slot_one(struct grail_impl *impl,
-			 struct grail_element *slot,
-			 const struct utouch_frame *touch,
-			 const struct utouch_contact *t1)
-{
-	const struct grail_element *pslot = slot->prev;
-	const struct utouch_contact *p1 = pslot->touches[0];
-
-	if (!t1->active) {
-		stop_slot(impl, slot);
-		return;
-	}
-
-	slot->touches[0] = t1;
-	slot->num_touches = 1;
-
-	if (pslot->num_touches != slot->num_touches || t1->id != p1->id) {
-		start_slot(impl, slot, touch);
-		return;
-	}
-
-	update_slot(impl, slot, 0, 1);
-}
-
-static void set_slot_two(struct grail_impl *impl,
-			 struct grail_element *slot,
-			 const struct utouch_frame *touch,
-			 const struct utouch_contact *t1,
-			 const struct utouch_contact *t2)
-{
-	const struct grail_element *pslot = slot->prev;
-	const struct utouch_contact *p1 = pslot->touches[0];
-	const struct utouch_contact *p2 = pslot->touches[1];
-	double tx, ty, px, py, d2;
-
-	if (!t1->active || !t2->active) {
-		stop_slot(impl, slot);
-		return;
-	}
-
-	slot->touches[0] = t1;
-	slot->touches[1] = t2;
-	slot->num_touches = 2;
-
-	if (pslot->num_touches != slot->num_touches ||
-	    t1->id != p1->id || t2->id != p2->id) {
-		start_slot(impl, slot, touch);
-		return;
-	}
-
-	tx = t2->x - t1->x;
-	ty = t2->y - t1->y;
-	px = p2->x - p1->x;
-	py = p2->y - p1->y;
-
-	d2 = px * px + py * py;
-	if (d2 > 0) {
-		px /= d2;
-		py /= d2;
-	}
-
-	update_slot(impl, slot, tx * py - ty * px, tx * px + ty * py);
-}
-
-static void set_slot_multi(struct grail_impl *impl,
-			   struct grail_element *slot,
-			   struct grail_frame *frame,
-			   const struct utouch_frame *touch)
-{
-	const struct grail_element *pslot = slot->prev;
-	struct grail_element **slots = frame->slots;
-	int i, j, n = impl->num_touches;
-	struct grail_element *best = 0;
-
-	if (touch->num_active < 3) {
-		stop_slot(impl, slot);
-		return;
-	}
-
-	memcpy(slot->touches, touch->active,
-	       touch->num_active * sizeof(slot->touches[0]));
-	slot->num_touches = touch->num_active;
-
-	if (pslot->num_touches != slot->num_touches) {
-		start_slot(impl, slot, touch);
-		return;
-	}
-
-	for (i = 0; i < slot->num_touches; i++) {
-		if (slot->touches[i]->id != pslot->touches[i]->id) {
-			start_slot(impl, slot, touch);
-			return;
-		}
-	}
-
-	for (i = 0; i < impl->num_touches; i++) {
-		for (j = i + 1; j < impl->num_touches; j++) {
-			struct grail_element *s = slots[n++];
-			if (!s->num_touches)
-				continue;
-			if (!best || s->radius2 > best->radius2)
-				best = s;
-		}
-	}
-
-	update_slot(impl, slot, best->transform[1], best->transform[0]);
-}
-
-/**
- * Determine the center of rotation point.
- *
- * For any given point q that is transformed by a 2D affine transformation
- * matrix T about anchor point P the new point q' may be determined by the
- * following equation:
- *
- * q' = T * (q - P) + P
- *
- * T and P are dependent, so we can modify one and find a new value for the
- * other. We will label the original T and P as T0 and P0, and the new values
- * will be labeled T1 and P1. We can find new values by solving the following
- * equation:
- *
- * q' = T0 * (q - P0) + P0 = T1 * (q - P1) + P1
- *
- * In the calculations below, we use variables for the scalar values
- * that make up T0, P0, T1, and P1:
- *
- * T0: [ a -b c ]  P0: [ x0 ]  T1: [ a -b 0 ]  P1: [ x1 ]
- *     [ b  a d ]      [ y0 ]      [ b  a 0 ]      [ y1 ]
- *     [ 0  0 1 ]      [  0 ]      [ 0  0 1 ]      [  0 ]
- *
- * Note that rotation and scaling are independent of the anchor point, so a and
- * b are equivalent between the transformation matrices.
- *
- * Since we know all the values of T0, P0, and T1, we can calculate the values
- * x1 and y1 in P1.
- */
-static inline int set_center_of_rotation(struct grail_element *e)
-{
-	float a = e->transform[0];
-	float b = e->transform[3];
-	float c = e->transform[2];
-	float d = e->transform[5];
-	float x0 = e->center.x;
-	float y0 = e->center.y;
-	float x1;
-	float y1;
-
-	float div = a*a - 2*a + b*b + 1;
-
-	if (fabsf(div) < 1e-5)
-		return 0;
-
-	x1 = (a*a*x0 - a*(2*x0+c) + b*b*x0 - b*d + c + x0) / div;
-	y1 = (a*a*y0 - a*(2*y0+d) + b*b*y0 + b*c + d + y0) / div;
-
-	e->rotation_center.x = x1;
-	e->rotation_center.y = y1;
-
-	return 1;
-}
-
-static void set_slots(struct grail_impl *impl,
-		      struct grail_frame *frame,
-		      const struct utouch_frame *touch)
-{
-	struct grail_element **slots = frame->slots;
-	struct utouch_contact *const *tc = touch->slots;
-	int i, j, n = 0;
-
-	for (i = 0; i < impl->num_touches; i++)
-		set_slot_one(impl, slots[n++], touch, tc[i]);
-
-	for (i = 0; i < impl->num_touches; i++)
-		for (j = i + 1; j < impl->num_touches; j++)
-			set_slot_two(impl, slots[n++], touch, tc[i], tc[j]);
-
-	set_slot_multi(impl, slots[n++], frame, touch);
-}
-
-static void collect_transforms(struct grail_impl *impl,
-			       struct grail_frame *frame,
-			       const struct utouch_frame *touch)
-{
-	const struct utouch_surface *s = utouch_frame_get_surface(impl->fh);
-	const struct grail_control *ctl = impl->ctl;
-	float d_x = ctl->bar_drag_x * (s->mapped_max_x - s->mapped_min_x);
-	float d_y = ctl->bar_drag_y * (s->mapped_max_y - s->mapped_min_y);
-	float ds2 = ctl->bar_scale * ctl->bar_scale;
-	float dt;
-	int i;
-
-	for (i = 0; i < impl->num_slots; i++) {
-		struct grail_element *s = frame->slots[i];
-
-		if (!s->num_touches)
-			continue;
-
-		set_center_of_rotation(s);
-
-		dt = touch->time - s->start_time;
-		if (dt > ctl->glue_ms) {
-			unsigned int mask = s->active_mask;
-
-			if (fabs(s->drag.x) > d_x)
-				mask |= GRAIL_EXPECT_DRAG_X;
-			if (fabs(s->drag.y) > d_y)
-				mask |= GRAIL_EXPECT_DRAG_Y;
-			if (fabs(s->scale2 - 1) > ds2)
-				mask |= GRAIL_EXPECT_SCALE;
-			if (fabs(s->angle) > ctl->bar_angle)
-				mask |= GRAIL_EXPECT_ANGLE;
-
-			s->active_mask = mask;
-
-			if (dt < ctl->drop_x_ms)
-				mask |= GRAIL_EXPECT_DRAG_X;
-			if (dt < ctl->drop_y_ms)
-				mask |= GRAIL_EXPECT_DRAG_Y;
-			if (dt < ctl->drop_scale_ms)
-				mask |= GRAIL_EXPECT_SCALE;
-			if (dt < ctl->drop_angle_ms)
-				mask |= GRAIL_EXPECT_ANGLE;
-
-			s->expect_mask &= mask;
-		}
-
-		frame->ongoing[frame->num_ongoing++] = s;
-	}
-}
-
-const struct grail_frame GRAIL_PUBLIC *
-grail_pump_frame(grail_handle ge, const struct utouch_frame *touch)
-{
-	struct grail_impl *impl = ge->impl;
-	struct grail_frame *frame = impl->frames[impl->nextframe];
-	const struct grail_frame *prev = frame->prev;
-	int i;
-
-	if (touch->slot_revision == touch->prev->slot_revision &&
-	    !prev->num_ongoing)
-		return 0;
-
-	frame->touch = touch;
-	frame->num_ongoing = 0;
-	for (i = 0; i < impl->num_slots; i++)
-		frame->slots[i]->prev = prev->slots[i];
-
-	set_slots(impl, frame, touch);
-	collect_transforms(impl, frame, touch);
-
-	impl->nextframe = (impl->nextframe + 1) % impl->num_frames;
-
-	return frame;
-}

=== removed file 'src/v2/grail-gestures.c'
--- src/v2/grail-gestures.c	2012-03-26 12:57:55 +0000
+++ src/v2/grail-gestures.c	1970-01-01 00:00:00 +0000
@@ -1,222 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include "grail-impl.h"
-#include <math.h>
-
-/* Units of mm or radians */
-static const float FM_SN[DIM_FM] = { 0.13, 0.13, 0.26, 2 * M_PI / 1000 };
-static const float FM_BAR[DIM_FM] = { 2.6, 2.6, 5.2, 2 * M_PI / 50 };
-
-/* Units of ms */
-static const grail_time_t FM_HOLD_MS[DIM_FM] = { 60, 60, 60, 60 };
-static const grail_time_t FM_BAR_MS[DIM_FM] = { 300, 300, 500, 500 };
-static const grail_time_t SAMPLE_MS = 10;
-
-static const float EPS = 1e-3;
-
-static void compute_position(float *x, float *y,
-			     const struct utouch_frame *frame)
-{
-	int i, n = frame->num_active;
-	*x = 0;
-	*y = 0;
-	if (n < 1)
-		return;
-	for (i = 0; i < n; i++) {
-		const struct utouch_contact *t = frame->active[i];
-		*x += t->x;
-		*y += t->y;
-	}
-	*x /= n;
-	*y /= n;
-}
-
-static float compute_radius(float x, float y,
-			    const struct utouch_frame *frame)
-{
-	int i, n = frame->num_active;
-	float r = 0, r2 = 0;
-	if (n < 2)
-		return r;
-	for (i = 0; i < n; i++) {
-		const struct utouch_contact *t = frame->active[i];
-		float dx = t->x - x;
-		float dy = t->y - y;
-		r2 += dx * dx + dy * dy;
-	}
-	r2 /= n;
-	r = sqrt(r2);
-	return r;
-}
-
-static float compute_rotation(float x, float y, float r,
-			      const struct utouch_frame *frame)
-{
-	int i, n = frame->num_active;
-	float da = 0, darc2 = 0;
-	if (n < 2)
-		return da;
-	for (i = 0; i < n; i++) {
-		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;
-		float my = t->y - ot->y;
-		darc2 += dx * my - dy * mx;
-	}
-	darc2 /= n;
-	da = darc2 / (r * r);
-	return da;
-}
-
-static void move_reset(struct move_model *m, int i, float x, grail_time_t t)
-{
-	struct filter_model *fm = &m->fm[i];
-	fm->raw_delta = 0;
-	fm->action_delta = 0;
-	fm->velocity = 0;
-	fm->value = x;
-	fm->original = x;
-	fm->original_ms = t;
-	fm->sample = x;
-	fm->sample_ms = t;
-	m->tickle &= ~(1 << i);
-	m->active &= ~(1 << i);
-	m->timeout &= ~(1 << i);
-}
-
-static void move_update(struct move_model *m, int i, float x, grail_time_t t)
-{
-	struct filter_model *fm = &m->fm[i];
-	float dt = t - fm->sample_ms;
-
-	if (fabs(x - fm->value) < fm->fuzz)
-		return;
-
-	fm->raw_delta = x - fm->value;
-	fm->action_delta = fm->raw_delta;
-	fm->value = x;
-	if (dt > SAMPLE_MS) {
-		fm->velocity = (x - fm->sample) / dt;
-		fm->sample = x;
-		fm->sample_ms = t;
-	}
-	if (fabs(fm->raw_delta) > EPS)
-		m->tickle |= (1 << i);
-	else
-		m->tickle &= ~(1 << i);
-	if (m->active & (1 << i))
-		return;
-	fm->action_delta = 0;
-	if (fabs(x - fm->original) > fm->bar) {
-		if (t - fm->original_ms > fm->hold_ms) {
-			m->active |= (1 << i);
-			fm->action_delta = x - fm->original;
-		}
-	} else if (t - fm->original_ms > fm->bar_ms) {
-		m->timeout |= (1 << i);
-	}
-}
-
-void gru_init_motion(struct grail *ge)
-{
-	struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
-	struct gesture_recognizer *gru = ge->gru;
-	struct move_model *m = &gru->move;
-	float U[DIM_FM]; /* Device unit dimensions */
-	float P[DIM_FM]; /* Device physical dimensions */
-	int i;
-	U[FM_X] = s->mapped_max_x - s->mapped_min_x;
-	U[FM_Y] = s->mapped_max_y - s->mapped_min_y;
-	U[FM_R] = sqrt(U[FM_X] * U[FM_X] + U[FM_Y] * U[FM_Y]);
-	U[FM_A] = 2 * M_PI;
-	P[FM_X] = s->phys_width;
-	P[FM_Y] = s->phys_height;
-	P[FM_R] = sqrt(P[FM_X] * P[FM_X] + P[FM_Y] * P[FM_Y]);
-	P[FM_A] = 2 * M_PI;
-	for (i = 0; i < DIM_FM; i++) {
-		m->fm[i].fuzz = U[i] * FM_SN[i] / P[i];
-		m->fm[i].bar = U[i] * FM_BAR[i] / P[i];
-		m->fm[i].hold_ms = FM_HOLD_MS[i];
-		m->fm[i].bar_ms = FM_BAR_MS[i];
-	}
-}
-
-void gru_motion(struct grail *ge,
-		const struct utouch_frame *frame)
-{
-	const struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
-	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->prev->revision != frame->revision) {
-		r = compute_radius(x, y, frame);
-		a = 0;
-		move_reset(m, FM_X, x, t);
-		move_reset(m, FM_Y, y, t);
-		move_reset(m, FM_R, r, t);
-		move_reset(m, FM_A, a, t);
-		m->single = 0;
-		m->multi = 0;
-	} else if (frame->num_active < 2) {
-		r = 0;
-		a = 0;
-		move_update(m, FM_X, x, t);
-		move_update(m, FM_Y, y, t);
-		move_reset(m, FM_R, r, t);
-		move_reset(m, FM_A, a, t);
-		m->single = 1;
-		m->multi = 0;
-	} else {
-		r = compute_radius(x, y, frame);
-		a = m->fm[FM_A].value;
-		if (!s->is_semi_mt)
-			a += compute_rotation(x, y, r, frame);
-		move_update(m, FM_X, x, t);
-		move_update(m, FM_Y, y, t);
-		move_update(m, FM_R, r, t);
-		move_update(m, FM_A, a, t);
-		m->single = 0;
-		m->multi = 1;
-	}
-	m->ntouch = frame->num_active;
-	m->time = t;
-}
-
-void gru_event(struct grail *ge, int gid,
-	       const struct move_model *m,
-	       const grail_prop_t *prop, int nprop)
-{
-	gin_gid_event(ge, gid, m->fm[FM_X].value, m->fm[FM_Y].value, m->ntouch,
-		      prop, nprop, 0);
-}
-
-void gru_end(struct grail *ge, int gid, const struct move_model *m,
-	     const grail_prop_t *prop, int nprop)
-{
-	gin_gid_end(ge, gid, m->fm[FM_X].value, m->fm[FM_Y].value, m->ntouch,
-		    prop, nprop);
-}

=== removed file 'src/v2/grail-gestures.h'
--- src/v2/grail-gestures.h	2012-03-26 12:57:55 +0000
+++ src/v2/grail-gestures.h	1970-01-01 00:00:00 +0000
@@ -1,114 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_GESTURES_H
-#define GRAIL_GESTURES_H
-
-#include "grail-inserter.h"
-
-#define PRIO_POINTER	1
-#define PRIO_GESTURE	2
-#define PRIO_ENV	3
-#define PRIO_META	4
-#define PRIO_TAP	5
-
-#define DIM_FM		4
-
-#define FM_X		0
-#define FM_Y		1
-#define FM_R		2
-#define FM_A		3
-
-struct filter_model {
-	float raw_delta;
-	float action_delta;
-	float velocity;
-	float value;
-	float original;
-	float sample;
-	float fuzz;
-	float bar;
-	grail_time_t original_ms;
-	grail_time_t sample_ms;
-	grail_time_t hold_ms;
-	grail_time_t bar_ms;
-};
-
-struct move_model {
-	struct filter_model fm[DIM_FM];
-	int tickle, active, timeout;
-	int single, multi, ntouch;
-	grail_time_t time;
-};
-
-void gru_init_motion(struct grail *ge);
-void gru_motion(struct grail *ge,
-		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);
-void gru_end(struct grail *ge, int gid,
-	     const struct move_model *move,
-	     const grail_prop_t *prop, int nprop);
-
-struct combo_model {
-	int active, gid;
-	int mintouch, maxtouch;
-	int nprop;
-	grail_prop_t prop[DIM_GRAIL_PROP];
-};
-
-int gru_touch(struct grail *ge,
-	      const struct utouch_frame *frame);
-int gru_drag(struct grail *ge,
-	     const struct utouch_frame *frame);
-int gru_pinch(struct grail *ge,
-	      const struct utouch_frame *frame);
-int gru_rotate(struct grail *ge,
-	       const struct utouch_frame *frame);
-
-static inline int out_of_bounds(const struct combo_model *s,
-				const struct move_model *m)
-{
-	return m->ntouch < s->mintouch || m->ntouch > s->maxtouch;
-}
-
-int gru_wintouch(struct grail *ge,
-		 const struct utouch_frame *frame);
-int gru_windrag(struct grail *ge,
-		const struct utouch_frame *frame);
-int gru_winpinch(struct grail *ge,
-		 const struct utouch_frame *frame);
-int gru_winrotate(struct grail *ge,
-		  const struct utouch_frame *frame);
-
-struct tapping_model {
-	grail_time_t start;
-	int mintouch, maxtouch;
-	int active, gid, tap;
-	int nprop;
-	grail_prop_t prop[DIM_GRAIL_PROP];
-};
-
-int gru_tapping(struct grail *ge,
-		const struct utouch_frame *frame);
-
-#endif
-

=== removed file 'src/v2/grail-impl.h'
--- src/v2/grail-impl.h	2012-03-26 12:57:55 +0000
+++ src/v2/grail-impl.h	1970-01-01 00:00:00 +0000
@@ -1,87 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_IMPL_H
-#define GRAIL_IMPL_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)
-#define GRAIL_ID_MAX		0xffff
-
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-
-typedef void *grail_select_callback;
-
-/*
- * In this implementation, there can be N one-gestures, N (N - 1) / 2
- * two-gestures, and one global gesture.
- */
-static inline int get_slot_count(int n)
-{
-	return n + n * (n - 1) / 2 + 1;
-}
-
-int create_grail2(struct grail_impl *x,
-		  utouch_frame_handle fh,
-		  unsigned int num_frames,
-		  void *select,
-		  unsigned int version,
-		  unsigned int control_size,
-		  unsigned int frame_size,
-		  unsigned int slot_size);
-
-void destroy_grail2(struct grail_impl *x);
-
-struct grail_impl {
-	struct evemu_device *evemu;
-	struct mtdev *mtdev;
-	utouch_frame_handle fh;
-	const struct utouch_frame *touch;
-	struct evbuf evbuf;
-	struct grailbuf gbuf;
-	int filter_abs;
-	int ongoing;
-	int gesture;
-	FILE *fptest;
-	int fast_fileread;
-	/* new stuff below */
-	struct grail_control *ctl;
-	grail_select_callback select;
-	int num_frames;
-	int num_slots;
-	int num_touches;
-	int nextframe;
-	int seqid;
-	unsigned int control_size;
-	unsigned int frame_size;
-	unsigned int slot_size;
-	struct grail_frame **frames;
-};
-
-#endif

=== removed file 'src/v2/grail-init.c'
--- src/v2/grail-init.c	2012-03-26 12:57:55 +0000
+++ src/v2/grail-init.c	1970-01-01 00:00:00 +0000
@@ -1,235 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-impl.h"
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-
-static struct grail_control *create_control(int size)
-{
-	struct grail_control *c = calloc(1, size);
-
-	if (!c)
-		return 0;
-
-	c->glue_ms = 60;
-	c->bar_drag_x = 0.03;
-	c->bar_drag_y = 0.03;
-	c->bar_scale = 0.3;
-	c->bar_angle = 0.1;
-	c->drop_x_ms = 300;
-	c->drop_y_ms = 300;
-	c->drop_scale_ms = 300;
-	c->drop_angle_ms = 300;
-
-	return c;
-}
-
-static void destroy_slots(struct grail_element **slots, int nslot)
-{
-	int i;
-
-	if (slots) {
-		for (i = nslot - 1; i >= 0; i--)
-			free(slots[i]);
-		free(slots);
-	}
-}
-
-static void destroy_frame(struct grail_frame *frame, int nslot)
-{
-	if (frame) {
-		destroy_slots(frame->slots, nslot);
-		free(frame->ongoing);
-		free(frame);
-	}
-}
-
-static void destroy_frames(struct grail_frame **frames, int nframe, int nslot)
-{
-	int i;
-
-	if (frames) {
-		for (i = nframe - 1; i >= 0; i--)
-			destroy_frame(frames[i], nslot);
-		free(frames);
-	}
-}
-
-static struct grail_element **create_slots(int nslot, int ntouch, int size)
-{
-	struct grail_element **slots;
-	struct grail_element *s;
-	int i;
-
-	slots = calloc(nslot, sizeof(slots[0]));
-	if (!slots)
-		return 0;
-
-	for (i = 0; i < nslot; i++) {
-		s = calloc(1, size + ntouch * sizeof(void *));
-		if (!s)
-			goto out;
-		s->slot = i;
-		s->id = -1;
-		s->touches = (void *)((char *)s + size);
-		slots[i] = s;
-	}
-
-	return slots;
- out:
-	destroy_slots(slots, nslot);
-	return 0;
-}
-
-static struct grail_frame *create_frame(int nslot, int ntouch,
-					int frame_size, int slot_size)
-{
-	struct grail_frame *frame;
-
-	frame = calloc(1, frame_size);
-	if (!frame)
-		return 0;
-
-	frame->ongoing = calloc(nslot, sizeof(frame->ongoing[0]));
-	frame->slots = create_slots(nslot, ntouch, slot_size);
-	if (!frame->ongoing || !frame->slots)
-		goto out;
-
-	return frame;
- out:
-	destroy_frame(frame, nslot);
-	return 0;
-}
-
-static struct grail_frame **create_frames(int nframe, int nslot, int ntouch,
-					  int frame_size, int slot_size)
-{
-	struct grail_frame **frames;
-	struct grail_frame *f;
-	int i;
-
-	frames = calloc(nframe, sizeof(frames[0]));
-	if (!frames)
-		return 0;
-
-	for (i = 0; i < nframe; i++) {
-		f = create_frame(nslot, ntouch, frame_size, slot_size);
-		if (!f)
-			goto out;
-		frames[i] = f;
-	}
-
-	return frames;
- out:
-	destroy_frames(frames, nframe, nslot);
-	return 0;
-}
-
-int create_grail2(struct grail_impl *x,
-		  utouch_frame_handle fh,
-		  unsigned int num_frames,
-		  grail_select_callback select,
-		  unsigned int version,
-		  unsigned int control_size,
-		  unsigned int frame_size,
-		  unsigned int slot_size)
-{
-	unsigned int ntouch = utouch_frame_get_num_slots(fh);
-	unsigned int nslot = get_slot_count(ntouch);
-	int i;
-
-	x->select = select;
-	x->control_size = MAX(control_size, sizeof(struct grail_control));
-	x->frame_size = MAX(frame_size, sizeof(struct grail_frame));
-	x->slot_size = MAX(slot_size, sizeof(struct grail_element));
-
-	x->num_frames = num_frames;
-	x->num_slots = nslot;
-	x->num_touches = ntouch;
-
-	x->ctl = create_control(x->control_size);
-	if (!x->ctl)
-		goto freemem;
-
-	x->frames = create_frames(num_frames, nslot, ntouch,
-				  x->frame_size, x->slot_size);
-	if (!x->frames)
-		goto freemem;
-
-	for (i = 0; i < num_frames; i++)
-		x->frames[(i + 1) % num_frames]->prev = x->frames[i];
-
-	return 0;
-
- freemem:
-	destroy_grail2(x);
-	return -ENOMEM;
-}
-
-void destroy_grail2(struct grail_impl *x)
-{
-	destroy_frames(x->frames, x->num_frames, x->num_slots);
-	free(x->ctl);
-}
-
-grail_handle GRAIL_PUBLIC grail_new_raw(utouch_frame_handle fh,
-					unsigned int num_frames,
-					grail_select_callback select,
-					unsigned int version,
-					unsigned int control_size,
-					unsigned int frame_size,
-					unsigned int slot_size)
-{
-	struct grail *ge;
-	struct grail_impl *x;
-
-	ge = calloc(1, sizeof(*ge));
-	if (!ge)
-		return 0;
-	x = calloc(1, sizeof(*x));
-	if (!x)
-		goto out;
-	x->fh = fh;
-	if (create_grail2(x, fh, num_frames, select,
-			  version, control_size, frame_size, slot_size))
-		goto out;
-
-	ge->impl = x;
-	return ge;
-
- out:
-	free(x);
-	free(ge);
-	return 0;
-}
-
-void GRAIL_PUBLIC grail_delete(grail_handle ge)
-{
-	destroy_grail2(ge->impl);
-	free(ge->impl);
-	free(ge);
-}
-
-struct grail_control GRAIL_PUBLIC *grail_get_control(grail_handle ge)
-{
-	return ge->impl->ctl;
-}

=== removed file 'src/v2/grail-inserter.c'
--- src/v2/grail-inserter.c	2012-03-26 12:57:55 +0000
+++ src/v2/grail-inserter.c	1970-01-01 00:00:00 +0000
@@ -1,303 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-gestures.h"
-#include "grail-inserter.h"
-#include "grail-impl.h"
-#include <malloc.h>
-#include <string.h>
-#include <errno.h>
-#include <math.h>
-
-static const int MAX_GESTURE_ID = 0xfff;
-
-static int find_gslot(const struct gesture_inserter *gin, int gid)
-{
-	int i;
-	grail_mask_foreach(i, gin->used, sizeof(gin->used))
-		if (gin->state[i].id == gid)
-			return i;
-	return -1;
-}
-
-static int mask_overlap(const grail_mask_t *a, const grail_mask_t *b,
-			int bytes)
-{
-	int i;
-
-	for (i = 0; i < bytes; i++)
-		if (a[i] & b[i])
-			return 1;
-
-	return 0;
-}
-
-// todo: spanning tree for multi-user case
-static void setup_new_gestures(struct grail *ge,
-			       const struct utouch_frame *frame)
-{
-	struct gesture_inserter *gin = ge->gin;
-	grail_mask_t types[DIM_GRAIL_TYPE_BYTES];
-	grail_mask_t span[DIM_TOUCH_BYTES];
-	struct grail_client_info info[DIM_CLIENT];
-	int i, j, nclient = 0;
-	int nfresh = grail_mask_count(gin->fresh, sizeof(gin->fresh));
-	if (!nfresh)
-		return;
-
-	memset(types, 0, sizeof(types));
-	memset(span, 0, sizeof(span));
-
-	grail_mask_foreach(i, gin->fresh, sizeof(gin->fresh)) {
-		struct slot_state *s = &gin->state[i];
-		grail_mask_set(types, s->type);
-		grail_mask_set_mask(span, s->span, sizeof(span));
-	}
-
-	nclient = gin_get_clients(ge, info, DIM_CLIENT, types, sizeof(types),
-				  span, sizeof(span), frame);
-
-	grail_mask_foreach(i, gin->fresh, sizeof(gin->fresh)) {
-		struct slot_state *s = &gin->state[i];
-		s->nclient = 0;
-		for (j = 0; j < nclient; j++) {
-			if (!grail_mask_get(info[j].mask, s->type))
-				continue;
-			if (gin->grab_active &&
-			    info[j].id.client != gin->grab_client)
-				continue;
-			if (grail_mask_get(info[j].mask, GRAIL_TYPE_SYSFLAG1)) {
-				gin->grab_active = 1;
-				gin->grab_client = info[j].id.client;
-			}
-			s->client_id[s->nclient++] = info[j].id;
-		}
-	}
-
-	memset(gin->fresh, 0, sizeof(gin->fresh));
-}
-
-int gin_init(struct grail *ge)
-{
-	struct gesture_inserter *gin;
-	int i;
-	gin = calloc(1, sizeof(*gin));
-	if (!gin)
-		return -ENOMEM;
-	for (i = 0; i < DIM_INSTANCE; i++)
-		grail_mask_set(gin->unused, i);
-	ge->gin = gin;
-	return 0;
-}
-
-void gin_destroy(struct grail *ge)
-{
-	free(ge->gin);
-	ge->gin = NULL;
-}
-
-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;
-	if (frame->num_active && !frame->prev->num_active)
-		gin->grab_active = 0;
-}
-
-void gin_frame_end(struct grail *ge, const struct utouch_frame *frame)
-{
-	struct gesture_inserter *gin = ge->gin;
-	grail_mask_t keep[DIM_TOUCH_BYTES];
-	int i, hold[2] = { 0, 0 }, discard[2] = { 0, 0 };
-
-	memset(keep, 0, sizeof(keep));
-	setup_new_gestures(ge, frame);
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		if (!s->nclient)
-			continue;
-		if (s->priority > hold[s->slice])
-			hold[s->slice] = s->priority;
-		if (s->status != GRAIL_STATUS_UPDATE)
-			continue;
-		if (s->priority > discard[s->slice])
-			discard[s->slice] = s->priority;
-	}
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		if (!s->nclient || (s->priority < discard[s->slice] && !s->sent))
-			gin_gid_discard(ge, s->id);
-	}
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		if (s->slice == 1)
-			grail_mask_set_mask(keep, s->span, sizeof(keep));
-	}
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		if (!s->timeout)
-			continue;
-		if (mask_overlap(keep, s->span, sizeof(keep)))
-			continue;
-		gin_gid_discard(ge, s->id);
-	}
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		struct gesture_event ev;
-		grail_mask_set(gin->types, s->type);
-		if (s->priority < hold[s->slice] && !s->sent)
-			continue;
-		while (!gebuf_empty(&s->buf)) {
-			gebuf_get(&s->buf, &ev);
-			gin_send_event(ge, s, &ev, frame);
-		}
-		s->sent = 1;
-	}
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		if (s->status == GRAIL_STATUS_END)
-			gin_gid_discard(ge, s->id);
-	}
-}
-
-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;
-	s = &gin->state[i];
-	s->type = type;
-	if (priority < 0) {
-		s->priority = -priority;
-		s->slice = 1;
-	} else {
-		s->priority = priority;
-		s->slice = 0;
-	}
-	s->timeout = 0;
-	s->sent = 0;
-	s->id = gin->gestureid++ & MAX_GESTURE_ID;
-	s->status = GRAIL_STATUS_BEGIN;
-	s->nclient = 0;
-	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);
-	grail_mask_set(gin->used, i);
-	return s->id;
-}
-
-void gin_gid_discard(struct grail *ge, int gid)
-{
-	struct gesture_inserter *gin = ge->gin;
-	struct slot_state *s;
-	int i = find_gslot(gin, gid);
-	if (i < 0)
-		return;
-	s = &gin->state[i];
-	gebuf_clear(&s->buf);
-	s->status = GRAIL_STATUS_END;
-	grail_mask_clear(gin->used, i);
-	grail_mask_set(gin->unused, i);
-}
-
-void gin_gid_timeout(struct grail *ge, int gid)
-{
-	int i = find_gslot(ge->gin, gid);
-	if (i >= 0)
-		ge->gin->state[i].timeout = 1;
-}
-
-void gin_gid_event(struct grail *ge, int gid,
-		   float x, float y, int ntouch,
-		   const grail_prop_t *prop, int nprop,
-		   int transient)
-{
-	struct gesture_inserter *gin = ge->gin;
-	struct gesture_event ev;
-	struct slot_state *s;
-	int i = find_gslot(gin, gid);
-	if (i < 0)
-		return;
-	s = &gin->state[i];
-	ev.status = transient ? GRAIL_STATUS_UPDATE : s->status;
-	ev.ntouch = ntouch;
-	ev.nprop = nprop;
-	ev.time = gin->time;
-	ev.pos.x = x;
-	ev.pos.y = y;
-	memcpy(ev.prop, prop, nprop * sizeof(grail_prop_t));
-	gebuf_put(&s->buf, &ev);
-	if (transient)
-		s->status = GRAIL_STATUS_END;
-	else if (s->status == GRAIL_STATUS_BEGIN)
-		s->status = GRAIL_STATUS_UPDATE;
-}
-
-void gin_gid_end(struct grail *ge, int gid,
-		 float x, float y, int ntouch,
-		 const grail_prop_t *prop, int nprop)
-{
-	struct gesture_inserter *gin = ge->gin;
-	struct gesture_event ev;
-	struct slot_state *s;
-	int i = find_gslot(gin, gid);
-	if (i < 0)
-		return;
-	s = &gin->state[i];
-	if (s->status != GRAIL_STATUS_BEGIN) {
-		ev.status = GRAIL_STATUS_END;
-		ev.ntouch = ntouch;
-		ev.nprop = nprop;
-		ev.time = gin->time;
-		ev.pos.x = x;
-		ev.pos.y = y;
-		memcpy(ev.prop, prop, nprop * sizeof(grail_prop_t));
-		gebuf_put(&s->buf, &ev);
-	}
-	s->status = GRAIL_STATUS_END;
-}
-
-void GRAIL_PUBLIC grail_set_bbox(struct grail *ge,
-				 const struct grail_coord *tmin,
-				 const struct grail_coord *tmax)
-{
-	struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
-
-	s->mapped_min_x = tmin->x;
-	s->mapped_min_y = tmin->y;
-	s->mapped_max_x = tmax->x;
-	s->mapped_max_y = tmax->y;
-
-	if (ge->gru)
-		gru_init_motion(ge);
-}

=== removed file 'src/v2/grail-inserter.h'
--- src/v2/grail-inserter.h	2012-03-26 12:57:55 +0000
+++ src/v2/grail-inserter.h	1970-01-01 00:00:00 +0000
@@ -1,92 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_INSERTER_H
-#define GRAIL_INSERTER_H
-
-#include "grail-impl.h"
-#include "gebuf.h"
-
-#define DIM_EV_TYPE		EV_CNT
-#define DIM_EV_TYPE_BYTES	((DIM_EV_TYPE + 7) >> 3)
-
-#define DIM_INSTANCE		32
-#define DIM_INSTANCE_BYTES	((DIM_INSTANCE + 7) >> 3)
-
-#define DIM_CLIENT		32
-
-struct slot_state {
-	int type;
-	int priority;
-	int slice;
-	int timeout;
-	int sent;
-	int id;
-	int status;
-	int nclient;
-	struct grail_client_id client_id[DIM_CLIENT];
-	grail_mask_t span[DIM_TOUCH_BYTES];
-	struct gebuf buf;
-};
-
-struct gesture_inserter {
-	struct slot_state state[DIM_INSTANCE];
-	grail_mask_t types[DIM_GRAIL_TYPE_BYTES];
-	grail_mask_t unused[DIM_INSTANCE_BYTES];
-	grail_mask_t fresh[DIM_INSTANCE_BYTES];
-	grail_mask_t used[DIM_INSTANCE_BYTES];
-	grail_time_t time;
-	int gestureid;
-	int grab_active;
-	int grab_client;
-};
-
-int gin_add_contact_props(const struct gesture_inserter *gin,
-			  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 utouch_frame *frame);
-void gin_send_event(struct grail *ge, struct slot_state *s,
-		    const struct gesture_event *ev,
-		    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 utouch_frame *frame);
-void gin_frame_end(struct grail *ge, const struct utouch_frame *frame);
-
-int gin_gid_begin(struct grail *ge, int type, int priority,
-		  const struct utouch_frame *frame);
-void gin_gid_discard(struct grail *ge, int gid);
-void gin_gid_timeout(struct grail *ge, int gid);
-
-void gin_gid_event(struct grail *ge, int gid,
-		   float x, float y, int ntouch,
-		   const grail_prop_t *prop, int nprop,
-		   int transient);
-void gin_gid_end(struct grail *ge, int gid,
-		 float x, float y, int ntouch,
-		 const grail_prop_t *prop, int nprop);
-
-#endif

=== removed file 'src/v2/grail-legacy.c'
--- src/v2/grail-legacy.c	2012-03-26 12:57:55 +0000
+++ src/v2/grail-legacy.c	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include <grail.h>
-#include "grail-inserter.h"
-#include <string.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <malloc.h>
-#include <errno.h>
-#include <stdlib.h>
-
-#ifndef GRAIL_NO_LEGACY_ABI
-
-void GRAIL_PUBLIC grail_filter_abs_events(struct grail *ge, int usage)
-{
-	struct grail_impl *x = ge->impl;
-	x->filter_abs = usage;
-}
-
-int GRAIL_PUBLIC grail_get_contacts(const struct grail *ge,
-				    struct grail_contact *touch, int max_touch)
-{
-	const struct utouch_frame *frame = ge->impl->touch;
-	int i;
-	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 utouch_contact *ct = frame->active[i];
-		t->id = ct->id;
-		t->tool_type = ct->tool_type;
-		t->pos.x = ct->x;
-		t->pos.y = ct->y;
-		t->touch_major = ct->touch_major;
-		t->touch_minor = ct->touch_minor;
-		t->width_major = ct->width_major;
-		t->width_minor = ct->width_minor;
-		t->angle = ct->orientation;
-		t->pressure = ct->pressure;
-	}
-	return max_touch;
-}
-
-#endif

=== removed file 'src/v2/grail-recognizer.c'
--- src/v2/grail-recognizer.c	2012-03-26 12:57:55 +0000
+++ src/v2/grail-recognizer.c	1970-01-01 00:00:00 +0000
@@ -1,57 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <string.h>
-#include <malloc.h>
-#include <errno.h>
-
-int gru_init(struct grail *ge)
-{
-	struct gesture_recognizer *gru;
-	gru = calloc(1, sizeof(struct gesture_recognizer));
-	if (!gru)
-		return -ENOMEM;
-	ge->gru = gru;
-	gru_init_motion(ge);
-	return 0;
-}
-
-void gru_destroy(struct grail *ge)
-{
-	free(ge->gru);
-	ge->gru = NULL;
-}
-
-void gru_recognize(struct grail *ge, const struct utouch_frame *frame)
-{
-	if (!ge->gin || !ge->gru)
-		return;
-	gru_motion(ge, frame);
-	gru_touch(ge, frame);
-	gru_drag(ge, frame);
-	gru_pinch(ge, frame);
-	gru_rotate(ge, frame);
-	gru_wintouch(ge, frame);
-	gru_windrag(ge, frame);
-	gru_winpinch(ge, frame);
-	gru_winrotate(ge, frame);
-	gru_tapping(ge, frame);
-}

=== removed file 'src/v2/grail-recognizer.h'
--- src/v2/grail-recognizer.h	2012-03-26 12:57:55 +0000
+++ src/v2/grail-recognizer.h	1970-01-01 00:00:00 +0000
@@ -1,43 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_RECOGNIZER_H
-#define GRAIL_RECOGNIZER_H
-
-#include "grail-gestures.h"
-
-struct gesture_recognizer {
-	struct move_model move;
-	struct combo_model touch;
-	struct combo_model drag;
-	struct combo_model pinch;
-	struct combo_model rotate;
-	struct combo_model wintouch;
-	struct combo_model windrag;
-	struct combo_model winpinch;
-	struct combo_model winrotate;
-	struct tapping_model tapping;
-};
-
-int gru_init(struct grail *ge);
-void gru_recognize(struct grail *ge, const struct utouch_frame *frame);
-void gru_destroy(struct grail *ge);
-
-#endif

=== removed file 'src/v2/grailbuf.h'
--- src/v2/grailbuf.h	2012-03-26 12:57:55 +0000
+++ src/v2/grailbuf.h	1970-01-01 00:00:00 +0000
@@ -1,58 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2012 Canonical Ltd.
- *
- * This library is free software: you can redistribute it and/or modify it 
- * under the terms of the GNU Lesser General Public License version 3
- * as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful, but 
- * WITHOUT ANY WARRANTY; without even the implied warranties of 
- * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
- * PURPOSE.  See the GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library.  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 directory 'src/v3'
=== modified file 'test/Makefile.am'
--- test/Makefile.am	2012-04-03 01:40:58 +0000
+++ test/Makefile.am	2012-05-09 17:32:19 +0000
@@ -23,11 +23,6 @@
 	$(MTDEV_LIBS)
 
 check_grail_SOURCES = \
-	check-mapping.cpp \
-	check-transform.cpp
-
-if HAVE_XI22
-check_grail_SOURCES += \
 	grail.cpp \
 	subscription.cpp \
 	device.cpp \
@@ -48,7 +43,6 @@
 	x11/tap-touch-accept.cpp \
 	x11/parallel-atomic-gestures.cpp \
 	x11/hold-reject.cpp
-endif
 
 AM_CPPFLAGS = \
 	-I$(top_srcdir) \
@@ -82,10 +76,7 @@
 	$(COVERAGE_LIBS) \
 	$(XORG_GTEST_LIBS) \
 	$(XORG_GTEST_MAIN_LIBS)
-
-if HAVE_XI22
-check_grail_LDADD += \
-	$(XINPUT_LIBS) $(X11_LIBS)
-endif
+	$(XINPUT_LIBS) \
+	$(X11_LIBS)
 
 EXTRA_DIST = io recordings

=== removed file 'test/check-mapping.cpp'
--- test/check-mapping.cpp	2012-03-23 09:44:52 +0000
+++ test/check-mapping.cpp	1970-01-01 00:00:00 +0000
@@ -1,100 +0,0 @@
-#include <fcntl.h>
-#include <unistd.h>
-
-#include <cmath>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <ctime>
-#include <stdexcept>
-
-#include <gtest/gtest.h>
-
-#include "grail.h"
-
-/**
- * @brief Fixture for check-mapping test suite.
- */
-class CheckMapping : public testing::Test {
- protected:
-
-  grail ge_;
-  int fd_;
-  grail_coord pos_;
-
-  CheckMapping()
-      : fd_(-1) {
-    std::memset(&ge_, 0, sizeof(ge_));
-    std::memset(&pos_, 0, sizeof(pos_));
-  }
-
-  /**
-   * @brief Setup procedure is called before every test.
-   */
-  void SetUp() {
-    ge_.get_clients = TpGetClients;
-    ge_.event = TpEvent;
-    ge_.gesture = TpGesture;
-    ge_.priv = this;
-
-    fd_ = open(TEST_ROOT_DIR "io/evemu/one-tap.evemu", O_RDONLY | O_NONBLOCK);
-
-    if (0 != grail_open(&ge_, fd_))
-      throw std::runtime_error(
-          "Problem initializing grail for test-suite CheckMapping.");
-  }
-
-  /**
-   * @brief Cleanup procedure is called before every test.
-   */
-  virtual void TearDown() {
-    grail_close(&ge_, fd_);
-    close(fd_);
-  }
-
-  static int TpGetClients(struct grail* ge,
-                          grail_client_info* clients,
-                          int max_clients, const grail_coord* coords,
-                          int num_coords, const grail_mask_t *types,
-                          int type_bytes) {
-    memset(&clients[0], 0, sizeof(clients[0]));
-    memset(clients[0].mask, ~0, sizeof(clients[0].mask));
-    clients[0].id.client = 345;
-    clients[0].id.root = 1;
-    clients[0].id.event = 2;
-    clients[0].id.child = 3;
-    return 1;
-  }
-
-  static void TpEvent(grail* ge, const input_event* ev) {
-  }
-
-  static void TpGesture(grail* ge, const grail_event* ev) {
-    CheckMapping* data = static_cast<CheckMapping*>(ge->priv);
-    if (ev->type != GRAIL_TYPE_TAP1)
-      return;
-    data->pos_.x = ev->prop[GRAIL_PROP_TAP_X];
-    data->pos_.y = ev->prop[GRAIL_PROP_TAP_Y];
-  }
-
-  static float Distance(const grail_coord* p, float x, float y) {
-    double dx = p->x - x;
-    double dy = p->y - y;
-    return std::sqrt(dx * dx + dy * dy);
-  }
-};
-
-TEST_F(CheckMapping,device_coordinates) {
-  grail_pull(&ge_, fd_);
-
-  EXPECT_NEAR(0, CheckMapping::Distance(&pos_, 17086, 14789), 1E-8);
-}
-
-TEST_F(CheckMapping,mapped_coordinates) {
-  static const grail_coord min = { 0, 0 }, max = { 1.6, 1 };
-  grail_set_bbox(&ge_, &min, &max);
-
-  grail_pull(&ge_, fd_);
-
-  EXPECT_NEAR(0., CheckMapping::Distance(&pos_, 0.834303, 0.451338), 1E-6);
-}

=== removed file 'test/check-transform.cpp'
--- test/check-transform.cpp	2012-03-23 09:44:52 +0000
+++ test/check-transform.cpp	1970-01-01 00:00:00 +0000
@@ -1,116 +0,0 @@
-#include <fcntl.h>
-#include <unistd.h>
-
-#include <cmath>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <ctime>
-#include <stdexcept>
-
-#include <gtest/gtest.h>
-#include <utouch/frame-mtdev.h>
-
-#include "grail.h"
-
-/**
- * @brief Fixture for check-transform test suite.
- */
-class CheckTransform : public testing::Test {
- protected:
-  evemu_device* evemu_;
-  utouch_frame_handle fh_;
-  grail_handle ge_;
-  FILE* fp_;
-  timeval evtime_;
-
-  static float Distance(const grail_coord * p, float x, float y) {
-    double dx = p->x - x;
-    double dy = p->y - y;
-    return std::sqrt(dx * dx + dy * dy);
-  }
-
-  CheckTransform()
-      : evemu_(NULL),
-        fp_(NULL) {
-    std::memset(&fh_, 0, sizeof(fh_));
-    std::memset(&ge_, 0, sizeof(ge_));
-    std::memset(&evtime_, 0, sizeof(evtime_));
-  }
-
-  void SetUp() {
-    fp_ = fopen(TEST_ROOT_DIR "io/evemu/one-tap.evemu", "r");
-    if (!fp_)
-      throw std::runtime_error(
-          "Error opening pre-recorded events file io/evemu/one-tap.evemu.");
-
-    evemu_ = evemu_new(NULL);
-    if (!evemu_ || evemu_read(evemu_, fp_) <= 0)
-      throw std::runtime_error("Error reading emulated event.");
-
-    fh_ = utouch_frame_new_engine(100, 32, 100);
-    if (!fh_ || utouch_frame_init_mtdev(fh_, evemu_))
-      throw std::runtime_error("Error initializing utouch frame.");
-
-    ge_ = grail_new(fh_, 10, 0);
-    if (!ge_)
-      throw std::runtime_error(
-          "Error allocating and initializing grail context.");
-  }
-
-  void TearDown(struct test_data *data) {
-    grail_delete(ge_);
-    utouch_frame_delete_engine(fh_);
-    evemu_delete(evemu_);
-    fclose(fp_);
-  }
-
-  int GetEvent(input_event* ev) {
-    return evemu_read_event_realtime(fp_, ev, &evtime_) > 0;
-  }
-
-  const grail_element* GetElement(const input_event* ev) {
-    const utouch_frame* touch;
-    const grail_frame* frame;
-
-    touch = utouch_frame_pump_mtdev(fh_, ev);
-    if (!touch)
-      return NULL;
-    frame = grail_pump_frame(ge_, touch);
-    if (!frame || !frame->num_ongoing)
-      return NULL;
-
-    return frame->ongoing[frame->num_ongoing - 1];
-  }
-};
-
-TEST_F(CheckTransform, device_coordinates) {
-  struct input_event ev;
-  const struct grail_element *slot;
-  struct grail_coord pos = { 0, 0 };
-
-  while (GetEvent(&ev)) {
-    slot = GetElement(&ev);
-    if (slot)
-      pos = slot->center;
-  }
-
-  EXPECT_NEAR(0., CheckTransform::Distance(&pos, 17086, 14789), 1E-6);
-}
-
-TEST_F(CheckTransform, mapped_coordinates) {
-  static const struct grail_coord min = { 0, 0 }, max = { 1.6, 1 };
-  struct input_event ev;
-  const grail_element* slot;
-  struct grail_coord pos = { 0, 0 };
-
-  grail_set_bbox(ge_, &min, &max);
-
-  while (GetEvent(&ev)) {
-    slot = GetElement(&ev);
-    if (slot)
-      pos = slot->center;
-  }
-
-  EXPECT_NEAR(0., CheckTransform::Distance(&pos, 0.834303, 0.451338), 1E-6);
-}

=== modified file 'tools/Makefile.am'
--- tools/Makefile.am	2012-03-29 20:34:51 +0000
+++ tools/Makefile.am	2012-05-09 17:32:19 +0000
@@ -1,16 +1,10 @@
-bin_PROGRAMS = grail-gesture grail-test-mtdev
-noinst_PROGRAMS = grail-eventprinter
 dist_man_MANS = \
-	grail-gesture.1 \
 	grail-test-3-1.1 \
 	grail-test-atomic.1 \
 	grail-test-edge.1 \
-	grail-test-mtdev.1 \
 	grail-test-propagation.1
 
-if HAVE_XI22
-
-bin_PROGRAMS += \
+bin_PROGRAMS = \
 	grail-test-propagation \
 	grail-test-edge \
 	grail-test-3-1 \
@@ -48,8 +42,6 @@
 	common/slice.c \
 	common/slice.h
 
-endif
-
 INCLUDES=-I$(top_srcdir)/include/
 
 AM_CPPFLAGS = $(WARNING_CPPFLAGS)

=== removed file 'tools/grail-eventprinter.c'
--- tools/grail-eventprinter.c	2011-09-08 16:54:39 +0000
+++ tools/grail-eventprinter.c	1970-01-01 00:00:00 +0000
@@ -1,239 +0,0 @@
-/*****************************************************************************
- *
- * grail-eventprinter - pretty prints events as produced by Grail
- *
- * Copyright (C) 2010-2011 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/>.
- *
- ****************************************************************************/
-
-/* Regular applications must include <grail.h>. Since
- * this application needs to access Grail's internals
- * to access the private fast_fileread struct element,
- * it needs this header.
- *
- * Only Grail's internal tools are allowed to include
- * this header.
- */
-#include "../src/v2/grail-impl.h"
-
-#include <string.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-
-static grail_mask_t flag_mask[DIM_GRAIL_TYPE_BYTES];
-
-/* Order is the same as with defines in grail-types.h */
-
-static const char* const grail_event_names[] = {
-	"Drag1",
-	"Pinch1",
-	"Rotate1",
-	"Drag2",
-	"Pinch2",
-	"Rotate2",
-	"Drag3",
-	"Pinch3",
-	"Rotate3",
-	"Drag4",
-	"Pinch4",
-	"Rotate4",
-	"Drag5",
-	"Pinch5",
-	"Rotate5",
-	"Tap1",
-	"Tap2",
-	"Tap3",
-	"Tap4",
-	"Tap5",
-	"Edrag",
-	"Epinch",
-	"Erotate",
-	"Mdrag",
-	"Mpinch",
-	"Mrotate",
-	"Sysflag1",
-	"Unknown27",
-	"Unknown28",
-	"Unknown29",
-	"Unknown30",
-	"Unknown31",
-	"Touch1",
-	"Touch2",
-	"Touch3",
-	"Touch4",
-	"Touch5",
-	"Etouch",
-	"Mtouch"
-};
-
-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)
-{
-	printf("Client query.\n");
-
-	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)
-{
-	printf("Input event.\n");
-}
-
-static int is_drag_event(const struct grail_event *ev) {
-	return ev->type == GRAIL_TYPE_DRAG1 ||
-		ev->type == GRAIL_TYPE_DRAG2 ||
-		ev->type == GRAIL_TYPE_DRAG3 ||
-		ev->type == GRAIL_TYPE_DRAG4 ||
-		ev->type == GRAIL_TYPE_DRAG5;
-}
-
-static void print_drag_stats(const struct grail_event *ev) {
-	printf(" c = (%f, %f), delta = (%f, %f)\n",
-		ev->prop[GRAIL_PROP_DRAG_X],
-		ev->prop[GRAIL_PROP_DRAG_Y],
-		ev->prop[GRAIL_PROP_DRAG_VX],
-		ev->prop[GRAIL_PROP_DRAG_VY]);
-}
-
-static int is_rotate_event(const struct grail_event *ev) {
-	return ev->type == GRAIL_TYPE_ROTATE1 ||
-		ev->type == GRAIL_TYPE_ROTATE2 ||
-		ev->type == GRAIL_TYPE_ROTATE3 ||
-		ev->type == GRAIL_TYPE_ROTATE4 ||
-		ev->type == GRAIL_TYPE_ROTATE5;
-}
-
-static void print_rotate_stats(const struct grail_event *ev) {
-	printf(" a = %f, va = %f\n",
-		ev->prop[GRAIL_PROP_ROTATE_A],
-		ev->prop[GRAIL_PROP_ROTATE_VA]);
-}
-
-static int is_pinch_event(const struct grail_event *ev) {
-	return ev->type == GRAIL_TYPE_PINCH1 ||
-		ev->type == GRAIL_TYPE_PINCH2 ||
-		ev->type == GRAIL_TYPE_PINCH3 ||
-		ev->type == GRAIL_TYPE_PINCH4 ||
-		ev->type == GRAIL_TYPE_PINCH5;
-}
-
-static void print_pinch_stats(const struct grail_event *ev) {
-	printf(" radius = %f, delta r = %f\n",
-		ev->prop[GRAIL_PROP_PINCH_R],
-		ev->prop[GRAIL_PROP_PINCH_VR]);
-}
-
-const char *event_name(const struct grail_event *ev) {
-	return grail_event_names[ev->type];
-}
-
-static void tp_gesture(struct grail *ge, const struct grail_event *ev)
-{
-	if (ev->status == GRAIL_STATUS_BEGIN) {
-		printf("BEGIN gesture %s\n", event_name(ev));
-		if (is_drag_event(ev)){
-			print_drag_stats(ev);
-		}
-		if (is_rotate_event(ev)) {
-			print_rotate_stats(ev);
-		}
-		if (is_pinch_event(ev)) {
-			print_pinch_stats(ev);
-		}
-	}
-	if (ev->status == GRAIL_STATUS_UPDATE) {
-		printf("UPDATE gesture %s.\n", event_name(ev));
-	}
-	if (ev->status == GRAIL_STATUS_END) {
-		printf("END gesture %s.\n", event_name(ev));
-		if (is_drag_event(ev)){
-			print_drag_stats(ev);
-		}
-		if (is_rotate_event(ev)) {
-			print_rotate_stats(ev);
-		}
-		if (is_pinch_event(ev)) {
-			print_pinch_stats(ev);
-		}
-	}
-}
-
-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;
-	struct stat fs;
-	int i, fd;
-
-	if (argc < 2) {
-		fprintf(stderr, "Usage: %s <device or trace file>\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 = 0xffffffff; /* Get every gesture type. */
-	for (i = 0; i < DIM_GRAIL_TYPE; i++)
-		if ((mask >> i) & 1)
-			grail_mask_set(flag_mask, i);
-
-	fd = open(argv[1], O_RDONLY | O_NONBLOCK);
-	if (fd < 0) {
-		fprintf(stderr, "error: could not open device\n");
-		return -1;
-	}
-	if (fstat(fd, &fs)) {
-		fprintf(stderr, "error: could not stat the device\n");
-		return -1;
-	}
-	if (fs.st_rdev && 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;
-	}
-	ge.impl->fast_fileread = 1;
-
-	loop_device(&ge, fd);
-	grail_close(&ge, fd);
-
-	if (fs.st_rdev)
-		ioctl(fd, EVIOCGRAB, 0);
-	close(fd);
-	return 0;
-}

=== removed file 'tools/grail-gesture.1'
--- tools/grail-gesture.1	2012-03-29 13:21:33 +0000
+++ tools/grail-gesture.1	1970-01-01 00:00:00 +0000
@@ -1,17 +0,0 @@
-.TH GRAIL-GESTURE 1 "March 14, 2012" "grail" "uTouch"
-
-.SH NAME
-grail-gesture \- print grail v2 gesture events
-
-.SH SYNPOSIS
-.B grail-gesture
-.I mask
-.I devce
-.br
-
-.SH DESCRIPTION
-Prints grail v2 gesture events.  Works only with the grail v2 gesture
-recognition engine, based exclusively on the mtdev library to access kernel
-multi-touch input device events.
-
-This program is deprecated and will be removed in a future release of grail.

=== removed file 'tools/grail-gesture.c'
--- tools/grail-gesture.c	2011-04-28 16:53:57 +0000
+++ tools/grail-gesture.c	1970-01-01 00:00:00 +0000
@@ -1,131 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 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/>.
- *
- ****************************************************************************/
-
-#include <grail.h>
-#include <string.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <sys/stat.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;
-	struct stat fs;
-	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;
-