Merge lp:~oif-team/grail/grail2 into lp:grail

[Henrik Rydberg]

Rebased grail2 starter kit, this could go in trunk now.

[lp:~oif-team/grail/grail2]

139. By Chase Douglas on 2011-04-04

Merge send-key-events branch for better semi-mt support.

140. By Henrik Rydberg on 2011-04-04

Do not discard a started gesture

Not all discarding code paths were taking the notion of a started
gesture into account. Specifically, switching to a gesture of higher
priority would leave the old gesture without a finish. Fixed with
this patch.

Note that timeout implies not sent, so all discarding code paths
are now covered.

Signed-off-by: Henrik Rydberg <email address hidden>

141. By Henrik Rydberg on 2011-04-04

Glue touch gestures as well

All motion-activated gestures are held for a short (glue) time
to allow for direct transition to multi-finger gesture types.
The touch gestures were mistakenly implemented without this.
Fixed with this patch. LP: #748282

Signed-off-by: Henrik Rydberg <email address hidden>

142. By Chase Douglas on 2011-04-08

Merge branch to remove the EWMA move filter

143. By Jussi Pakkanen on 2011-04-27

Merged visibility fixes.

144. By Jussi Pakkanen on 2011-04-27

Merged C++ header fix.

145. By Jussi Pakkanen on 2011-04-27

Merge Pkg-config fix.

146. By Henrik Rydberg on 2011-04-27

Fixup remaining C++ and public function declarations

The grail-bits.h file can be included on its own, so it needs
the same handling. To save files in public name space, move the
visibility declarations to grail-bits.h, and include it as a main
file from grail.h.

Signed-off-by: Henrik Rydberg <email address hidden>

147. By Jussi Pakkanen on 2011-04-28

Merged Clang cleanups.

148. By Henrik Rydberg on 2011-04-28

Expose utouch-frame through grail API

Start a gentle API change by exposing utouch-frame through grail,
and deprecating the grail_contact struct. Old programs compile and
run fine. To only use the new api, compile with -DGRAIL_NO_LEGACY_API.

Signed-off-by: Henrik Rydberg <email address hidden>

149. By Henrik Rydberg on 2011-04-28

Prepare for gesture frame additions

Rename internal variables and fix makefile to make room for new
targets.

Signed-off-by: Henrik Rydberg <email address hidden>

150. By Henrik Rydberg on 2011-04-28

Introduce gesture frames

This patch extends the API with parallel new/delete functions,
aiming to eventually replace the open/close function. The new
functions give access to the grail gesture frames, containing
gestural transform information. This information is useful in its
own right, and will eventually replace the internal recognizer.

Signed-off-by: Henrik Rydberg <email address hidden>

151. By Henrik Rydberg on 2011-04-28

Document the gesture frame logic

Add some notes on the math of the gesture frame computations.

Signed-off-by: Henrik Rydberg <email address hidden>

152. By Henrik Rydberg on 2011-04-28

Add gesture transform unit tests

Start the gesture frame test suite with some basic coordinate
mapping tests.

Signed-off-by: Henrik Rydberg <email address hidden>

153. By Henrik Rydberg on 2011-04-28

Introduce test-mtdev

A new tool (test-mtdev) is added, showing the usage of gesture frames.

Signed-off-by: Henrik Rydberg <email address hidden>

154. By Henrik Rydberg on 2011-04-28

Introduce the grail transform tool

This tool tests the transform capabilities of grail. Similar to a
map application, one can use a single finger, two fingers, a whole
hand or two hands to move the rectangle around, scale and rotate it.

Signed-off-by: Henrik Rydberg <email address hidden>

155. By Henrik Rydberg on 2011-04-28

Update copyright information

The license information was always right, but the copyright information
for this particular project was never quite right. Corrected with this
patch. No functional changes.

Signed-off-by: Henrik Rydberg <email address hidden>

Unmerged revisions

=== added file 'AUTHORS'
--- AUTHORS	1970-01-01 00:00:00 +0000
+++ AUTHORS	2011-03-29 08:01:03 +0000
@@ -0,0 +1,1 @@
+Henrik Rydberg <[e-mail]>

=== modified file 'configure.ac'
--- configure.ac	2011-03-17 09:47:52 +0000
+++ configure.ac	2011-03-29 08:01:03 +0000
@@ -26,6 +26,13 @@
 PKG_CHECK_MODULES([EVEMU], [utouch-evemu >= 1.0.5])
 PKG_CHECK_MODULES([FRAME], [utouch-frame >= 1.0])
 
