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

[Henrik Rydberg]

New grail2 branch, rebased to current trunk. This version addresses these points:

* Added reference to Lagrange relaxation and some more comments to the documentation

* Treats center and drag separately in the expectation mask

* Adds the option of using an unbounded pivot

Since this branch only contains additions and the new tools for testing, I suggest we merge this into trunk now, so that we can concentrate on the modifications needed for the grail2-to-grail1 glue.

[Henrik Rydberg (rydberg)]

Another rebase, triggered by stuff that went into trunk already. Gesture documentation augmentation folded into this series as well.

[Chase Douglas (chasedouglas)]

Henrik,

I'm feeling really good about the architecture of the code. I still have questions about some of the math, but I'll leave that aside for now ;-)

I like the new transform tool quite a bit though; it really helps visualize what is going on.

Initially, I had lots more questions, but my investigations have answered most of those. Here are the remaining comments/questions I have:

* What would you think about passing around complete 3x3 matrices instead of the 3x2 simplified matrices that grail 2 emits right now? If we did something like this, a 3x3 matrix could be thrown into many transformation libraries, like pixman, without any conversion.

* In set_slot_multi(), the touches are deep copied into the grail_element slot. In the other set_slot_*() functions, the touches are shallow copied from the passed in utouch frame. It seems that it would be best for the usage model to be consistent between all the functions... is this left-over from a change, or is there a definite rationale for the difference?

* grail_pump_frame() returns a reference to a new grail frame. The utouch frame may be retrieved by calling grail_get_contact_frame(). How do we know that the utouch contact prev pointer in the returned utouch frame is still valid? It may become invalid as soon as utouch_frame is
pumped. I don't think this could cause a bug if the code calls the frame and grail methods appropriately. However, we could run into issues with folks doing things in odd ways, since the code is non-re-entrant. For instance, if anyone needs to do parallel programming with this interface
it could get very dicey. At the very least, we should add a note in grail.h that the utouch frame data is only valid until the utouch frame is pumped again.

One thing that may help is to add a utouch_frame function that can retrieve the previous frame, if available, instead of giving the client a pointer to memory that may end up modified over time. An even better alternative would be to have reference counting of frames, but that would be a larger architecture change to utouch frame. Do you have any thoughts here?

* Touch gestures seem to be missing from grail 2.

Overall, I'm feeling pretty good about the changes. As I now understand it, the extra freedom of choosing an appropriate pivot point may allow for better touch mapping as well. I really like the work overall!

As a side note, when we go to merge this Duncan has asked that we merge it into a separate series until at least all the dependent pieces are in place to not lose functionality. I set up the lp:utouch-grail/2.x series for this purpose. Once we have this and the next merge proposals approved we can look into merging it into trunk.

Thanks!

review: Needs Fixing

[Henrik Rydberg (rydberg)]

Hi Chase,

thanks for your comments!

* Sending 3x3 matrices

The elements store 2x3 for memory reasons. The recipe to create the full 3x3 matrix is simple, so I would prefer to leave it as is.

* Deep copy

All functions copy the pointers, there is no deep copy anywhere. Perhaps the memcpy() in set_slot_multi caused the confusion.

* Pumping

The utouch frames are constructed as a fixed ring, so all pointers are always valid, although they will pointer to the "wrong" data after a while when the data wraps around.

The semantics around prev points could be improved upon, as you suggest. There was originally an idea that a gesture frame could span several touch frames, hence the extra logic around prev pointers for those. The reason for the idea was to be able to skip frames with "unstable" touch configurations, using the glue time. However, since then, this stabilization logic has been moved to
the actual gesture fragment activation, and it seems to me one could again simplify the semantics and say that every touch frame corresponds to a gesture frame. Any thoughts on that?

Regardless of the above, the get_frame methods could be further specified to only be well defined from a callback, for instance. In all other instances, the pointers are known anyways, from the flow of the code.

* Touch gestures

It works in this end, when running grail-gesture

* Merging

The grail2 branch i feel is pretty well tested, so that could in principle go to trunk. It only contains additions, no replacements. No biggie if we do the series for this as well, that is fine. Perhaps the series should be called 1.1, though, since be are not breaking ABI?