+AC_ARG_WITH([xi], AS_HELP_STRING([--with-xi], [Build with XI2.1 support]))
+AM_CONDITIONAL([HAVE_XI], [test "x$with_xi" != "x"])
+
+AS_IF([test "x$with_xi" = "xyes"], [
+   PKG_CHECK_MODULES(XINPUT, x11 xext [xi >= 1.4.1.99.1] [inputproto >= 2.0.99.1])
+   AC_DEFINE([HAVE_XI], [1], [XI2.1 support])
+])
 # Check for TDD tools
 PKG_CHECK_MODULES([CHECK], [check >= 0.9.8],
                   [have_check=yes],

=== added file 'docs/gestures.txt'
--- docs/gestures.txt	1970-01-01 00:00:00 +0000
+++ docs/gestures.txt	2011-03-29 08:01:03 +0000
@@ -0,0 +1,18 @@
+The gesture transformation from a multi-finger action is overstated and to
+a certain extent arbitrary. This document describes how it is performed in
+grail2.
+
+All two-finger transformations are extracted. These are all exact, in the
+sense that continusouly transforming the original finger position, frame
+per frame, will exactly follow the actual finger position.
+
+In addition to two-finger transformations, one global gesture is also
+extracted. The rotation and scaling is taken from the pair with the longest
+distance between contacts. This approximates the behavior of a region, such
+that complex transformations could be happening inside the region, but at a
+distance, the behavior should look like it was performed with two fingers.
+
+The pivot of the global gesture is extracted using least squares, using the
+same principle as for contact pairs; the pivot is the point which, after
+rotation and scaling, leaves the transformed contacts as close to the
+actual positions as possible.

=== added file 'docs/pivot.txt'
--- docs/pivot.txt	1970-01-01 00:00:00 +0000
+++ docs/pivot.txt	2011-03-29 08:01:03 +0000
@@ -0,0 +1,144 @@
+The pivot, p, is defined as the point, within the convex hull of the
+contacts, which, after rotation and scaling, leaves the transformed
+contacts as close to the actual positions as possible.
+
+Let r_i be the starting points and s_i the actual ending points in a
+transformation. Let D be the scaling, and R the rotation. Then, minimizing
+
+L(p) = sum_i |D R (r_i - p) + p - s_i|^2 / N
+
+yields the pivot. Let
+
+rm = sum_i r_i / N,
+p = rm + u,
+q_i = s_i - rm - D R (r_i - rm),
+
+and we get
+
+L(p) = sum_i |(1 - D R) u - q_i|^2 / N.
+
+With
+
+L0 = sum_i norm2(q_i) / N,
+T = (1 - D R)' (1 - D R),
+m = sum_i q_i / N,
+
+we can write this as
+
+L(p) = L0 + u' T u - 2 m' (1 - D R) u.
+
+To handle the constraint, we can approximate the hull with a circle
+centered at rm. If we pick the average radius, P, the constraint becomes
+
+|u| < P.
+
+Relaxing the expression (h >= 0) yields
+
+L(p, h) = L0 + u' T u - 2 m' (1 - D R) u + h (|u|^2 - P^2),
+
+leading to the linear equation
+
+(T + h) u = (1 - D R)' m.
+
+Further,
+
+sm = sum_i s_i / N,
+m = sum_i (s_i - rm - D R (r_i - rm)) / N = sm - rm,
+
+thus m is the average displacement. In words, the pivot is the average
+position plus a correction depending on the average displacement.
+
+*
+
+Some algebra solves the equation,
+
+D' = D,
+[D, R] = 0,
+R = S + C,
+S' = -S,
+C' = C,
+R + R' = 2 C,
+T = (1 - D R)' (1 - D R) = 1 + D^2 - 2 D C,
+
+which is a simple diagonal scaling operator. With
+
+a = 1 - D C,
+b = D S,
+
+we can write this as
+
+T = (1 - DC)^2 + D^2(1 - C^2) = (1 - DC)^2 + D^2 S^2 = a^2 + b^2.
+
+Similarly, we can write
+
+(1 - D R)' = ((a, b), (-b, a)),
+
+and thusly,
+
+u = Q(h) m,
+
+with
+
+Q(h) = ((a, b), (-b, a)) / (a^2 + b^2 + h).
+
+When D R = 1, it follows that a^2 + b^2 = 0, and the relaxation ensures
+that u is finite.
+
+*
+
+The drag is found by minimizing
+
+E(d) = sum_i | D R (r_i - p) + p + d - s_i |^2 / N,
+E(d) = d^2 + 2 d' ((1 - D R) u - m) + E0,
+
+which leads to the linear equation
+
+d = m - (1 - D R) u.
+
+Explicitly,
+
+d = m - (a ux - b uy, a uy + b ux).
+
+Inserting the expression for u yields, after some algebra,
+
+d = m (1 - (a^2 + b^2) / (a^2 + b^2 + h)).
+
+When h = 0, d = 0, as expected.
+
+When a^2 + b^2 = 0, d = m, also as expected.
+
+For constrained cases, the drag is a fraction of the average displacement.
+
+*
+
+Time to look at measures for the relaxation parameter. Since d depends on
+h, we can write the correction u(h) in terms of d instead. After som
+algebra,
+
+|u(h)| = (|m| - |d|) / sqrt(a^2 + b^2).
+
+Conversely, d(h) can be written in terms of the constrained u(h) as
+
+d(h) = m (1 - sqrt(a^2 + b^2) |u(h)| / |m|).
+
+Since |u(0)| = |m| / sqrt(a^2 + b^2), we obtain
+
+d(h) = m (1 - |u(h)| / |u(0)|).
+
+*
+
+We can now write down an explicit recipe for determining the pivot (p) and
+drag (d), given the transformation parameters a and b.
+
+w = (a mx + b my, a my - b mx).
+
+If |w| = 0, then u = 0. Consequently p = rm, d = m, and we are done. Else,
+
+u = w |m|^2 / |w|^2,
+
+t = P / |u|.
+
+If t >= 1, then p = rm + u, d = 0, and we are done. Else,
+
+p = rm + t u,
+d = (1 - t) m.

=== modified file 'include/grail-bits.h'
--- include/grail-bits.h	2010-08-06 20:30:20 +0000
+++ include/grail-bits.h	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'include/grail-types.h'
--- include/grail-types.h	2011-03-28 20:04:07 +0000
+++ include/grail-types.h	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'include/grail.h'
--- include/grail.h	2010-08-19 20:35:45 +0000
+++ include/grail.h	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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
@@ -25,8 +24,11 @@
 
 #include <grail-bits.h>
 #include <grail-types.h>
+#include <utouch/frame.h>
 #include <linux/input.h>
 
+#define GRAIL_VERSION           0x00011000
+
 #define DIM_GRAIL_TYPE		64
 #define DIM_GRAIL_TYPE_BYTES	((DIM_GRAIL_TYPE + 7) >> 3)
 
@@ -37,8 +39,28 @@
 #define GRAIL_STATUS_UPDATE	1
 #define GRAIL_STATUS_END	2
 
-typedef float grail_prop_t;		/* gesture properties */
-typedef __u64 grail_time_t;		/* time in milliseconds */
+#define GRAIL_EXPECT_X		0x0001
+#define GRAIL_EXPECT_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_get_version(void);
 
 /**
  * struct grail_coord - coordinate in bounding box units
@@ -49,32 +71,63 @@
 	float x, y;
 };
 
-/**
- * struct grail_contact - MT event information in bounding box units
- * @id: Contact tracking id
- * @tool_type: Tool type (ABS_MT_TOOL_TYPE)
- * @pos: Position of contact (bbox units)
- * @touch_major: Major axis of contact shape (bbox units)
- * @touch_minor: Minor axis of contact shape (bbox units)
- * @width_major: Major axis of perimeter (bbox units)
- * @width_minor: Minor axis of perimeter (bbox units)
- * @angle: Angle of orientation (vertical: 0 horizontal: +-M_PI_2)
- * @pressure: Pressure of contact (min: 0 max: 1)
- *
- * Depending on the native support of the underlying device, some or all of
- * the listed properties may be computed.
- */
-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;
-};
+grail_handle 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_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_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_pump_frame(grail_handle ge,
+					    const struct utouch_frame *frame);
 
 /**
  * struct grail_client_id - Gesture client information
@@ -102,6 +155,139 @@
 };
 
 /**
+ * struct grail_control - control parameters of grail
+ * @glue_ms: minimum time to hold activation (ms)
+ * @thresh_drag: minimum moveness for drag
+ * @thresh_scale: maximum moveness for rotate and scale
+ * @bar_x: minimum horizontal distance to activate (surface width fraction)
+ * @bar_y: minimum 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 thresh_drag;
+	float thresh_scale;
+	float bar_x;
+	float bar_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
+ * @pivot: current center of rotate and scale (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];
+	float moveness;
+	struct grail_coord pivot;
+	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 + T[1] * p->y + T[2];
+	q->y = T[3] * p->x + T[4] * p->y + T[5];
+}
+
+/**
  * struct grail_event - Gesture event
  * @type: The gesture type
  * @id: Unique identifier foof the gesture instance
@@ -227,19 +413,6 @@
 		    const struct grail_coord *max);
 
 /**
- * grail_filter_abs_events - filter kernel motion events
- * @ge: the grail device in use
- * @usage: When true, filter kernel motion events.
- *
- * Single-finger pointer events are treated as pointer gestures in
- * grail. When filter_motion_events is non-zero, the kernel events
- * corresponding to pointer movement are removed from the event
- * stream.
- *
- */
-void grail_filter_abs_events(struct grail *ge, int usage);
-
-/**
  * grail_get_units - get device coordinate ranges
  * @ge: the grail device in use
  * @min: minimum x and y coordinates
@@ -255,15 +428,40 @@
 		     struct grail_coord *min, struct grail_coord *max);
 
 /**
- * grail_get_contacts - get current contact state
+ * grail_get_contact_frame - get current contact frame
  * @ge: the grail device in use
- * @touch: array of contacts to be filled in
- * @max_touch: maximum number of contacts supported by the array
- *
- * Extract the contact state as currently seen by grail.
- *
+ *
+ * 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_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_filter_abs_events(struct grail *ge, int usage);
+
 int grail_get_contacts(const struct grail *ge,
 		       struct grail_contact *touch, int max_touch);
 
 #endif
+
+#endif

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2011-03-28 20:04:07 +0000
+++ src/Makefile.am	2011-03-29 08:01:03 +0000
@@ -26,7 +26,10 @@
 	grail-recognizer.h \
 	grail-event.c \
 	grail-impl.h \
-	grail-api.c
+	grail-api.c \
+	grail-legacy.c \
+	grail-init.c \
+	grail-frame.c
 
 AM_CFLAGS = $(CWARNFLAGS)
 

=== modified file 'src/evbuf.h'
--- src/evbuf.h	2011-02-24 22:50:31 +0000
+++ src/evbuf.h	2011-03-29 08:01:03 +0000
@@ -1,28 +1,21 @@
 /*****************************************************************************
  *
- * mtdev - Multitouch Protocol Translation Library (MIT license)
- *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
+ * 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/>.
  *
  ****************************************************************************/
 