The grail2.next branch is not fully complete, agreed. There are test cases missing to guard the replacement patches. Minor behavior changes might also need to be checked and defined. Also, I am working on yet another simplification of the code, that should get rid of two of the three event buffers in use.

So yes, merging everything into a new series sounds good.

Tbanks!

[Jussi Pakkanen (jpakkane)]

Gnome's versions of MIN and MAX macros have one more set of parentheses around the condition:

http://developer.gnome.org/glib/stable/glib-Standard-Macros.html

That is, they use

#define MIN(a, b) (((a) < (b)) ? (a) : (b))

rather than

#define MIN(a, b) ((a) < (b) ? (a) : (b))

I can't see how this could lead to errors, but that's the way they do it.

[Henrik Rydberg (rydberg)]

Hm... it _looks_ like code that does not trust the operator precedence rules. Thanks for the information, anyways. I think we can safely go with our version. A further interesting example can be found in include/linux/kernel.h, where temporary variables are used.

[Chase Douglas (chasedouglas)]

I think the best course of action right now is to merge the changes so we can move on. We can resolve any issues with fixes moving forward.

I still have issues with the code that is in the unstable ppa. Until we get those fixed I would rather not merge the code directly into trunk. For now, lets merge this into lp:utouch-grail/2.x, and once we're sure all regressions are fixed we can redirect the lp:utouch-grail series to lp:utouch-grail/2.x.