=== modified file 'src/gebuf.h'
--- src/gebuf.h	2011-01-02 12:08:08 +0000
+++ src/gebuf.h	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'src/gestures-drag.c'
--- src/gestures-drag.c	2011-03-28 20:04:18 +0000
+++ src/gestures-drag.c	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'src/gestures-pinch.c'
--- src/gestures-pinch.c	2011-03-28 20:04:11 +0000
+++ src/gestures-pinch.c	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'src/gestures-rotate.c'
--- src/gestures-rotate.c	2011-03-28 20:04:11 +0000
+++ src/gestures-rotate.c	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'src/gestures-tapping.c'
--- src/gestures-tapping.c	2011-03-24 21:46:18 +0000
+++ src/gestures-tapping.c	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'src/grail-api.c'
--- src/grail-api.c	2011-03-17 09:46:39 +0000
+++ src/grail-api.c	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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
@@ -20,9 +19,9 @@
  *
  ****************************************************************************/
 
+#include "grail-impl.h"
 #include "grail-inserter.h"
 #include "grail-recognizer.h"
-#include "grail-impl.h"
 #include <string.h>
 #include <stdio.h>
 #include <unistd.h>
@@ -34,10 +33,9 @@
 #define DIM_FRAMES 100
 #define FRAME_RATE 100
 
-void grail_filter_abs_events(struct grail *ge, int usage)
+unsigned int grail_get_version(void)
 {
-	struct grail_impl *x = ge->impl;
-	x->filter_abs = usage;
+	return GRAIL_VERSION;
 }
 
 int grail_open(struct grail *ge, int fd)
@@ -151,6 +149,11 @@
 	max->y = s->max_y;
 }
 
+const struct utouch_frame *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;
@@ -226,7 +229,7 @@
 	struct grail_impl *impl = ge->impl;
 	struct grail_event gev;
 
-	ge->impl->frame = frame;
+	ge->impl->touch = frame;
 
 	if (frame->num_active && !frame->prev->num_active) {
 		impl->ongoing = 1;

=== modified file 'src/grail-bits.c'
--- src/grail-bits.c	2010-08-06 20:30:20 +0000
+++ src/grail-bits.c	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'src/grail-event.c'
--- src/grail-event.c	2011-03-17 09:48:13 +0000
+++ src/grail-event.c	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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
@@ -117,28 +116,3 @@
 		grailbuf_put(&impl->gbuf, &gev);
 	}
 }
-
-int grail_get_contacts(const struct grail *ge,
-		       struct grail_contact *touch, int max_touch)
-{
-	const struct gesture_inserter *gin = ge->gin;
-	const struct utouch_frame *frame = ge->impl->frame;
-	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;
-}

=== added file 'src/grail-frame.c'
--- src/grail-frame.c	1970-01-01 00:00:00 +0000
+++ src/grail-frame.c	2011-03-29 08:01:03 +0000
@@ -0,0 +1,372 @@
+/*****************************************************************************
+ *
+ * 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-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_moveness_pivot_and_drag(struct grail_impl *impl,
+					struct grail_element *slot,
+					double ds, double dc)
+{
+	const struct grail_element *pslot = slot->prev;
+	double mx = slot->center.x - pslot->center.x;
+	double my = slot->center.y - pslot->center.y;
+	float *T = slot->transform;
+
+	slot->moveness = 1;
+	slot->pivot = pslot->center;
+
+	if (slot->num_touches > 1) {
+		double wx = (1 - dc) * mx + ds * my;
+		double wy = (1 - dc) * my - ds * mx;
+		double w2 = wx * wx + wy * wy;
+		if (w2 > 0) {
+			double s = sqrt(pslot->radius2 / w2);
+			double q = (mx * mx + my * my) / w2;
+			if (s < q) {
+				slot->moveness = 1 - s / q;
+				slot->pivot.x += s * wx;
+				slot->pivot.y += s * wy;
+			} else {
+				slot->moveness = 0;
+				slot->pivot.x += q * wx;
+				slot->pivot.y += q * wy;
+			}
+		}
+	}
+
+	mx *= slot->moveness;
+	my *= slot->moveness;
+
+	T[0] = dc;
+	T[1] = ds;
+	T[2] = (1 - dc) * slot->pivot.x - ds * slot->pivot.y + mx;
+	T[3] = -ds;
+	T[4] = dc;
+	T[5] = (1 - dc) * slot->pivot.y + ds * slot->pivot.x + my;
+
+	slot->drag.x = pslot->drag.x + mx;
+	slot->drag.y = pslot->drag.y + my;
+}
+
+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->pivot = slot->center;
+	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->expect_mask = pslot->expect_mask;
+	slot->active_mask = pslot->active_mask;
+	slot->start_time = pslot->start_time;
+
+	set_center_velocity_and_radius(impl, slot);
+	set_moveness_pivot_and_drag(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)
+{
+	slot->id = -1;
+	slot->expect_mask = 0;
+	slot->num_touches = 0;
+}
+
+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]);
+}
+
+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 dx = ctl->bar_x * (s->mapped_max_x - s->mapped_min_x);
+	float dy = ctl->bar_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->expect_mask)
+			continue;
+
+		dt = touch->time - s->start_time;
+		if (dt > ctl->glue_ms) {
+
+			if (s->moveness > ctl->thresh_drag) {
+				if (fabs(s->drag.x) > dx)
+					s->active_mask |= GRAIL_EXPECT_X;
+				if (fabs(s->drag.y) > dy)
+					s->active_mask |= GRAIL_EXPECT_Y;
+			}
+			if (s->moveness < ctl->thresh_scale) {
+				if (fabs(s->scale2 - 1) > ds2)
+					s->active_mask |= GRAIL_EXPECT_SCALE;
+				if (fabs(s->angle) > ctl->bar_angle)
+					s->active_mask |= GRAIL_EXPECT_ANGLE;
+			}
+
+			s->active_mask &= s->expect_mask;
+
+			if (dt > ctl->drop_x_ms)
+				s->expect_mask &= ~GRAIL_EXPECT_X;
+			if (dt > ctl->drop_y_ms)
+				s->expect_mask &= ~GRAIL_EXPECT_Y;
+			if (dt > ctl->drop_scale_ms)
+				s->expect_mask &= ~GRAIL_EXPECT_SCALE;
+			if (dt > ctl->drop_angle_ms)
+				s->expect_mask &= ~GRAIL_EXPECT_ANGLE;
+
+			s->expect_mask |= s->active_mask;
+		}
+
+		if (s->expect_mask)
+			frame->ongoing[frame->num_ongoing++] = s;
+	}
+}
+
+const struct grail_frame *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;
+}

=== modified file 'src/grail-gestures.c'
--- src/grail-gestures.c	2011-03-28 20:04:16 +0000
+++ src/grail-gestures.c	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'src/grail-gestures.h'
--- src/grail-gestures.h	2011-03-28 20:04:07 +0000
+++ src/grail-gestures.h	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'src/grail-impl.h'
--- src/grail-impl.h	2011-03-17 09:46:39 +0000
+++ src/grail-impl.h	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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
@@ -33,18 +32,56 @@
 
 #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 *frame;
+	const struct utouch_frame *touch;
 	struct evbuf evbuf;
 	struct grailbuf gbuf;
 	int filter_abs;
 	int ongoing;
 	int gesture;
 	FILE *fptest;
+	/* 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

=== added file 'src/grail-init.c'
--- src/grail-init.c	1970-01-01 00:00:00 +0000
+++ src/grail-init.c	2011-03-29 08:01:03 +0000
@@ -0,0 +1,240 @@
+/*****************************************************************************
+ *
+ * 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-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->thresh_drag = 0.8;
+	c->thresh_scale = 0.2;
+	c->bar_x = 0.02;
+	c->bar_y = 0.02;
+	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;
+	int i;
+
+	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)
+{
+	struct utouch_surface *s = utouch_frame_get_surface(fh);
+	unsigned int ntouch = utouch_frame_get_num_slots(fh);
+	unsigned int nslot = get_slot_count(ntouch);
+	int i, j;
+
+	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_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_delete(grail_handle ge)
+{
+	destroy_grail2(ge->impl);
+	free(ge->impl);
+	free(ge);
+}
+
+struct grail_control *grail_get_control(grail_handle ge)
+{
+	return ge->impl->ctl;
+}

=== modified file 'src/grail-inserter.c'
--- src/grail-inserter.c	2011-03-28 20:04:20 +0000
+++ src/grail-inserter.c	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'src/grail-inserter.h'
--- src/grail-inserter.h	2011-03-28 20:04:20 +0000
+++ src/grail-inserter.h	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== added file 'src/grail-legacy.c'
--- src/grail-legacy.c	1970-01-01 00:00:00 +0000
+++ src/grail-legacy.c	2011-03-29 08:01:03 +0000
@@ -0,0 +1,65 @@
+/*****************************************************************************
+ *
+ * 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 "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_filter_abs_events(struct grail *ge, int usage)
+{
+	struct grail_impl *x = ge->impl;
+	x->filter_abs = usage;
+}
+
+int grail_get_contacts(const struct grail *ge,
+		       struct grail_contact *touch, int max_touch)
+{
+	const struct gesture_inserter *gin = ge->gin;
+	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

=== modified file 'src/grail-recognizer.c'
--- src/grail-recognizer.c	2011-03-28 20:04:07 +0000
+++ src/grail-recognizer.c	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'src/grail-recognizer.h'
--- src/grail-recognizer.h	2011-03-28 20:04:07 +0000
+++ src/grail-recognizer.h	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'src/grailbuf.h'
--- src/grailbuf.h	2011-01-02 12:06:56 +0000
+++ src/grailbuf.h	2011-03-29 08:01:03 +0000
@@ -2,8 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ * 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

=== modified file 'test/Makefile.am'
--- test/Makefile.am	2011-03-17 09:47:52 +0000
+++ test/Makefile.am	2011-03-29 08:01:03 +0000
@@ -9,6 +9,7 @@
 
 check_grail_SOURCES = \
 	check-mapping.c \
+	check-transform.c \
 	check-grail.c
 
 check_grail_CFLAGS = \

=== modified file 'test/check-grail.c'
--- test/check-grail.c	2011-03-17 09:47:52 +0000
+++ test/check-grail.c	2011-03-29 08:01:03 +0000
@@ -3,6 +3,7 @@
 #define LOGFILE_PREFIX ""
 
 extern Suite *make_mapping_suite();
+extern Suite *make_transform_suite();
 
 int main(int argc CK_ATTRIBUTE_UNUSED, char* argv[] CK_ATTRIBUTE_UNUSED)
 {
@@ -11,6 +12,7 @@
 	int num_failed;
 
 	srunner_add_suite(sr, make_mapping_suite());
+	srunner_add_suite(sr, make_transform_suite());
 
 	srunner_set_log(sr, "check_grail.log");
 	srunner_set_xml(sr, "check_grail.xml");

=== added file 'test/check-transform.c'
--- test/check-transform.c	1970-01-01 00:00:00 +0000
+++ test/check-transform.c	2011-03-29 08:01:03 +0000
@@ -0,0 +1,137 @@
+#include <check.h>
+#include <utouch/frame-mtdev.h>
+#include <grail.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+
+struct test_data {
+	struct evemu_device *evemu;
+	utouch_frame_handle fh;
+	grail_handle ge;
+	FILE *fp;
+	struct timeval evtime;
+};
+
+static int near(const struct grail_coord *p, float x, float y)
+{
+	double dx = p->x - x;
+	double dy = p->y - y;
+	return dx * dx + dy * dy < 1e-8 * (x * x + y * y);
+}
+
+static int init_test_data(struct test_data *data, const char *path)
+{
+	memset(data, 0, sizeof(*data));
+
+	data->fp = fopen(path, "r");
+	if (!data->fp)
+		return -1;
+
+	data->evemu = evemu_new(NULL);
+	if (!data->evemu || evemu_read(data->evemu, data->fp) <= 0)
+		return -1;
+
+	data->fh = utouch_frame_new_engine(100, 32, 100);
+	if (!data->fh || utouch_frame_init_mtdev(data->fh, data->evemu))
+		return -1;
+
+	data->ge = grail_new(data->fh, 10, 0);
+	if (!data->ge)
+		return -1;
+
+	return 0;
+}
+
+static void term_test_data(struct test_data *data)
+{
+	grail_delete(data->ge);
+	utouch_frame_delete_engine(data->fh);
+	evemu_delete(data->evemu);
+	fclose(data->fp);
+}
+
+static int get_event(struct test_data *data, struct input_event *ev)
+{
+	return evemu_read_event_realtime(data->fp, ev, &data->evtime) > 0;
+}
+
+static const struct grail_element *get_element(struct test_data *data,
+					       const struct input_event *ev)
+{
+	const struct utouch_frame *touch;
+	const struct grail_frame *frame;
+
+	touch = utouch_frame_pump_mtdev(data->fh, ev);
+	if (!touch)
+		return 0;
+	frame = grail_pump_frame(data->ge, touch);
+	if (!frame || !frame->num_ongoing)
+		return 0;
+
+	return frame->ongoing[frame->num_ongoing - 1];
+}
+
+START_TEST(device_coordinates)
+{
+	struct test_data data;
+	struct input_event ev;
+	const struct grail_element *slot;
+	struct grail_coord pos = { 0, 0 };
+
+	fail_if(init_test_data(&data, "io/evemu/one-tap.evemu"));
+
+	while (get_event(&data, &ev)) {
+		slot = get_element(&data, &ev);
+		if (slot)
+			pos = slot->center;
+	}
+
+	fail_unless(near(&pos, 17087, 14790));
+
+	term_test_data(&data);
+}
+END_TEST
+
+START_TEST(mapped_coordinates)
+{
+	static const struct grail_coord min = { 0, 0 }, max = { 1.6, 1 };
+	struct test_data data;
+	struct input_event ev;
+	const struct grail_element *slot;
+	struct grail_coord pos = { 0, 0 };
+
+	fail_if(init_test_data(&data, "io/evemu/one-tap.evemu"));
+	grail_set_bbox(data.ge, &min, &max);
+
+	while (get_event(&data, &ev)) {
+		slot = get_element(&data, &ev);
+		if (slot)
+			pos = slot->center;
+	}
+
+	fail_unless(near(&pos, 0.834303, 0.451338));
+
+	term_test_data(&data);
+}
+END_TEST
+
+Suite *make_transform_suite()
+{
+	Suite *s = suite_create("grail-solver");
+	TCase *test;
+
+	test = tcase_create("device_coordinates");
+	tcase_add_test(test, device_coordinates);
+	suite_add_tcase(s, test);
+
+	test = tcase_create("mapped_coordinates");
+	tcase_add_test(test, mapped_coordinates);
+	suite_add_tcase(s, test);
+
+	return s;
+}

=== modified file 'tools/Makefile.am'
--- tools/Makefile.am	2011-01-02 12:08:08 +0000
+++ tools/Makefile.am	2011-03-29 08:01:03 +0000
@@ -1,7 +1,15 @@
-bin_PROGRAMS = grail-gesture
+bin_PROGRAMS = grail-gesture grail-test-mtdev
+
+if HAVE_XI
+
+bin_PROGRAMS += grail-transform
+
+endif
 
 INCLUDES=-I$(top_srcdir)/include/
 
-grail_gesture_SOURCES = grail-gesture.c
-grail_gesture_LDFLAGS = -L$(top_builddir)/src/.libs/ \
-	-lutouch-grail -lutouch-frame -lutouch-evemu -lmtdev -lm
+AM_CFLAGS = $(X11_CFLAGS) $(XINPUT_CFLAGS)
+
+AM_LDFLAGS = -L$(top_builddir)/src/.libs/ \
+	-lutouch-grail -lutouch-frame -lutouch-evemu -lmtdev \
+	$(X11_LIBS) $(XINPUT_LIBS) -lm

=== modified file 'tools/grail-gesture.c'
--- tools/grail-gesture.c	2011-03-17 09:46:39 +0000
+++ tools/grail-gesture.c	2011-03-29 08:01:03 +0000
@@ -2,7 +2,7 @@
  *
  * grail - Gesture Recognition And Instantiation Library
  *
- * Copyright (C) 2010 Canonical Ltd.
+ * 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
@@ -17,9 +17,6 @@
  * You should have received a copy of the GNU General Public License along
  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
- * Authors:
- *      Henrik Rydberg <[e-mail]>
- *
  ****************************************************************************/
 
 #include <grail.h>