(I've updated lp:utouch-grail/2.x to be in sync with lp:utouch-grail).

review: Approve

[Henrik Rydberg (rydberg)]

It was a bit of work for all of us to get this one in, now that it is done, thank you.

I will update 2.x to this point also, and remake the remaining branches.

Cheers!

=== added file 'AUTHORS'
--- AUTHORS	1970-01-01 00:00:00 +0000
+++ AUTHORS	2011-04-28 16:58:23 +0000
@@ -0,0 +1,1 @@
+Henrik Rydberg <[e-mail]>

=== modified file 'configure.ac'
--- configure.ac	2011-04-27 08:13:32 +0000
+++ configure.ac	2011-04-28 16:58:23 +0000
@@ -12,7 +12,7 @@
 AM_INIT_AUTOMAKE([foreign dist-bzip2])
 AM_MAINTAINER_MODE
 
-LIB_VERSION=1:0:0
+LIB_VERSION=2:0:1
 AC_SUBST([LIB_VERSION])
 
 # Initialize libtool
@@ -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-04-28 16:58:23 +0000
@@ -0,0 +1,58 @@
+Introduction
+------------
+
+This document describes how the gestures are extracted from multi-finger
+actions. The process is divided into gestural transformations, gesture
+recognition, and gesture instantiation.
+
+Gestural Transformations
+------------------------
+
+All two-finger transformations are extracted. These are all exact, in the
+sense that continuously transforming the original finger positions, frame
+per frame, will exactly follow the actual finger positions.
+
+In addition to two-finger transformations, a global gesture is also
+extracted. The rotation and scaling is taken from the contact pair with the
+longest distance between contacts. This approximates the behavior of a
+region, such that complex transformations could, in principle, be happening
+inside the region, but at a distance, the transformation will look like it
+was performed with two fingers.
+
+At each time step, a gestural transformation is goverened by rotation,
+scaling and translation. The point around which rotation and scaling is
+performed is called the pivot. To form as natural gestures as possible,
+this point always lies within the area formed by the contacts themselves.
+It is placed at the point which, after rotation and scaling, leaves the
+transformed contacts as close to the actual positions as possible.  The
+translation, or drag, is always a fraction of the movement of the center
+point. The fraction is called moveness, and is related to the distance
+between the pivot and the center point. When the pivot is at the center
+point, the moveness is one and the drag is the same as the center movement.
+When the pivot is at one of the contacts, as in rotation around a finger,
+the moveness is zero, and consequently the drag is zero.  The relations
+between the pivot, the moveness and the drag are detailed in the document
+pivot.txt.
+
+Gesture Recognition
+-------------------
+
+Each gestural transformation can give rise to one or several gesture
+primitives. Based on the rotation, scaling, moveness and drag values, the
+gesture primitives drag, pinch and rotate are recognized. The onset of a
+gesture primitive is governed by a threshold and a timeout. Basically, if
+performed distinctly enough, the gesture will be triggered, and will remain
+active until a finger is lifted or added.
+
+Gesture Instantiation
+---------------------
+
+Given a set of detected gesture primitives, only some will trigger actual
+gesture events. First, the set of available primitives are matched against
+available listeners. Primitives not listened for are dropped. The remaining
+set is arranged according to priority. A pointer gesture has lower priority
+than a two-finger gesture, which has lower priority than a tap, for
+instance. As long as the gesture primitives of higher priority are expected
+but not activated, all gestures are held back. Once one of the highest
+priority primitives are activated, all primitives of lower priority are
+cancelled, and events are emitted.

=== added file 'docs/pivot.txt'
--- docs/pivot.txt	1970-01-01 00:00:00 +0000
+++ docs/pivot.txt	2011-04-28 16:58:23 +0000
@@ -0,0 +1,146 @@
+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 [1] 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.
+
+[1] See Lagrange relaxation

=== modified file 'include/grail-bits.h'
--- include/grail-bits.h	2011-04-27 16:12:36 +0000
+++ include/grail-bits.h	2011-04-28 16:58:23 +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-04-28 16:58:23 +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	2011-04-27 16:12:36 +0000
+++ include/grail.h	2011-04-28 16:58:23 +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
@@ -26,11 +25,14 @@
 #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)
 
@@ -41,8 +43,30 @@
 #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_CENTER_X	0x0001
+#define GRAIL_EXPECT_CENTER_Y	0x0002
+#define GRAIL_EXPECT_DRAG_X	0x0004
+#define GRAIL_EXPECT_DRAG_Y	0x0008
+#define GRAIL_EXPECT_SCALE	0x0010
+#define GRAIL_EXPECT_ANGLE	0x0020
+#define GRAIL_EXPECT_MASK	0x003f
+
+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
@@ -53,32 +77,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_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
@@ -106,6 +161,143 @@
 };
 
 /**
+ * struct grail_control - control parameters of grail
+ * @glue_ms: minimum time to hold activation (ms)
+ * @bar_center_x: horizontal distance to activate (surface width fraction)
+ * @bar_center_y: vertical distance to activate (surface height fraction)
+ * @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)
+ * @pivot_unbound: when true, the pivot is not bound to the contact area
+ *
+ * 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_center_x;
+	float bar_center_y;
+	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;
+	int pivot_unbound;
+};
+
+/**
+ * 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
+ * @start_center: center position at start of transform (surface units)
+ * @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;
+	struct grail_coord start_center;
+	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
@@ -231,19 +423,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_PUBLIC 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
@@ -259,17 +438,43 @@
 				  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_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
+
 #ifdef __cplusplus
 }
 #endif

=== added file 'include/grail.h.orig'
--- include/grail.h.orig	1970-01-01 00:00:00 +0000
+++ include/grail.h.orig	2011-04-28 16:58:23 +0000
@@ -0,0 +1,277 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2010 Canonical Ltd.
+ * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#ifndef _GRAIL_H
+#define _GRAIL_H
+
+#include <linux/input.h>
+#include <grail-bits.h>
+#include <grail-types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#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
+
+typedef float grail_prop_t;		/* gesture properties */
+typedef __u64 grail_time_t;		/* time in milliseconds */
+
+/**
+ * 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;
+};
+
+/**
+ * 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;
+};
+
+/**
+ * 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_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_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_PUBLIC 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
+ * @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_contacts - get current contact state
+ * @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.
+ *
+ */
+int GRAIL_PUBLIC grail_get_contacts(const struct grail *ge,
+				    struct grail_contact *touch, int max_touch);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2011-04-27 16:12:36 +0000
+++ src/Makefile.am	2011-04-28 16:58:23 +0000
@@ -25,7 +25,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
 
 # These are flags required to properly set up
 # the build. -fvisibility requires GCC > 4 (or clang)

=== modified file 'src/evbuf.h'
--- src/evbuf.h	2011-02-24 22:50:31 +0000
+++ src/evbuf.h	2011-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 08:20:04 +0000
+++ src/grail-api.c	2011-04-28 16:58:23 +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>
@@ -35,10 +34,9 @@
 #define DIM_FRAMES 100
 #define FRAME_RATE 100
 