=== added file 'tools/grail-test-mtdev.c'
--- tools/grail-test-mtdev.c	1970-01-01 00:00:00 +0000
+++ tools/grail-test-mtdev.c	2011-03-29 08:01:03 +0000
@@ -0,0 +1,256 @@
+/*****************************************************************************
+ *
+ * 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/>.
+ *
+ ****************************************************************************/
+
+#define MTDEV_NO_LEGACY_API
+
+#include <utouch/frame-mtdev.h>
+#include <grail.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <math.h>
+
+struct frame_test {
+	struct evemu_device *evemu;
+	struct mtdev *mtdev;
+	utouch_frame_handle fh;
+	grail_handle ge;
+};
+
+static int init_evemu(struct frame_test *test, FILE *fp, int fd)
+{
+	test->evemu = evemu_new(NULL);
+	if (!test->evemu)
+		return -1;
+	if (fp)
+		return evemu_read(test->evemu, fp) <= 0;
+	else
+		return evemu_extract(test->evemu, fd);
+}
+
+static int init_mtdev(struct frame_test *test, int fd)
+{
+	test->mtdev = mtdev_new_open(fd);
+	if (!test->mtdev)
+		return -1;
+	return 0;
+}
+
+static int init_frame(struct frame_test *test, int fd)
+{
+	test->fh = utouch_frame_new_engine(100, 32, 100);
+	if (!test->fh)
+		return -1;
+	return utouch_frame_init_mtdev(test->fh, test->evemu);
+}
+
+static int init_grail(struct frame_test *test)
+{
+	struct grail_coord min = { 0, 0 };
+	struct grail_coord max = { 1, 1 };
+	test->ge = grail_new(test->fh, 10, 0);
+	if (!test->ge)
+		return -1;
+	grail_set_bbox(test->ge, &min, &max);
+	return 0;
+}
+
+static void destroy_all(struct frame_test *test)
+{
+	grail_delete(test->ge);
+	utouch_frame_delete_engine(test->fh);
+	if (test->mtdev)
+		mtdev_close_delete(test->mtdev);
+	evemu_delete(test->evemu);
+	memset(test, 0, sizeof(*test));
+}
+
+static void report_frame(grail_handle ge,
+			 const struct utouch_frame *touch)
+{
+	const struct grail_frame *frame = grail_pump_frame(ge, touch);
+	int i;
+
+	if (!frame)
+		return;
+
+	fprintf(stderr, "ongoing elements: %d\n", frame->num_ongoing);
+
+	for (i = 0; i < frame->num_ongoing; i++) {
+		const struct grail_element *slot = frame->ongoing[i];
+		if (!slot->active_mask)
+			continue;
+
+		fprintf(stderr, " element %d\n", i);
+		fprintf(stderr, "  slot:         %d\n", slot->slot);
+		fprintf(stderr, "  id:           %d\n", slot->id);
+		fprintf(stderr, "  num_touches:  %d\n", slot->num_touches);
+		fprintf(stderr, "  expect:       %d\n", slot->expect_mask);
+		fprintf(stderr, "  active:       %d\n", slot->active_mask);
+		fprintf(stderr, "  start time:   %ld\n", slot->start_time);
+		fprintf(stderr, "  center.x:     %f\n", slot->center.x);
+		fprintf(stderr, "  center.y:     %f\n", slot->center.y);
+		fprintf(stderr, "  velocity.x:   %f\n", slot->velocity.x);
+		fprintf(stderr, "  velocity.y:   %f\n", slot->velocity.y);
+		fprintf(stderr, "  radius2:      %f\n", slot->radius2);
+		fprintf(stderr,	"                %+08f %+08f %+08f\n"
+			"                %+08f %+08f %+08f\n"
+			"                %+08f %+08f %+08f\n",
+			slot->transform[0], slot->transform[1],
+			slot->transform[2], slot->transform[3],
+			slot->transform[4], slot->transform[5],
+			slot->transform[6], slot->transform[7],
+			slot->transform[8]);
+		fprintf(stderr, "  moveness:     %f\n", slot->moveness);
+		fprintf(stderr, "  pivot.x:      %f\n", slot->pivot.x);
+		fprintf(stderr, "  pivot.y:      %f\n", slot->pivot.y);
+		fprintf(stderr, "  drag.x:       %f\n", slot->drag.x);
+		fprintf(stderr, "  drag.y:       %f\n", slot->drag.y);
+		fprintf(stderr, "  scale2:       %f\n", slot->scale2);
+		fprintf(stderr, "  angle:        %f\n", slot->angle);
+	}
+}
+
+static void loop_device(struct frame_test *test, FILE *fp, int fd)
+{
+	const struct utouch_frame *frame;
+	struct input_event ev;
+
+	if (fp) {
+		struct timeval evtime;
+		memset(&evtime, 0, sizeof(evtime));
+		while (evemu_read_event_realtime(fp, &ev, &evtime) > 0) {
+			frame = utouch_frame_pump_mtdev(test->fh, &ev);
+			if (frame)
+				report_frame(test->ge, frame);
+		}
+	} else {
+		while (!mtdev_idle(test->mtdev, fd, 5000)) {
+			while (mtdev_get(test->mtdev, fd, &ev, 1) > 0) {
+				frame = utouch_frame_pump_mtdev(test->fh, &ev);
+				if (frame)
+					report_frame(test->ge, frame);
+			}
+		}
+	}
+}
+
+static void report_device_caps(struct frame_test *test)
+{
+	const struct utouch_surface *s = utouch_frame_get_surface(test->fh);
+
+	fprintf(stderr, "device props:\n");
+	if (s->needs_pointer)
+		fprintf(stderr, "\tpointer\n");
+	if (s->is_direct)
+		fprintf(stderr, "\tdirect\n");
+	if (s->is_buttonpad)
+		fprintf(stderr, "\tbuttonpad\n");
+	if (s->is_semi_mt)
+		fprintf(stderr, "\tsemi_mt\n");
+	fprintf(stderr, "device mt events:\n");
+	if (s->use_touch_major)
+		fprintf(stderr, "\ttouch_major\n");
+	if (s->use_touch_minor)
+		fprintf(stderr, "\ttouch_minor\n");
+	if (s->use_width_major)
+		fprintf(stderr, "\twidth_major\n");
+	if (s->use_width_minor)
+		fprintf(stderr, "\twidth_minor\n");
+	if (s->use_orientation)
+		fprintf(stderr, "\torientation\n");
+	if (s->use_pressure)
+		fprintf(stderr, "\tpressure\n");
+	if (s->use_distance)
+		fprintf(stderr, "\tdistance\n");
+
+	fprintf(stderr, "touch frames: %d\n",
+		utouch_frame_get_num_frames(test->fh));
+	fprintf(stderr, "touch slots: %d\n",
+		utouch_frame_get_num_slots(test->fh));
+}
+
+int main(int argc, char *argv[])
+{
+	struct frame_test test;
+	struct stat fs;
+	FILE *fp = 0;
+	int fd;
+
+	if (argc < 2) {
+		fprintf(stderr, "Usage: %s <device>\n", argv[0]);
+		return -1;
+	}
+
+	memset(&test, 0, sizeof(test));
+
+	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)
+		fp = fdopen(fd, "r");
+
+	if (!fp && ioctl(fd, EVIOCGRAB, 1)) {
+		fprintf(stderr, "error: could not grab the device\n");
+		return -1;
+	}
+
+	if (init_evemu(&test, fp, fd)) {
+		fprintf(stderr, "error: could not describe device\n");
+		return -1;
+	}
+	if (!utouch_frame_is_supported_mtdev(test.evemu)) {
+		fprintf(stderr, "error: unsupported device\n");
+		return -1;
+	}
+
+	fprintf(stderr, "device: %s\n", evemu_get_name(test.evemu));
+
+	if (!fp && init_mtdev(&test, fd)) {
+		fprintf(stderr, "error: could not init mtdev\n");
+		return -1;
+	}
+	if (init_frame(&test, fd)) {
+		fprintf(stderr, "error: could not init frame\n");
+		return -1;
+	}
+	if (init_grail(&test)) {
+		fprintf(stderr, "error: could not init grail\n");
+		return -1;
+	}
+
+	report_device_caps(&test);
+
+	loop_device(&test, fp, fd);
+
+	destroy_all(&test);
+
+	if (fs.st_rdev)
+		ioctl(fd, EVIOCGRAB, 0);
+	return 0;
+}

=== added file 'tools/grail-transform.c'
--- tools/grail-transform.c	1970-01-01 00:00:00 +0000
+++ tools/grail-transform.c	2011-03-29 08:01:03 +0000
@@ -0,0 +1,374 @@
+/*****************************************************************************
+ *
+ * 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 "config.h"
+#include <evemu.h>
+#include <utouch/frame-mtdev.h>
+#include <utouch/frame-xi2.h>
+#include <grail.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <math.h>
+
+struct appdata {
+	int opcode;
+	struct grail_coord min, max;
+	int fd;
+	struct evemu_device *evemu;
+	struct mtdev *mtdev;
+	utouch_frame_handle fh;
+	struct grail *ge;
+
+	struct grail_coord pos[4];
+	struct grail_coord touch[32];
+	struct grail_coord pivot;
+	XPoint pts[5];
+	int scaling;
+	int ntouch;
+
+	Display *dsp;
+	Window win;
+	GC gc;
+	int screen;
+	float off_x, off_y;
+	unsigned long white, black;
+};
+
+static void clear_screen(struct appdata *w)
+{
+	const struct utouch_surface *s = utouch_frame_get_surface(w->fh);
+	int width = s->mapped_max_x - s->mapped_min_x;
+	int height = s->mapped_max_y - s->mapped_min_y;
+	int i;
+
+	XSetForeground(w->dsp, w->gc, w->white);
+	XFillRectangle(w->dsp, w->win, w->gc, 0, 0, width, height);
+
+	for (i = 0; i < 5; i++) {
+		w->pts[i].x = w->pos[i % 4].x - w->off_x;
+		w->pts[i].y = w->pos[i % 4].y - w->off_y;
+	}
+
+	XSetForeground(w->dsp, w->gc, w->black);
+	XDrawLines(w->dsp, w->win, w->gc, w->pts, 5, CoordModeOrigin);
+
+}
+
+static void draw_object(struct appdata *w)
+{
+	static const double frac = 0.01;
+	const struct utouch_surface *s = utouch_frame_get_surface(w->fh);
+	double d = frac * (s->mapped_max_x - s->mapped_min_x);
+	int i;
+
+	XDrawLines(w->dsp, w->win, w->gc, w->pts, 5, CoordModeOrigin);
+
+	if (w->scaling)
+		XFillArc(w->dsp, w->win, w->gc,
+			 w->pivot.x - d / 2, w->pivot.y - d / 2,
+			 d, d, 0, 360 * 64);
+
+	d *= 4;
+	for (i = 0; i < w->ntouch; i++)
+		XFillArc(w->dsp, w->win, w->gc,
+			 w->touch[i].x - d / 2, w->touch[i].y - d / 2,
+			 d, d, 0, 360 * 64);
+}
+
+static void report_frame(struct appdata *w,
+			 const struct utouch_frame *touch)
+{
+	const struct grail_control *ctl = grail_get_control(w->ge);
+	const struct grail_frame *frame;
+	const struct grail_element *slot;
+	struct grail_coord tmp;
+	int i;
+
+	if (!touch)
+		return;
+
+	frame = grail_pump_frame(w->ge, touch);
+	if (!frame || !frame->num_ongoing || !frame->prev->num_ongoing)
+		return;
+
+	slot = frame->ongoing[frame->num_ongoing - 1];
+	if (slot->transform[0] == 0 && slot->transform[1] == 0)
+		return;
+
+	for (i = 0; i < 4; i++) {
+		grail_element_transform(slot, &tmp, &w->pos[i]);
+		w->pos[i] = tmp;
+	}
+
+	XSetForeground(w->dsp, w->gc, w->white);
+	draw_object(w);
+
+	w->ntouch = touch->num_active;
+	for (i = 0; i < w->ntouch; i++) {
+		w->touch[i].x = touch->active[i]->x - w->off_x;
+		w->touch[i].y = touch->active[i]->y - w->off_y;
+	}
+
+	w->scaling = slot->moveness < ctl->thresh_scale;
+	w->pivot.x = slot->pivot.x - w->off_x;
+	w->pivot.y = slot->pivot.y - w->off_y;
+
+	for (i = 0; i < 5; i++) {
+		w->pts[i].x = w->pos[i % 4].x - w->off_x;
+		w->pts[i].y = w->pos[i % 4].y - w->off_y;
+	}
+
+	XSetForeground(w->dsp, w->gc, w->black);
+	draw_object(w);
+
+	XFlush(w->dsp);
+}
+
+static int init_window(struct appdata *w)
+{
+	int event, err;
+
+	w->pos[0].x = 100;
+	w->pos[0].y = 100;
+	w->pos[1].x = 200;
+	w->pos[1].y = 100;
+	w->pos[2].x = 200;
+	w->pos[2].y = 200;
+	w->pos[3].x = 100;
+	w->pos[3].y = 200;
+
+	w->dsp = XOpenDisplay(NULL);
+	if (!w->dsp)
+		return -1;
+	if (!XQueryExtension(w->dsp, "XInputExtension",
+			     &w->opcode, &event, &err))
+		return -1;
+
+	w->screen = DefaultScreen(w->dsp);
+	w->white = WhitePixel(w->dsp, w->screen);
+	w->black = BlackPixel(w->dsp, w->screen);
+
+	w->win = XCreateSimpleWindow(w->dsp, XDefaultRootWindow(w->dsp),
+				     0, 0, 600, 600, 0, w->black, w->white);
+	w->gc = DefaultGC(w->dsp, w->screen);
+
+	XMapWindow(w->dsp, w->win);
+	XFlush(w->dsp);
+
+	return 0;
+}
+
+static void term_window(struct appdata *w)
+{
+	XDestroyWindow(w->dsp, w->win);
+	XCloseDisplay(w->dsp);
+}
+
+static void set_screen_size_mtdev(struct appdata *w, XEvent *xev)
+{
+	struct utouch_surface *s = utouch_frame_get_surface(w->fh);
+	XConfigureEvent *cev = (XConfigureEvent *)xev;
+
+	s->mapped_min_x = 0;
+	s->mapped_min_y = 0;
+	s->mapped_max_x = DisplayWidth(w->dsp, w->screen);
+	s->mapped_max_y = DisplayHeight(w->dsp, w->screen);
+	s->mapped_max_pressure = 1;
+
+	if (cev) {
+		w->off_x = cev->x;
+		w->off_y = cev->y;
+	}
+}
+
+static void loop_device_mtdev(struct appdata *w)
+{
+	const struct utouch_frame *tf;
+	struct input_event iev;
+	XEvent xev;
+
+	clear_screen(w);
+
+	set_screen_size_mtdev(w, 0);
+	XSelectInput(w->dsp, w->win, StructureNotifyMask);
+
+	while (1) {
+		while (!mtdev_idle(w->mtdev, w->fd, 100)) {
+			while (mtdev_get(w->mtdev, w->fd, &iev, 1) > 0) {
+				tf = utouch_frame_pump_mtdev(w->fh, &iev);
+				report_frame(w, tf);
+			}
+		}
+		while (XPending(w->dsp)) {
+			XNextEvent(w->dsp, &xev);
+			set_screen_size_mtdev(w, &xev);
+		}
+	}
+}
+
+static int run_mtdev(struct appdata *w, const char *path)
+{
+	w->fd = open(path, O_RDONLY | O_NONBLOCK);
+	if (w->fd < 0) {
+		fprintf(stderr, "error: could not open device\n");
+		return -1;
+	}
+	if (ioctl(w->fd, EVIOCGRAB, 1)) {
+		fprintf(stderr, "error: could not grab the device\n");
+		return -1;
+	}
+
+	w->evemu = evemu_new(NULL);
+	if (!w->evemu)
+		return -1;
+	if (evemu_extract(w->evemu, w->fd))
+		return -1;
+	w->mtdev = mtdev_new_open(w->fd);
+	if (!w->mtdev)
+		return -1;
+	w->fh = utouch_frame_new_engine(500, 32, 100);
+	if (!w->fh)
+		return -1;
+	if (utouch_frame_init_mtdev(w->fh, w->evemu))
+		return -1;
+	w->ge = grail_new(w->fh, 100, 0);
+	if (!w->ge)
+		return -1;
+
+	grail_get_control(w->ge)->drop_x_ms = 1e8;
+	grail_get_control(w->ge)->drop_y_ms = 1e8;
+	grail_get_control(w->ge)->drop_scale_ms = 1e8;
+	grail_get_control(w->ge)->drop_angle_ms = 1e8;
+
+	loop_device_mtdev(w);
+
+	grail_delete(w->ge);
+	utouch_frame_delete_engine(w->fh);
+	mtdev_close_delete(w->mtdev);
+	evemu_delete(w->evemu);
+
+	ioctl(w->fd, EVIOCGRAB, 0);
+	close(w->fd);
+}
+
+#if HAVE_XI
+static void loop_device_xi2(struct appdata *w, int id)
+{
+	const struct utouch_frame *tf;
+	XIEventMask mask;
+
+	mask.deviceid = id;
+	mask.mask_len = XIMaskLen(XI_LASTEVENT);
+	mask.mask = calloc(mask.mask_len, sizeof(char));
+
+	XISetMask(mask.mask, XI_TouchBegin);
+	XISetMask(mask.mask, XI_TouchUpdate);
+	XISetMask(mask.mask, XI_TouchEnd);
+	XISetMask(mask.mask, XI_PropertyEvent);
+	XISelectEvents(w->dsp, w->win, &mask, 1);
+
+	XSelectInput(w->dsp, DefaultRootWindow(w->dsp), StructureNotifyMask);
+
+	while (1) {
+		XEvent ev;
+		XIDeviceEvent *event = (void *)&ev;
+		XGenericEventCookie *cookie = &ev.xcookie;
+		XNextEvent(w->dsp, &ev);
+
+		if (XGetEventData(w->dsp, cookie) &&
+		    cookie->type == GenericEvent &&
+		    cookie->extension == w->opcode) {
+			tf = utouch_frame_pump_xi2(w->fh, cookie->data);
+			report_frame(w, tf);
+		}
+		XFreeEventData(w->dsp, cookie);
+	}
+
+}
+
+static int run_xi2(struct appdata *w, int id)
+{
+	XIDeviceInfo *info, *dev;
+	int ndevices, i;
+
+	info = XIQueryDevice(w->dsp, XIAllDevices, &ndevices);
+	dev = 0;
+	for (i = 0; i < ndevices; i++)
+		if (info[i].deviceid == id)
+			dev = &info[i];
+	if (!dev)
+		return -1;
+
+	w->fh = utouch_frame_new_engine(500, 32, 100);
+	if (!w->fh)
+		return -1;
+	if (utouch_frame_init_xi2(w->fh, w->dsp, dev))
+		return -1;
+	w->ge = grail_new(w->fh, 100, 0);
+	if (!w->ge)
+		return -1;
+
+	loop_device_xi2(w, id);
+
+	grail_delete(w->ge);
+	utouch_frame_delete_engine(w->fh);
+
+	XIFreeDeviceInfo(info);
+
+	return 0;
+}
+#else
+static int run_xi2(struct appdata *w, int id)
+{
+	fprintf(stderr, "X not supported in this build (use --with-xi)\n");
+	return 0;
+}
+#endif
+
+int main(int argc, char **argv)
+{
+	struct appdata w;
+	int id, ret;
+
+	if (argc < 2) {
+		fprintf(stderr, "Usage: %s <device>\n", argv[0]);
+		return -1;
+	}
+
+	memset(&w, 0, sizeof(w));
+
+	if (init_window(&w))
+		return -1;
+
+	id = atoi(argv[1]);
+
+	if (id)
+		ret = run_xi2(&w, id);
+	else
+		ret = run_mtdev(&w, argv[1]);
+
+	term_window(&w);
+
+	return ret;
+}

=== modified file 'utouch-grail.sym.in'
--- utouch-grail.sym.in	2011-01-02 12:08:42 +0000
+++ utouch-grail.sym.in	2011-03-29 08:01:03 +0000
@@ -1,13 +1,19 @@
 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