-void GRAIL_PUBLIC grail_filter_abs_events(struct grail *ge, int usage)
+unsigned int GRAIL_PUBLIC grail_get_version(void)
 {
-	struct grail_impl *x = ge->impl;
-	x->filter_abs = usage;
+	return GRAIL_VERSION;
 }
 
 int GRAIL_PUBLIC grail_open(struct grail *ge, int fd)
@@ -152,6 +150,12 @@
 	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;
@@ -221,15 +225,15 @@
 }
 
 static void report_frame(struct grail *ge,
-			 const struct utouch_frame *frame,
+			 const struct utouch_frame *touch,
 			 const struct input_event *syn)
 {
 	struct grail_impl *impl = ge->impl;
 	struct grail_event gev;
 
-	ge->impl->frame = frame;
+	impl->touch = touch;
 
-	if (frame->num_active && !frame->prev->num_active) {
+	if (touch->num_active && !touch->prev->num_active) {
 		impl->ongoing = 1;
 		impl->gesture = 0;
 	}
@@ -237,14 +241,14 @@
 	if (!impl->ongoing)
 		return;
 
-	gin_frame_begin(ge, frame);
-	gru_recognize(ge, frame);
-	gin_frame_end(ge, frame);
+	gin_frame_begin(ge, touch);
+	gru_recognize(ge, touch);
+	gin_frame_end(ge, touch);
 
 	if (!grailbuf_empty(&impl->gbuf))
 		impl->gesture = 1;
 
-	if (frame->num_active == 0 || gesture_timeout(ge, frame))
+	if (touch->num_active == 0 || gesture_timeout(ge, touch))
 		impl->ongoing &= impl->gesture;
 }
 

=== modified file 'src/grail-bits.c'
--- src/grail-bits.c	2011-04-27 16:12:36 +0000
+++ src/grail-bits.c	2011-04-28 16:58:23 +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-04-27 08:13:32 +0000
+++ src/grail-event.c	2011-04-28 16:58:23 +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_PUBLIC 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-04-28 16:58:23 +0000
@@ -0,0 +1,398 @@
+/*****************************************************************************
+ *
+ * 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_control *ctl = impl->ctl;
+	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 q = (mx * mx + my * my) / w2;
+			double s = ctl->pivot_unbound ?
+				q : sqrt(pslot->radius2 / 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);
+	slot->start_center = slot->center;
+	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->start_time = pslot->start_time;
+	slot->start_center = pslot->start_center;
+	slot->expect_mask = pslot->expect_mask;
+	slot->active_mask = pslot->active_mask;
+
+	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)
+{
+	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->start_center = pslot->start_center;
+	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->moveness = 1;
+	slot->pivot = pslot->pivot;
+	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]);
+}
+
+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 c_x = ctl->bar_center_x * (s->mapped_max_x - s->mapped_min_x);
+	float c_y = ctl->bar_center_y * (s->mapped_max_y - s->mapped_min_y);
+	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;
+
+		dt = touch->time - s->start_time;
+		if (dt > ctl->glue_ms) {
+			unsigned int mask = s->active_mask;
+
+			if (fabs(s->center.x - s->start_center.x) > c_x)
+				mask |= GRAIL_EXPECT_CENTER_X;
+			if (fabs(s->center.y - s->start_center.y) > c_y)
+				mask |= GRAIL_EXPECT_CENTER_Y;
+			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_CENTER_X;
+			if (dt < ctl->drop_y_ms)
+				mask |= GRAIL_EXPECT_CENTER_Y;
+			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;
+}

=== modified file 'src/grail-gestures.c'
--- src/grail-gestures.c	2011-04-07 20:46:30 +0000
+++ src/grail-gestures.c	2011-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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->bar_center_x = 0.03;
+	c->bar_center_y = 0.03;
+	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;
+	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_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;
+}

=== modified file 'src/grail-inserter.c'
--- src/grail-inserter.c	2011-04-28 08:20:04 +0000
+++ src/grail-inserter.c	2011-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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_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 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-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 16:58:23 +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-04-28 08:20:04 +0000
+++ tools/grail-gesture.c	2011-04-28 16:58:23 +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-04-28 16:58:23 +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->expect_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-04-28 16:58:23 +0000
@@ -0,0 +1,371 @@
+/*****************************************************************************
+ *
+ * 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 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);
+
+	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->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;
+}