Merge lp:~chasedouglas/grail/rework into lp:grail

[Chase Douglas]

The new grail implementation is ready! I don't feel like recapping the changes, you should be familiar with the general idea by now :). There are unit tests for the subscription object, and an integration test for a two-touch drag. Unfortunately, if you run the two-touch drag test under valgrind it is slowed down enough that timeouts occur that would not under normal operation. I'm still pondering how to handle this, but for now we must ignore failure under valgrind.

[lp:~chasedouglas/grail/rework]

291. By Chase Douglas on 2012-01-25

Merge from trunk

[Stephen M. Webb (bregma)]

I've been using this branch for geis development and testing, so I give it a general approval except for the following.

(1) The test suite gets built with a 'make all' target, which is not usual procedure. The Makefile.am in the test subdirectory should use a check_PROGRAMS target and not a noinst_PROGRAMS target.

(2) There is no way to disable building the test suite if xorg-gtest is installed on your system, and the test suite fails to build if the --with-xi argument is not given to ./configure.

(3) The TwoDrag test fails throwing a "Failed to open device file" exception. It looks like the test data is missing from the repo.

review: Needs Fixing

[lp:~chasedouglas/grail/rework]

292. By Chase Douglas on 2012-01-25

Add recordings needed for testing

293. By Chase Douglas on 2012-01-25

Build testsuite at "make check" time

294. By Chase Douglas on 2012-01-25

Fix build for HAVE_XI conditional

[Chase Douglas (chasedouglas)]

> I've been using this branch for geis development and testing, so I give it a
> general approval except for the following.
>
> (1) The test suite gets built with a 'make all' target, which is not usual
> procedure. The Makefile.am in the test subdirectory should use a
> check_PROGRAMS target and not a noinst_PROGRAMS target.

Fixed

> (2) There is no way to disable building the test suite if xorg-gtest is
> installed on your system, and the test suite fails to build if the --with-xi
> argument is not given to ./configure.

The entire build system was broken, so I fixed it all up.

> (3) The TwoDrag test fails throwing a "Failed to open device file" exception.
> It looks like the test data is missing from the repo.

Yep, I forgot to bzr add the recordings directory. It should work now.

[Stephen M. Webb (bregma)]

Yep. Good to go.

review: Approve

=== modified file 'Makefile.am'
--- Makefile.am	2011-01-02 12:06:04 +0000
+++ Makefile.am	2012-01-25 15:53:29 +0000
@@ -5,6 +5,36 @@
 
 INCLUDES = $(top_srcdir)/include/
 
+if HAVE_GCOV
+  .PHONY: coverage-html generate-coverage-html coverage-html-clean
+  coverage-html:
+	-$(MAKE) $(AM_MAKEFLAGS) -k check
+	$(MAKE) $(AM_MAKEFLAGS) generate-coverage-html
+
+  generate-coverage-html:
+	@echo Collecting coverage data
+	$(LCOV) --directory $(top_builddir) --base-directory src --capture --output-file coverage.info --no-checksum --compat-libtool
+	LANG=C $(GENHTML) --prefix $(top_builddir) --output-directory coveragereport --title "Code Coverage" --legend --show-details coverage.info
+
+  clean-coverage-html:
+	-$(LCOV) --directory $(top_builddir) -z
+	-rm -rf coverage.info coveragereport
+	-find $(top_builddir) -name '*.gcda' -print | xargs rm
+
+  .PHONY: coverage-xml generate-coverage-xml coverage-xml-clean
+  coverage-xml:
+	-$(MAKE) $(AM_MAKEFLAGS) -k check
+	$(MAKE) $(AM_MAKEFLAGS) generate-coverage-xml
+
+  generate-coverage-xml:
+	@echo Generating coverage XML report
+	$(MAKE) $(AM_MAKEFLAGS) clean-coverage-xml
+	$(GCOVR) -x -r $(top_builddir) -o $(top_builddir)/coverage.xml --object-directory=$(abs_builddir)/.libs
+
+  clean-coverage-xml:
+	-rm -rf $(top_builddir)/coverage.xml
+endif # HAVE_GCOV
+
 .PHONY: ChangeLog INSTALL
 INSTALL:
 	$(INSTALL_CMD)
 
=== modified file 'configure.ac'
--- configure.ac	2011-08-31 17:20:48 +0000
+++ configure.ac	2012-01-25 15:53:29 +0000
@@ -1,16 +1,21 @@
 # Initialize Autoconf
 AC_PREREQ([2.60])
 AC_INIT([Gesture Recognition And Instantiation Library],
-        [2.1.0],
+        [2.99.1],
         [],
         [utouch-grail])
 AC_CONFIG_SRCDIR([Makefile.am])
 AC_CONFIG_HEADERS([config.h])
 AC_CONFIG_AUX_DIR([config-aux])
+AC_CONFIG_MACRO_DIR([m4])
+
+m4_include([m4/gcov.m4])
+m4_include([m4/gtest.m4])
 
 # Initialize Automake
 AM_INIT_AUTOMAKE([foreign dist-bzip2])
-AM_MAINTAINER_MODE
+AM_SILENT_RULES([yes])
+AM_MAINTAINER_MODE([enable])
 
 LIB_VERSION=3:0:2
 AC_SUBST([LIB_VERSION])
@@ -20,11 +25,12 @@
 
 # Checks for programs.
 AC_PROG_CC
+AC_PROG_CXX
 AC_PROG_INSTALL
 
 PKG_CHECK_MODULES([MTDEV], [mtdev >= 1.1])
 PKG_CHECK_MODULES([EVEMU], [utouch-evemu >= 1.0.5])
-PKG_CHECK_MODULES([FRAME], [utouch-frame >= 1.2])
+PKG_CHECK_MODULES([FRAME], [utouch-frame >= 1.9.0])
 
 AC_ARG_WITH([xi], AS_HELP_STRING([--with-xi], [Build with XI2.1 support]))
 AM_CONDITIONAL([HAVE_XI], [test "x$with_xi" != "x"])
@@ -33,19 +39,37 @@
    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],
-                  AC_MSG_WARN([package 'check' not found: tests disabled]))
-AM_CONDITIONAL([HAVE_CHECK],[test "x$have_check" = xyes])
-
+AC_CHECK_GTEST
+
+AS_IF([test "x$have_gtest" = xyes],
+    [PKG_CHECK_MODULES(XORG_GTEST, xorg-gtest,
+        [have_xorg_gtest="yes"],
+        [AC_MSG_WARN([xorg-gtest not installed, tests will not be built])])],
+    [AC_MSG_WARN([gtest not installed, tests will not be build])]
+)
+
+AM_CONDITIONAL([HAVE_GTEST], [test "x$have_xorg_gtest" = xyes])	
+                 
+AC_SUBST([GTEST_LDFLAGS])	
+AC_SUBST([GTEST_CXXFLAGS])
+
+# Enable coverage reports using gcov
+AC_TDD_GCOV
+
+AM_CONDITIONAL([HAVE_GCOV],[test "x$ac_cv_check_gcov" = xyes])
+ 
 AC_CONFIG_FILES([Makefile
                  src/Makefile
                  tools/Makefile
                  test/Makefile
                  utouch-grail.pc])
 
-AC_SUBST(AM_CPPFLAGS, "-Wall -Werror")
+AC_SUBST(AM_CPPFLAGS, "-DBUILDING_GRAIL $GTEST_CPPFLAGS")
+AC_SUBST(AM_CFLAGS, "-fvisibility=hidden -Wall -Werror $COVERAGE_CFLAGS")
+AC_SUBST(AM_CXXFLAGS, "-std=c++0x $COVERAGE_CXXFLAGS $GTEST_CXXFLAGS")
+AC_SUBST(AM_LDFLAGS, "$COVERAGE_LDFLAGS $GTEST_LDFLAGS")
 
 AC_OUTPUT
 
 
=== added directory 'include/utouch'
=== added file 'include/utouch/grail.h'
--- include/utouch/grail.h	1970-01-01 00:00:00 +0000
+++ include/utouch/grail.h	2012-01-25 15:53:29 +0000
@@ -0,0 +1,685 @@
+/*****************************************************************************
+ *
+ * utouch-grail - Multitouch Gesture Recognition 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/>.
+ *
+ ****************************************************************************/
+
+/**
+ * @file utouch/grail.h
+ * Definitions of the main and platform-generic API
+ */
+
+#ifndef UTOUCH_GRAIL_UTOUCH_GRAIL_H_
+#define UTOUCH_GRAIL_UTOUCH_GRAIL_H_
+
+#include <stdint.h>
+
+#include <utouch/frame.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup v3 uTouch-Grail 3.x
+ * @{
+ */
+
+/** An object for the context of the uTouch Frame instance */
+typedef struct UGHandle_* UGHandle;
+/** An object for a gesture subscription */
+typedef struct UGSubscription_* UGSubscription;
+/** An object for an event */
+typedef struct UGEvent_* UGEvent;
+/** An object for a gesture state in time */
+typedef const struct UGSlice_* UGSlice;
+
+/** The status code denoting the result of a function call */
+typedef enum UGStatus {
+  UGStatusSuccess = 0, /**< The call was successful */
+  UGStatusErrorGeneric, /**< A platform-dependent error occurred */
+  UGStatusErrorResources, /**< An error occurred due to insufficient resources */
+  UGStatusErrorNoEvent, /**< No events were available to get */
+  UGStatusErrorUnknownProperty, /**< The requested property value was not set */
+  UGStatusErrorInvalidValue, /**< The property value passed in is invalid */
+  UGStatusErrorInvalidDevice, /**< The requested device does not exist */
+  UGStatusErrorInvalidSubscription, /**< The subscription is invalid */
+  UGStatusErrorInvalidGesture, /**< The requested gesture does not exist */
+  UGStatusErrorInvalidIndex, /**< The requested touch index is invalid */
+  UGStatusErrorAtomicity, /**< The subscription has a different value for 
+                               UGSubscriptionPropertyAtomicGestures than other
+                               subscriptions active on the window */
+} UGStatus;
+
+/** Subscription properties */
+typedef enum UGSubscriptionProperty {
+  /**
+   * Device to subscribe to gesture events for
+   *
+   * Value type: UFDevice
+   */
+  UGSubscriptionPropertyDevice,
+  /**
+   * Window to subscribe to gesture events for
+   *
+   * Value type: UFWindowId
+   */
+  UGSubscriptionPropertyWindow,
+  /**
+   * Gesture types to subscribe for
+   *
+   * Value type: UGGestureTypeMask
+   */
+  UGSubscriptionPropertyMask,
+  /**
+   * Number of touches required to begin gesture
+   *
+   * Value type: unsigned int
+   */
+  UGSubscriptionPropertyTouchesStart,
+  /**
+   * Minimum number of touches for gesture
+   *
+   * Value type: unsigned int
+   */
+  UGSubscriptionPropertyTouchesMinimum,
+  /**
+   * Maximum number of touches for gesture
+   *
+   * Value type: unsigned int
+   */
+  UGSubscriptionPropertyTouchesMaximum,
+  /**
+   * Timeout for recognizing a drag gesture
+   *
+   * Value type: 64-bit unsigned integer
+   */
+  UGSubscriptionPropertyDragTimeout,
+  /**
+   * Threshold value for recognizing a drag gesture
+   *
+   * Value type: float
+   */
+  UGSubscriptionPropertyDragThreshold,
+  /**
+   * Timeout for recognizing a pinch gesture
+   *
+   * Value type: 64-bit unsigned integer
+   */
+  UGSubscriptionPropertyPinchTimeout,
+  /**
+   * Threshold value for recognizing a pinch gesture
+   *
+   * Value type: float
+   */
+  UGSubscriptionPropertyPinchThreshold,
+  /**
+   * Timeout for recognizing a rotate gesture
+   *
+   * Value type: 64-bit unsigned integer
+   */
+  UGSubscriptionPropertyRotateTimeout,
+  /**
+   * Threshold value for recognizing a rotate gesture
+   *
+   * Value type: float
+   */
+  UGSubscriptionPropertyRotateThreshold,
+  /**
+   * Timeout for recognizing a tap gesture
+   *
+   * Value type: 64-bit unsigned integer
+   */
+  UGSubscriptionPropertyTapTimeout,
+  /**
+   * Threshold value for recognizing a tap gesture
+   *
+   * Value type: float
+   */
+  UGSubscriptionPropertyTapThreshold,
+  /**
+   * Only support one gesture at a time
+   *
+   * Value type: int with boolean semantics
+   *
+   * The first version of uTouch-Grail supported only one gesture at a time.
+   * When this property is true, uTouch-Grail will mimic this behavior. This
+   * results in the following:
+   *
+   * - The uTouch-Grail client must not attempt to accept or reject a gesture
+   * - If a gesture is active for a maximum of N touches, the addition of
+   *   another touch will end the gesture. A new gesture is begun if another
+   *   subscription's TouchesStart property equals the new number of touches.
+   * - All subscriptions for a window must have the same value for this
+   *   property. If a client attempts to activate a subscription with a
+   *   different value for this property than the already activated
+   *   subscriptions for the window, UGStatusErrorAtomicity will be returned.
+   *
+   * There is one key difference between uTouch-Grail v1 behavior and the use of
+   * this option. The v1 behavior only supported one gesture per device. The use
+   * of this option only supports one gesture per device per window. The
+   * beginning of a gesture in a window does not inhibit gestures in other
+   * windows. It also does not guarantee that there are no active touches
+   * outside the window.
+   */
+  UGSubscriptionPropertyAtomicGestures,
+} UGSubscriptionProperty;
+
+/** Event type */
+typedef enum UGEventType {
+  UGEventTypeSlice = 0, /**< A new gesture slice */
+} UGEventType;
+
+/** Event properties */
+typedef enum UGEventProperty {
+  /**
+   * Type of event
+   *
+   * Value type: UGEventType
+   */
+  UGEventPropertyType = 0,
+  /**
+   * Slice of a gesture
+   *
+   * Value type: UGSlice
+   */
+  UGEventPropertySlice,
+  /**
+   * Event time
+   *
+   * Value type: 64-bit unsigned int
+   *
+   * This property holds the time the event occurred in display server
+   * timespace. The time is provided in milliseconds (ms).
+   */
+  UGEventPropertyTime,
+} UGEventProperty;
+
+/** Gesture type bit indices */
+typedef enum UGGestureType {
+  UGGestureTypeDrag = 0x1, /**< Drag gesture */
+  UGGestureTypePinch = 0x2, /**< Pinch gesture */
+  UGGestureTypeRotate = 0x4, /**< Rotate gesture */
+  UGGestureTypeTap = 0x8, /**< Tap gesture */
+  UGGestureTypeTouch = 0x10, /**< Touch gesture */
+} UGGestureType;
+
+/** Bit-mask of gesture types */
+typedef uint32_t UGGestureTypeMask;
+
+/** 2D affine transformation */
+typedef const float UGTransform[3][3];
+
+/** Gesture slice state */
+typedef enum UGGestureState {
+  UGGestureStateBegin = 0, /**< Gesture slice begin */
+  UGGestureStateUpdate, /**< Gesture slice update */
+  UGGestureStateEnd, /**< Gesture slice end */
+} UGGestureState;
+
+/** Gesture slice properties */
+typedef enum UGSliceProperty {
+  /**
+   * Gesture ID
+   *
+   * Value type: unsigned int
+   */
+  UGSlicePropertyId = 0,
+  /**
+   * Gesture set state
+   *
+   * Value type: UGGestureState
+   */
+  UGSlicePropertyState,
+  /**
+   * Gesture subscription
+   *
+   * Value type: UGSubscription
+   */
+  UGSlicePropertySubscription,
+  /**
+   * Recognized gestures
+   *
+   * Value type: UGGestureTypeMask
+   */
+  UGSlicePropertyRecognized,
+  /**
+   * Number of touches
+   *
+   * Value type: unsigned int
+   */
+  UGSlicePropertyNumTouches,
+  /**
+   * Touch frame
+   *
+   * Value type: UFFrame
+   */
+  UGSlicePropertyFrame,
+  /**
+   * Original gesture center along the X axis
+   *
+   * Value type: float
+   *
+   * This value represents the original geometric center of the touches.
+   */
+  UGSlicePropertyOriginalCenterX,
+  /**
+   * Original gesture center along the Y axis
+   *
+   * Value type: float
+   *
+   * This value represents the original geometric center of the touches.
+   */
+  UGSlicePropertyOriginalCenterY,
+  /**
+   * Original radius of touches
+   *
+   * Value type: float
+   *
+   * This value represents the average of the square of the euclidean distance
+   * from the geometric center of the original touches to each touch.
+   */
+  UGSlicePropertyOriginalRadius,
+  /**
+   * Best-fit 2D affine transformation of previous to current touch locations
+   *
+   * Value type: pointer to UGTransform
+   *
+   * The transformation is relative to the previous geometric center of the
+   * touches.
+   */
+  UGSlicePropertyTransform,
+  /**
+   * Best-fit 2D affine transformation of original to current touch locations
+   *
+   * Value type: pointer to UGTransform
+   *
+   * The transformation is relative to the original geometric center of the
+   * touches.
+   */
+  UGSlicePropertyCumulativeTransform,
+  /**
+   * Best-fit instant center of rotation along the X axis
+   *
+   * Value type: float
+   */
+  UGSlicePropertyCenterOfRotationX,
+  /**
+   * Best-fit instant center of rotation along the Y axis
+   *
+   * Value type: float
+   */
+  UGSlicePropertyCenterOfRotationY,
+  /**
+   * Whether the construction of all gestures containing the same touches is
+   * finished
+   *
+   * Value type: int with boolean semantics
+   *
+   * Grail events are serial. This property allows the client to determine if
+   * all the possible gestures from the set of touches in this gesture have been
+   * sent. When this value is true, the client will have received all the
+   * information needed to make a gesture accept and reject decision based on
+   * potentially overlapping gestures. An example is when both one and two touch
+   * gestures are subscribed on the same window with the same gesture types and
+   * thresholds. When this property is true for one touch gesture events, the
+   * client can be sure there are no other touches unless a two touch gesture
+   * event has already been sent.
+   */
+  UGSlicePropertyConstructionFinished,
+} UGSliceProperty;
+
+/**
+ * Create a new grail context
+ *
+ * @param [in] frame_handle The uTouch frame context object
+ * @param [out] handle The new uTouch grail context object
+ * @return UGStatusSuccess or UGStatusErrorResources
+ */
+UGStatus grail_new(UFHandle frame_handle, UGHandle *handle);
+
+/**
+ * Delete a grail context
+ *
+ * @param [in] handle The uTouch Grail context object
+ */
+void grail_delete_v3(UGHandle handle);
+
+/**
+ * Get the event file descriptor for the uTouch Frame context
+ *
+ * @param [in] handle The uTouch Grail context object
+ * @return A file descriptor for the context
+ *
+ * When events are available for processing, the file descriptor will be
+ * readable. Perform an 8-byte read from the file descriptor to clear the state.
+ * Refer to the EVENTFD(2) man page for more details.
+ */
+int grail_get_fd(UGHandle handle);
+
+/**
+ * Create a new subscription object
+ *
+ * @param [out] subscription The new subscription object
+ * @return UGStatusSuccess or UGStatusErrorResources
+ */
+UGStatus grail_subscription_new(UGSubscription* subscription);
+
+/**
+ * Delete a subscription object
+ *
+ * @param [in] subscription The subscription object
+ */
+void grail_subscription_delete(UGSubscription subscription);
+
+/**
+ * Set a subscription property
+ *
+ * @param [in] subscription The subscription object
+ * @param [in] property The subscription property
+ * @param [in] value The new value of the property
+ * @return UGStatusSuccess or UGStatusInvalidProperty
+ */
+UGStatus grail_subscription_set_property(UGSubscription subscription,
+                                         UGSubscriptionProperty property,
+                                         const void* value);
+
+/**
+ * Get a subscription property
+ *
+ * @param [in] subscription The subscription object
+ * @param [in] property The subscription property
+ * @param [out] value The value of the property
+ * @return UGStatusSuccess or UGStatusInvalidProperty
+ */
+UGStatus grail_subscription_get_property(UGSubscription subscription,
+                                         UGSubscriptionProperty property,
+                                         void* value);
+
+/**
+ * Activate a subscription
+ *
+ * @param [in] handle The context object
+ * @param [in] subscription The subscription object
+ * @return UGStatusSuccess or UGStatusErrorInvalidDevice
+ */
+UGStatus grail_subscription_activate(UGHandle handle, UGSubscription subscription);
+
+/**
+ * Deactivate a subscription
+ *
+ * @param [in] handle The context object
+ * @param [in] subscription The subscription object
+ */
+void grail_subscription_deactivate(UGHandle handle,
+                                   UGSubscription subscription);
+
+/**
+ * Process a uTouch Frame event
+ *
+ * @param [in] handle The context object
+ * @param [in] event The uTouch Frame event
+ */
+void grail_process_frame_event(UGHandle handle, const UFEvent event);
+
+/**
+ * Get an event from the uTouch Grail context
+ *
+ * @param [in] handle The context object
+ * @param [out] event The retrieved event
+ * @return UGStatusSuccess or UGStatusErrorNoEvent
+ */
+UGStatus grail_get_event(UGHandle handle, UGEvent *event);
+
+/**
+ * Update the grail state for the given server time
+ *
+ * @param [in] handle The context object
+ * @param [in] time The current server time
+ *
+ * The recognizer uses timeouts for deciding whether to accept or reject
+ * touches. Calling this function will perform any pending decisions based on
+ * the current server time.
+ */
+void grail_update_time(UGHandle handle, uint64_t time);
+
+/**
+ * Get the next timeout at which to update the grail state
+ *
+ * @param [in] handle The context object
+ * @return The next server time at which the grail state should be updated
+ *
+ * To update the grail state, call grail_update_time().
+ */
+uint64_t grail_next_timeout(UGHandle handle);
+
+/**
+ * Increment the reference count of an event
+ *
+ * @param [in] event The event object
+ */
+void grail_event_ref(UGEvent event);
+
+/**
+ * Decrement the reference count of an event
+ *
+ * @param [in] event The event object
+ *
+ * When the reference count reaches zero, the event is freed.
+ */
+void grail_event_unref(UGEvent event);
+
+/**
+ * Get the value of a property of an event
+ *
+ * @param [in] event The event object
+ * @param [in] property The property to retrieve a value for
+ * @param [out] value The value retrieved
+ * @return UGStatusSuccess or UGStatusErrorUnknownProperty
+ */
+UGStatus grail_event_get_property(const UGEvent event, UGEventProperty property,
+                                  void *value);
+
+/**
+ * Get the touch ID of a touch in a slice
+ *
+ * @param [in] slice The gesture slcie object
+ * @param [in] index The index of the touch in the slice
+ * @param [out] touch_id The touch ID of the touch
+ */
+UGStatus grail_slice_get_touch_id(const UGSlice slice, unsigned int index,
+                                  UFTouchId *touch_id);
+
+/**
+ * Get the value of a property of a gesture slice
+ *
+ * @param [in] slice The gesture slice object
+ * @param [in] property The property to retrieve a value for
+ * @param [out] value The value retrieved
+ * @return UGStatusSuccess or UGStatusErrorUnknownProperty
+ */
+UGStatus grail_slice_get_property(const UGSlice slice, UGSliceProperty property,
+                                  void *value);
+
+/**
+ * Accept gesture associated with gesture slice
+ *
+ * @param [in] handle The context object
+ * @param [in] id The ID of the gesture to accept
+ * @return UGStatusSuccess or UGStatusErrorInvalidGesture
+ */
+UGStatus grail_accept_gesture(UGHandle handle, unsigned int id);
+
+/**
+ * Reject gesture associated with gesture slice
+ *
+ * @param [in] handle The context object
+ * @param [in] id The ID of the gesture to reject
+ * @return UGStatusSuccess or UGStatusErrorInvalidGesture
+ */
+UGStatus grail_reject_gesture(UGHandle handle, unsigned int id);
+
+/**
+ * @defgroup v3-helpers Helper Functions
+ * These helper functions may be used in place of the generic property getters.
+ * They are limited to properties that are guaranteed to exist in all instances
+ * of the objects.
+ * @{
+ */
+
+/**
+ * Get the type of an event
+ *
+ * @param [in] event The event object
+ * @return The type of the event
+ */
+UGEventType grail_event_get_type(const UGEvent event);
+
+/**
+ * Get the time of an event
+ *
+ * @param [in] event The event object
+ * @return The time of the event
+ */
+uint64_t grail_event_get_time(const UGEvent event);
+
+/**
+ * Get the ID of a gesture from a slice
+ *
+ * @param [in] slice The gesture slice object
+ * @return The ID of the gesture
+ */
+unsigned int grail_slice_get_id(const UGSlice slice);
+
+/**
+ * Get the state of a gesture in a slice
+ *
+ * @param [in] slice The gesture slice object
+ * @return The state of the gesture in the slice
+ */
+UGGestureState grail_slice_get_state(const UGSlice slice);
+
+/**
+ * Get the subscription for the gesture from the slice
+ *
+ * @param [in] slice The gesture slice object
+ * @return The subscription
+ */
+UGSubscription grail_slice_get_subscription(const UGSlice slice);
+
+/**
+ * Get the gestures recognized through the slice
+ *
+ * @param [in] slice The gesture slice object
+ * @return The recognized gestures
+ */
+UGGestureTypeMask grail_slice_get_recognized(const UGSlice slice);
+
+/**
+ * Get the current number of touches in the slice
+ *
+ * @param [in] slice The gesture slice object
+ * @return The number of touches
+ */
+unsigned int grail_slice_get_num_touches(const UGSlice slice);
+
+/**
+ * Get the original centroid position of the gesture along the X axis
+ *
+ * @param [in] slice The gesture slice object
+ * @return The position
+ */
+float grail_slice_get_original_center_x(const UGSlice slice);
+
+/**
+ * Get the original centroid position of the gesture along the Y axis
+ *
+ * @param [in] slice The gesture slice object
+ * @return The position
+ */
+float grail_slice_get_original_center_y(const UGSlice slice);
+
+/**
+ * Get the original radius of the gesture
+ *
+ * @param [in] slice The gesture slice object
+ * @return The position
+ */
+float grail_slice_get_original_radius(const UGSlice slice);
+
+/**
+ * Get the instantaneous center of rotation of the gesture along the X axis
+ *
+ * @param [in] slice The gesture slice object
+ * @return The position
+ */
+float grail_slice_get_center_of_rotation_x(const UGSlice slice);
+
+/**
+ * Get the instantaneous center of rotation of the gesture along the Y axis
+ *
+ * @param [in] slice The gesture slice object
+ * @return The position
+ */
+float grail_slice_get_center_of_rotation_y(const UGSlice slice);
+
+/**
+ * Get the best-fit instantaneous 2D affine transformation for the gesture slice
+ *
+ * @param [in] slice The gesture slice object
+ * @return the transformation
+ *
+ * The returned transformation is owned by the gesture slice.
+ */
+const UGTransform *grail_slice_get_transform(const UGSlice slice);
+
+/**
+ * Get the best-fit cumulative 2D affine transformation for the gesture slice
+ *
+ * @param [in] slice The gesture slice object
+ * @return the transformation
+ *
+ * The returned transformation is owned by the gesture slice.
+ */
+const UGTransform *grail_slice_get_cumulative_transform(const UGSlice slice);
+
+/**
+ * Get the uTouch-Frame frame for the slice
+ *
+ * @param [in] slice The gesture slice object
+ * @return the frame
+ */
+const UFFrame grail_slice_get_frame(const UGSlice slice);
+
+/**
+ * Get whether construction has finished for all touches in the gesture
+ *
+ * @param [in] slice The gesture slice object
+ * @return whether construction has finished
+ */
+int grail_slice_get_construction_finished(const UGSlice slice);
+
+/** @} */
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UTOUCH_GRAIL_UTOUCH_GRAIL_H_
 
=== added directory 'm4'
=== added file 'm4/gcov.m4'
--- m4/gcov.m4	1970-01-01 00:00:00 +0000
+++ m4/gcov.m4	2012-01-25 15:53:29 +0000
@@ -0,0 +1,83 @@
+# Checks for existence of coverage tools:
+#  * gcov
+#  * lcov
+#  * genhtml
+#  * gcovr
+# 
+# Sets ac_cv_check_gcov to yes if tooling is present
+# and reports the executables to the variables LCOV, GCOVR and GENHTML.
+AC_DEFUN([AC_TDD_GCOV],
+[
+  AC_ARG_ENABLE(gcov,
+  AS_HELP_STRING([--enable-gcov],
+		 [enable coverage testing with gcov]),
+  [use_gcov=$enableval], [use_gcov=no])
+
+  if test "x$use_gcov" = "xyes"; then
+  # we need gcc:
+  if test "$GCC" != "yes"; then
+    AC_MSG_ERROR([GCC is required for --enable-gcov])
+  fi
+
+  # Check if ccache is being used
+  AC_CHECK_PROG(SHTOOL, shtool, shtool)
+  case `$SHTOOL path $CC` in
+    *ccache*[)] gcc_ccache=yes;;
+    *[)] gcc_ccache=no;;
+  esac
+
+  if test "$gcc_ccache" = "yes" && (test -z "$CCACHE_DISABLE" || test "$CCACHE_DISABLE" != "1"); then
+    AC_MSG_ERROR([ccache must be disabled when --enable-gcov option is used. You can disable ccache by setting environment variable CCACHE_DISABLE=1.])
+  fi
+
+  lcov_version_list="1.6 1.7 1.8 1.9"
+  AC_CHECK_PROG(LCOV, lcov, lcov)
+  AC_CHECK_PROG(GENHTML, genhtml, genhtml)
+  AC_CHECK_PROG(GCOVR, gcovr, gcovr)
+
+  if test "$LCOV"; then
+    AC_CACHE_CHECK([for lcov version], glib_cv_lcov_version, [
+      glib_cv_lcov_version=invalid
+      lcov_version=`$LCOV -v 2>/dev/null | $SED -e 's/^.* //'`
+      for lcov_check_version in $lcov_version_list; do
+        if test "$lcov_version" = "$lcov_check_version"; then
+          glib_cv_lcov_version="$lcov_check_version (ok)"
+        fi
+      done
+    ])
+  else
+    lcov_msg="To enable code coverage reporting you must have one of the following lcov versions installed: $lcov_version_list"
+    AC_MSG_ERROR([$lcov_msg])
+  fi
+
+  case $glib_cv_lcov_version in
+    ""|invalid[)]
+      lcov_msg="You must have one of the following versions of lcov: $lcov_version_list (found: $lcov_version)."
+      AC_MSG_ERROR([$lcov_msg])
+      LCOV="exit 0;"
+      ;;
+  esac
+
+  if test -z "$GENHTML"; then
+    AC_MSG_ERROR([Could not find genhtml from the lcov package])
+  fi
+
+  if test -z "$GCOVR"; then
+    AC_MSG_ERROR([Could not find gcovr; easy_install (or pip) gcovr])
+  fi
+
+  ac_cv_check_gcov=yes
+
+  # Remove all optimization flags from CFLAGS
+  changequote({,})
+  CFLAGS=`echo "$CFLAGS" | $SED -e 's/-O[0-9]*//g'`
+  changequote([,])
+
+  # Add the special gcc flags
+  COVERAGE_CFLAGS="-O0 -fprofile-arcs -ftest-coverage"
+  COVERAGE_CXXFLAGS="-O0 -fprofile-arcs -ftest-coverage"	
+  COVERAGE_LDFLAGS="-lgcov"
+
+fi
+]) # AC_TDD_GCOV
+
 
=== added file 'm4/gtest.m4'
--- m4/gtest.m4	1970-01-01 00:00:00 +0000
+++ m4/gtest.m4	2012-01-25 15:53:29 +0000
@@ -0,0 +1,24 @@
+# Checks whether the gtest library is available on the system
+# Allows for adjusting the include and library path.
+# Sets have_gtest=yes if the library is present and
+# reports the compiler and linker flags in 
+# GTEST_CXXFLAGS AND GTEST_LDFLAGS, respectively.
+AC_DEFUN([AC_CHECK_GTEST],
+[
+  AC_ARG_WITH([gtest-include-path],
+  [AS_HELP_STRING([--with-gtest-include-path],
+    [location of the Google test headers, defaults to /usr/include])],
+  [GTEST_CXXFLAGS="-I$withval"],
+  [GTEST_CXXFLAGS='-I/usr/include'])
+
+  AC_ARG_WITH([gtest-lib-path],
+  [AS_HELP_STRING([--with-gtest-lib-path], [location of the Google test libraries])],
+  [GTEST_LDFLAGS="-L$withval -lpthread"],
+  [GTEST_LDFLAGS='-lgtest -lpthread'])
+
+  AC_HAVE_LIBRARY( [gtest], 
+                [have_gtest=yes], 
+                 AC_MSG_WARN([package 'gtest' not found: tests disabled]))
+
+]) # AC_CHECK_GTEST
+
 
=== modified file 'src/Makefile.am'
--- src/Makefile.am	2011-04-28 16:53:41 +0000
+++ src/Makefile.am	2012-01-25 15:53:29 +0000
@@ -1,3 +1,5 @@
+AUTOMAKE_OPTIONS = subdir-objects
+
 lib_LTLIBRARIES = libutouch-grail.la
 
 libutouch_grail_la_LDFLAGS = \
@@ -7,32 +9,48 @@
 	$(EVEMU_LIBS) \
 	$(FRAME_LIBS)
 
+v2dir = v2
 libutouch_grail_la_SOURCES = \
-	evbuf.h \
-	gebuf.h \
-	grailbuf.h \
-	grail-bits.c \
-	grail-inserter.c \
-	grail-inserter.h \
-	grail-gestures.c \
-	grail-gestures.h \
-	gestures-touch.c \
-	gestures-drag.c \
-	gestures-pinch.c \
-	gestures-rotate.c \
-	gestures-tapping.c \
-	grail-recognizer.c \
-	grail-recognizer.h \
-	grail-event.c \
-	grail-impl.h \
-	grail-api.c \
-	grail-legacy.c \
-	grail-init.c \
-	grail-frame.c
+	v2/evbuf.h \
+	v2/gebuf.h \
+	v2/grailbuf.h \
+	v2/grail-bits.c \
+	v2/grail-inserter.c \
+	v2/grail-inserter.h \
+	v2/grail-gestures.c \
+	v2/grail-gestures.h \
+	v2/gestures-touch.c \
+	v2/gestures-drag.c \
+	v2/gestures-pinch.c \
+	v2/gestures-rotate.c \
+	v2/gestures-tapping.c \
+	v2/grail-recognizer.c \
+	v2/grail-recognizer.h \
+	v2/grail-event.c \
+	v2/grail-impl.h \
+	v2/grail-api.c \
+	v2/grail-legacy.c \
+	v2/grail-init.c \
+	v2/grail-frame.c
 
-# These are flags required to properly set up
-# the build. -fvisibility requires GCC > 4 (or clang)
-AM_CFLAGS = $(CWARNFLAGS) -DBUILDING_GRAIL -fvisibility=hidden
+if HAVE_XI
+v3dir = v3
+libutouch_grail_la_SOURCES += \
+	v3/event.cpp \
+	v3/event.h \
+	v3/gesture.cpp \
+	v3/gesture.h \
+	v3/handle.cpp \
+	v3/handle.h \
+	v3/log.cpp \
+	v3/log.h \
+	v3/recognizer.cpp \
+	v3/recognizer.h \
+	v3/slice.cpp \
+	v3/slice.h \
+	v3/subscription.cpp \
+	v3/subscription.h
+endif
 
 INCLUDES = -I$(top_srcdir)/include/
 
@@ -41,3 +59,9 @@
 	$(top_srcdir)/include/grail-bits.h \
 	$(top_srcdir)/include/grail-types.h \
 	$(top_srcdir)/include/grail.h
+
+if HAVE_XI
+libutouch_grail_v3includedir = $(includedir)/utouch
+libutouch_grail_v3include_HEADERS = \
+	$(top_srcdir)/include/utouch/grail.h
+endif
 
=== removed file 'src/evbuf.h'
--- src/evbuf.h	2011-04-28 16:53:57 +0000
+++ src/evbuf.h	1970-01-01 00:00:00 +0000
@@ -1,57 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_EVBUF_H
-#define GRAIL_EVBUF_H
-
-#define DIM_EVENTS 4096
-
-struct evbuf {
-	int head;
-	int tail;
-	struct input_event buffer[DIM_EVENTS];
-};
-
-static inline void evbuf_clear(struct evbuf *evbuf)
-{
-	evbuf->head = evbuf->tail = 0;
-}
-
-static inline int evbuf_empty(const struct evbuf *evbuf)
-{
-	return evbuf->head == evbuf->tail;
-}
-
-static inline void evbuf_put(struct evbuf *evbuf,
-			     const struct input_event *ev)
-{
-	evbuf->buffer[evbuf->head++] = *ev;
-	evbuf->head &= DIM_EVENTS - 1;
-}
-
-static inline void evbuf_get(struct evbuf *evbuf,
-			     struct input_event *ev)
-{
-	*ev = evbuf->buffer[evbuf->tail++];
-	evbuf->tail &= DIM_EVENTS - 1;
-}
-
-#endif
 
=== removed file 'src/gebuf.h'
--- src/gebuf.h	2011-05-17 14:15:22 +0000
+++ src/gebuf.h	1970-01-01 00:00:00 +0000
@@ -1,68 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_GESTURE_BUFFER_H
-#define GRAIL_GESTURE_BUFFER_H
-
-#include "grail-impl.h"
-
-#define DIM_GESTURE_EVENTS 512
-
-struct gesture_event {
-	int status;
-	int ntouch;
-	int nprop;
-	utouch_frame_time_t time;
-	struct grail_coord pos;
-	grail_prop_t prop[DIM_GRAIL_PROP];
-};
-
-struct gebuf {
-	int head;
-	int tail;
-	struct gesture_event buffer[DIM_GESTURE_EVENTS];
-};
-
-static inline void gebuf_clear(struct gebuf *gebuf)
-{
-	gebuf->head = gebuf->tail = 0;
-}
-
-static inline int gebuf_empty(const struct gebuf *gebuf)
-{
-	return gebuf->head == gebuf->tail;
-}
-
-static inline void gebuf_put(struct gebuf *gebuf,
-			     const struct gesture_event *ev)
-{
-	gebuf->buffer[gebuf->head++] = *ev;
-	gebuf->head &= DIM_GESTURE_EVENTS - 1;
-}
-
-static inline void gebuf_get(struct gebuf *gebuf,
-			     struct gesture_event *ev)
-{
-	*ev = gebuf->buffer[gebuf->tail++];
-	gebuf->tail &= DIM_GESTURE_EVENTS - 1;
-}
-
-#endif
 
=== removed file 'src/gestures-drag.c'
--- src/gestures-drag.c	2011-04-28 16:53:57 +0000
+++ src/gestures-drag.c	1970-01-01 00:00:00 +0000
@@ -1,135 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	-1,
-	GRAIL_TYPE_DRAG1,
-	GRAIL_TYPE_DRAG2,
-	GRAIL_TYPE_DRAG3,
-	GRAIL_TYPE_DRAG4,
-	GRAIL_TYPE_DRAG5,
-};
-
-static void set_props(const struct gesture_inserter *gin,
-		      struct combo_model *s, const struct move_model *m,
-		      const struct utouch_frame *frame)
-{
-	if (m->single) {
-		s->prop[GRAIL_PROP_DRAG_DX] = m->fm[FM_X].raw_delta;
-		s->prop[GRAIL_PROP_DRAG_DY] = m->fm[FM_Y].raw_delta;
-	} else {
-		s->prop[GRAIL_PROP_DRAG_DX] = m->fm[FM_X].action_delta;
-		s->prop[GRAIL_PROP_DRAG_DY] = m->fm[FM_Y].action_delta;
-	}
-	s->prop[GRAIL_PROP_DRAG_VX] = m->fm[FM_X].velocity;
-	s->prop[GRAIL_PROP_DRAG_VY] = m->fm[FM_Y].velocity;
-	s->prop[GRAIL_PROP_DRAG_X] = m->fm[FM_X].value;
-	s->prop[GRAIL_PROP_DRAG_Y] = m->fm[FM_Y].value;
-	s->nprop = 6;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-static const int fm_mask = 0x03;
-
-int gru_drag(struct grail *ge,
-	    const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->drag;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (type < 0)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_windrag(struct grail *ge,
-		const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->windrag;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MDRAG,
-						   PRIO_META, frame);
-			state->mintouch = 1;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EDRAG,
-						   PRIO_ENV, frame);
-			state->mintouch = 1;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
 
=== removed file 'src/gestures-pinch.c'
--- src/gestures-pinch.c	2011-06-06 14:42:39 +0000
+++ src/gestures-pinch.c	1970-01-01 00:00:00 +0000
@@ -1,131 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	0,
-	0,
-	GRAIL_TYPE_PINCH2,
-	GRAIL_TYPE_PINCH3,
-	GRAIL_TYPE_PINCH4,
-	GRAIL_TYPE_PINCH5,
-};
-
-static const int fm_mask = 0x04;
-
-static void set_props(const struct gesture_inserter *gin,
-		      struct combo_model *s,
-		      const struct move_model *m,
-		      const struct utouch_frame *frame)
-{
-	s->prop[GRAIL_PROP_PINCH_DR] = m->fm[FM_R].action_delta;
-	s->prop[GRAIL_PROP_PINCH_VR] = m->fm[FM_R].velocity;
-	s->prop[GRAIL_PROP_PINCH_R] = m->fm[FM_R].value;
-	s->prop[GRAIL_PROP_PINCH_X] = m->fm[FM_X].value;
-	s->prop[GRAIL_PROP_PINCH_Y] = m->fm[FM_Y].value;
-	s->nprop = 5;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-int gru_pinch(struct grail *ge,
-	      const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->pinch;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (!type)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_winpinch(struct grail *ge,
-		 const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->winpinch;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MPINCH,
-						   PRIO_META, frame);
-			state->mintouch = 2;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EPINCH,
-						   PRIO_ENV, frame);
-			state->mintouch = 2;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
 
=== removed file 'src/gestures-rotate.c'
--- src/gestures-rotate.c	2011-06-03 12:54:23 +0000
+++ src/gestures-rotate.c	1970-01-01 00:00:00 +0000
@@ -1,130 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	0,
-	0,
-	GRAIL_TYPE_ROTATE2,
-	GRAIL_TYPE_ROTATE3,
-	GRAIL_TYPE_ROTATE4,
-	GRAIL_TYPE_ROTATE5,
-};
-
-static const int fm_mask = 0x08;
-
-static void set_props(const struct gesture_inserter *gin,
-		      struct combo_model *s, const struct move_model *m,
-		      const struct utouch_frame *frame)
-{
-	s->prop[GRAIL_PROP_ROTATE_DA] = m->fm[FM_A].action_delta;
-	s->prop[GRAIL_PROP_ROTATE_VA] = m->fm[FM_A].velocity;
-	s->prop[GRAIL_PROP_ROTATE_A] = m->fm[FM_A].value;
-	s->prop[GRAIL_PROP_ROTATE_X] = m->fm[FM_X].value;
-	s->prop[GRAIL_PROP_ROTATE_Y] = m->fm[FM_Y].value;
-	s->nprop = 5;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-int gru_rotate(struct grail *ge,
-	       const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->rotate;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi && !move->single) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (!type)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_winrotate(struct grail *ge,
-		  const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->winrotate;
-	struct move_model *move = &gru->move;
-	int mask = state->active ? (move->active & fm_mask) : fm_mask;
-	if (!move->multi) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-		return 0;
-	}
-	if ((move->timeout & fm_mask) == fm_mask) {
-		if (state->active) {
-			gin_gid_timeout(ge, state->gid);
-		}
-	}
-	if (!(move->tickle & mask))
-		return 0;
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MROTATE,
-						   PRIO_META, frame);
-			state->mintouch = 2;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EROTATE,
-						   PRIO_ENV, frame);
-			state->mintouch = 2;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (!(move->active & fm_mask))
-		return 0;
-	set_props(ge->gin, state, move, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
 
=== removed file 'src/gestures-tapping.c'
--- src/gestures-tapping.c	2011-04-28 16:53:57 +0000
+++ src/gestures-tapping.c	1970-01-01 00:00:00 +0000
@@ -1,100 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-
-static const int fm_mask = 0x07;
-
-static void set_props(const struct gesture_inserter *gin,
-		      struct tapping_model *s, const struct move_model *m,
-		      const struct utouch_frame *frame)
-{
-	s->prop[GRAIL_PROP_TAP_DT] = m->time - s->start;
-	s->prop[GRAIL_PROP_TAP_X] = m->fm[FM_X].value;
-	s->prop[GRAIL_PROP_TAP_Y] = m->fm[FM_Y].value;
-	s->nprop = 3;
-	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
-}
-
-int gru_tapping(struct grail *ge,
-		const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct tapping_model *state = &gru->tapping;
-	struct move_model *move = &gru->move;
-	state->tap = 0;
-	if (frame->num_active && !frame->prev->num_active) {
-		state->mintouch = 0;
-		state->maxtouch = 0;
-	}
-	if (move->ntouch > state->maxtouch) {
-		if (state->active) {
-			gin_gid_discard(ge, state->gid);
-			state->active = 0;
-		}
-		state->start = move->time;
-		state->maxtouch = move->ntouch;
-		set_props(ge->gin, state, move, frame);
-		if (state->maxtouch <= 5) {
-			int type = GRAIL_TYPE_TAP1 + state->maxtouch - 1;
-			state->gid = gin_gid_begin(ge, type, PRIO_TAP, frame);
-			state->active = 1;
-		}
-		return 0;
-	}
-	if (!state->active) {
-		state->mintouch = move->ntouch;
-		state->maxtouch = move->ntouch;
-		return 0;
-	}
-	if (move->ntouch <= state->mintouch) {
-		int x = state->prop[GRAIL_PROP_TAP_X];
-		int y = state->prop[GRAIL_PROP_TAP_Y];
-		int t = move->time - state->start;
-		if (t > move->fm[FM_X].bar_ms) {
-			gin_gid_discard(ge, state->gid);
-			state->mintouch = move->ntouch;
-			state->maxtouch = move->ntouch;
-			state->active = 0;
-			return 0;
-		}
-		state->tap = state->maxtouch;
-		state->prop[GRAIL_PROP_TAP_DT] = t;
-		gin_gid_event(ge, state->gid, x, y, state->maxtouch,
-			      state->prop, state->nprop, 1);
-		state->mintouch = move->ntouch;
-		state->maxtouch = move->ntouch;
-		state->active = 0;
-		return 1;
-	}
-	if (!move->ntouch)
-		return 0;
-	state->prop[GRAIL_PROP_TAP_DT] = move->time - state->start;
-	if ((move->active & fm_mask) ||
-	    move->time - state->start > move->fm[FM_X].bar_ms) {
-		gin_gid_discard(ge, state->gid);
-		state->mintouch = move->ntouch;
-		state->maxtouch = move->ntouch;
-		state->active = 0;
-	}
-	return 0;
-}
 
=== removed file 'src/gestures-touch.c'
--- src/gestures-touch.c	2011-04-04 17:27:38 +0000
+++ src/gestures-touch.c	1970-01-01 00:00:00 +0000
@@ -1,98 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <math.h>
-#include <stdio.h>
-
-static const int getype[DIM_TOUCH + 1] = {
-	-1,
-	GRAIL_TYPE_TOUCH1,
-	GRAIL_TYPE_TOUCH2,
-	GRAIL_TYPE_TOUCH3,
-	GRAIL_TYPE_TOUCH4,
-	GRAIL_TYPE_TOUCH5,
-};
-
-int gru_touch(struct grail *ge,
-	      const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->touch;
-	struct move_model *move = &gru->move;
-	if (frame->slot_revision != frame->prev->slot_revision) {
-		if (state->active) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if (!state->active) {
-		int type = getype[move->ntouch];
-		if (type <= 0)
-			return 0;
-		state->gid = gin_gid_begin(ge, type, -PRIO_GESTURE, frame);
-		state->active = 1;
-	}
-	if (move->time - move->fm[FM_X].original_ms <= move->fm[FM_X].hold_ms)
-		return 0;
-	state->nprop = gin_add_contact_props(ge->gin, state->prop, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
-
-int gru_wintouch(struct grail *ge,
-		 const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct combo_model *state = &gru->wintouch;
-	struct move_model *move = &gru->move;
-	if (frame->slot_revision != frame->prev->slot_revision) {
-		if (state->active && out_of_bounds(state, move)) {
-			gru_end(ge, state->gid, move,
-				state->prop, state->nprop);
-			state->active = 0;
-		}
-	}
-	if (!state->active) {
-		if (move->ntouch == 4) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MTOUCH,
-						   -PRIO_META, frame);
-			state->mintouch = 1;
-			state->maxtouch = 4;
-			state->active = 1;
-		} else if (move->ntouch == 3) {
-			state->gid = gin_gid_begin(ge, GRAIL_TYPE_ETOUCH,
-						   -PRIO_ENV, frame);
-			state->mintouch = 1;
-			state->maxtouch = 3;
-			state->active = 1;
-		} else {
-			return 0;
-		}
-	}
-	if (move->time - move->fm[FM_X].original_ms <= move->fm[FM_X].hold_ms)
-		return 0;
-	state->nprop = gin_add_contact_props(ge->gin, state->prop, frame);
-	gru_event(ge, state->gid, move, state->prop, state->nprop);
-	return 1;
-}
 
=== removed file 'src/grail-api.c'
--- src/grail-api.c	2011-08-31 17:20:48 +0000
+++ src/grail-api.c	1970-01-01 00:00:00 +0000
@@ -1,328 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-impl.h"
-#include "grail-inserter.h"
-#include "grail-recognizer.h"
-#include <string.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <malloc.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-
-#define DIM_FRAMES 100
-#define FRAME_RATE 100
-
-unsigned int GRAIL_PUBLIC grail_get_version(void)
-{
-	return GRAIL_VERSION;
-}
-
-int GRAIL_PUBLIC grail_open(struct grail *ge, int fd)
-{
-	struct grail_impl *x;
-	struct stat fs;
-	int ret;
-
-	ret = fstat(fd, &fs);
-	if (ret)
-		return ret;
-
-	x = calloc(1, sizeof(*x));
-	if (!x)
-		return -ENOMEM;
-
-	if (!fs.st_rdev)
-		x->fptest = fdopen(fd, "r");
-
-	x->evemu = evemu_new(x->fptest ? "fptest" : 0);
-	if (!x->evemu) {
-		ret = -ENOMEM;
-		goto freemem;
-	}
-	if (x->fptest)
-		ret = evemu_read(x->evemu, x->fptest) <= 0;
-	else
-		ret = evemu_extract(x->evemu, fd);
-	if (ret)
-		goto freemem;
-	if (!utouch_frame_is_supported_mtdev(x->evemu)) {
-		ret = -ENODEV;
-		goto freemem;
-	}
-
-	if (!x->fptest) {
-		x->mtdev = mtdev_new_open(fd);
-		if (!x->mtdev) {
-			ret = -ENOMEM;
-			goto freemem;
-		}
-	}
-	x->fh = utouch_frame_new_engine(DIM_FRAMES, DIM_TOUCH, FRAME_RATE);
-	if (!x->fh) {
-		ret = -ENOMEM;
-		goto freedev;
-	}
-	ret = utouch_frame_init_mtdev(x->fh, x->evemu);
-	if (ret)
-		goto freeframe;
-
-	ge->impl = x;
-
-	ret = gin_init(ge);
-	if (ret)
-		goto freeframe;
-
-	ret = gru_init(ge);
-	if (ret)
-		goto freegin;
-
-	return 0;
- freegin:
-	gin_destroy(ge);
- freeframe:
-	utouch_frame_delete_engine(x->fh);
- freedev:
-	if (x->mtdev)
-		mtdev_close_delete(x->mtdev);
- freemem:
-	evemu_delete(x->evemu);
-	if (x->fptest)
-		fclose(x->fptest);
-	free(x);
-	ge->impl = 0;
-	return ret;
-}
-
-void GRAIL_PUBLIC grail_close(struct grail *ge, int fd)
-{
-	struct grail_impl *x = ge->impl;
-	gru_destroy(ge);
-	gin_destroy(ge);
-	utouch_frame_delete_engine(x->fh);
-	if (x->mtdev)
-		mtdev_close_delete(x->mtdev);
-	evemu_delete(x->evemu);
-	if (x->fptest)
-		fclose(x->fptest);
-	free(x);
-	ge->impl = 0;
-}
-
-int GRAIL_PUBLIC grail_idle(struct grail *ge, int fd, int ms)
-{
-	struct grail_impl *x = ge->impl;
-	if (x->fptest)
-		return 0;
-	if (x->mtdev)
-		return mtdev_idle(x->mtdev, fd, ms);
-	return 1;
-}
-
-void GRAIL_PUBLIC grail_get_units(const struct grail *ge,
-				  struct grail_coord *min, struct grail_coord *max)
-{
-	struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
-	min->x = s->min_x;
-	min->y = s->min_y;
-	max->x = s->max_x;
-	max->y = s->max_y;
-}
-
-const struct utouch_frame GRAIL_PUBLIC *
-grail_get_contact_frame(const struct grail *ge)
-{
-	return ge->impl->touch;
-}
-
-static void flush_events(struct grail *ge)
-{
-	struct grail_impl *impl = ge->impl;
-	struct input_event iev;
-
-	grailbuf_clear(&impl->gbuf);
-	while (!evbuf_empty(&impl->evbuf)) {
-		evbuf_get(&impl->evbuf, &iev);
-		if (ge->event)
-			ge->event(ge, &iev);
-	}
-}
-
-static int skip_event(const struct input_event *ev, int count)
-{
-	switch (ev->type) {
-	case EV_ABS:
-		return 1;
-	case EV_KEY:
-		return ev->code >= BTN_DIGI && ev->code < BTN_WHEEL;
-	case EV_SYN:
-		switch (ev->code) {
-		case SYN_MT_REPORT:
-			return 1;
-		case SYN_REPORT:
-			return count == 0;
-		default:
-			return 0;
-		}
-	default:
-		return 0;
-	}
-}
-
-static void flush_gestures(struct grail *ge)
-{
-	struct grail_impl *impl = ge->impl;
-	struct input_event iev;
-	struct grail_event gev;
-	int count = 0;
-
-	while (!evbuf_empty(&impl->evbuf)) {
-		evbuf_get(&impl->evbuf, &iev);
-		if (skip_event(&iev, count))
-			continue;
-		if (ge->event)
-			ge->event(ge, &iev);
-		if (iev.type == EV_SYN && iev.code == SYN_REPORT)
-			count = 0;
-		else
-			count++;
-	}
-	while (!grailbuf_empty(&impl->gbuf)) {
-		grailbuf_get(&impl->gbuf, &gev);
-		if (ge->gesture)
-			ge->gesture(ge, &gev);
-	}
-}
-
-static int gesture_timeout(struct grail *ge, const struct utouch_frame *frame)
-{
-	struct gesture_recognizer *gru = ge->gru;
-	struct gesture_inserter *gin = ge->gin;
-
-	return grail_mask_count(gin->used, sizeof(gin->used)) == 0 &&
-		frame->time - frame->mod_time > gru->move.fm[FM_X].hold_ms;
-}
-
-static void report_frame(struct grail *ge,
-			 const struct utouch_frame *touch,
-			 const struct input_event *syn)
-{
-	struct grail_impl *impl = ge->impl;
-
-	impl->touch = touch;
-
-	if (touch->num_active && !touch->prev->num_active) {
-		impl->ongoing = 1;
-		impl->gesture = 0;
-	}
-
-	if (!impl->ongoing)
-		return;
-
-	gin_frame_begin(ge, touch);
-	gru_recognize(ge, touch);
-	gin_frame_end(ge, touch);
-
-	if (!grailbuf_empty(&impl->gbuf))
-		impl->gesture = 1;
-
-	if (touch->num_active == 0 || gesture_timeout(ge, touch))
-		impl->ongoing &= impl->gesture;
-}
-
-static void grail_pump_mtdev(struct grail *ge, const struct input_event *ev)
-{
-	struct grail_impl *impl = ge->impl;
-	const struct utouch_frame *frame;
-
-	evbuf_put(&impl->evbuf, ev);
-
-	if (ev->type == EV_SYN || ev->type == EV_ABS || ev->type == EV_KEY) {
-		frame = utouch_frame_pump_mtdev(impl->fh, ev);
-		if (frame)
-			report_frame(ge, frame, ev);
-	}
-
-	if (ev->type == EV_SYN) {
-		if (!impl->ongoing)
-			flush_events(ge);
-		if (impl->gesture)
-			flush_gestures(ge);
-	}
-}
-
-/**
- * Read an event from the given file. If fast_fileread is true,
- * return immediately. If it is false, delay between events
- * so it looks like they are coming in real time.
- */
-static int grail_read_evemu_event(FILE *fp, struct input_event *ev,
-		      struct timeval *evtime, int fast_fileread) {
-	if (fast_fileread)
-		return evemu_read_event(fp, ev);
-	return evemu_read_event_realtime(fp, ev, evtime);
-}
-
-
-static int grail_pull_fstest(struct grail *ge, int fd)
-{
-	struct grail_impl *impl = ge->impl;
-	struct input_event ev;
-	struct timeval evtime;
-        int count = 0;
-
-	memset(&evtime, 0, sizeof(evtime));
-	while (grail_read_evemu_event(impl->fptest, &ev, &evtime, impl->fast_fileread) > 0) {
-		grail_pump_mtdev(ge, &ev);
-		count++;
-	}
-
-	fclose(impl->fptest);
-	impl->fptest = 0;
-
-        return count > 0 ? count : -1;
-}
-
-int GRAIL_PUBLIC grail_pull(struct grail *ge, int fd)
-{
-	struct grail_impl *impl = ge->impl;
-	struct input_event ev;
-        int ret, count = 0;
-
-	if (impl->fptest)
-		return grail_pull_fstest(ge, fd);
-
-        while ((ret = mtdev_get(impl->mtdev, fd, &ev, 1)) > 0) {
-		grail_pump_mtdev(ge, &ev);
-                count++;
-        }
-
-        return count > 0 ? count : ret;
-}
-
-void GRAIL_PUBLIC grail_set_coordinate_transform_callback(struct grail *ge,
-							  utouch_coordinate_transform_cb callback,
-							  void *user_data) {
-	utouch_frame_set_coordinate_transform_callback(ge->impl->fh, callback, user_data);
-}
 
=== removed file 'src/grail-bits.c'
--- src/grail-bits.c	2011-04-28 16:53:57 +0000
+++ src/grail-bits.c	1970-01-01 00:00:00 +0000
@@ -1,93 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-bits.h"
-
-static const int grail_bits_in_byte[256] =
-{
-	0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
-	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
-	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
-	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
-	1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
-	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
-	2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
-	3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8,
-};
-
-static const int grail_first_set_bit[256] =
-{
-	-1,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-	5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,
-};
-
-void GRAIL_PUBLIC grail_mask_set_mask(grail_mask_t *a, const grail_mask_t *b,
-				      int bytes)
-{
-	while (bytes--)
-		*a++ |= *b++;
-}
-
-void GRAIL_PUBLIC grail_mask_clear_mask(grail_mask_t *a, const grail_mask_t *b,
-					int bytes)
-{
-	while (bytes--)
-		*a++ &= ~*b++;
-}
-
-int GRAIL_PUBLIC grail_mask_count(const grail_mask_t *mask, int bytes)
-{
-	int count = 0;
-	while (bytes--)
-		count += grail_bits_in_byte[*mask++];
-	return count;
-}
-
-int GRAIL_PUBLIC grail_mask_get_first(const grail_mask_t *mask, int bytes)
-{
-	int k;
-	for (k = 0; k < bytes; k++)
-		if (mask[k])
-			return (k << 3) | grail_first_set_bit[mask[k]];
-	return -1;
-}
-
-int GRAIL_PUBLIC grail_mask_get_next(int i, const grail_mask_t *mask, int bytes)
-{
-	int k = ++i >> 3;
-	if (k < bytes) {
-		i = grail_first_set_bit[mask[k] & (~0 << (i & 7))];
-		if (i >= 0)
-			return (k << 3) | i;
-		while (++k < bytes) {
-			i = grail_first_set_bit[mask[k]];
-			if (i >= 0)
-				return (k << 3) | i;
-		}
-	}
-	return -1;
-}
 
=== removed file 'src/grail-event.c'
--- src/grail-event.c	2011-08-31 17:45:31 +0000
+++ src/grail-event.c	1970-01-01 00:00:00 +0000
@@ -1,118 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-inserter.h"
-#include "grail-impl.h"
-#include <malloc.h>
-#include <string.h>
-#include <errno.h>
-#include <math.h>
-
-static void compute_bbox(struct grail_coord *min, struct grail_coord *max,
-			 const struct utouch_frame *frame)
-{
-	float x, y;
-	int i;
-	if (frame->num_active < 1)
-		return;
-	x = frame->active[0]->x;
-	y = frame->active[0]->y;
-	min->x = max->x = x;
-	min->y = max->y = y;
-	for (i = 1; i < frame->num_active; i++) {
-		x = frame->active[i]->x;
-		y = frame->active[i]->y;
-		if (x < min->x)
-			min->x = x;
-		if (y < min->y)
-			min->y = y;
-		if (x > max->x)
-			max->x = x;
-		if (y > max->y)
-			max->y = y;
-	}
-}
-
-int gin_add_contact_props(const struct gesture_inserter *gin,
-			  grail_prop_t *prop, const struct utouch_frame *frame)
-{
-	struct grail_coord min = { 0, 0 };
-	struct grail_coord max = { 0, 0 };
-	int i, n = 0, ntouch = frame->num_active;
-	if (!ntouch)
-		return n;
-	if (ntouch > 5)
-		ntouch = 5;
-	compute_bbox(&min, &max, frame);
-	prop[n++] = min.x;
-	prop[n++] = min.y;
-	prop[n++] = max.x;
-	prop[n++] = max.y;
-	for (i = 0; i < ntouch; i++) {
-		const struct utouch_contact *ct = frame->active[i];
-		prop[n++] = ct->id;
-		prop[n++] = ct->x;
-		prop[n++] = ct->y;
-	}
-	return n;
-}
-
-int gin_get_clients(struct grail *ge,
-		    struct grail_client_info *info, int maxinfo,
-		    const grail_mask_t* types, int btypes,
-		    const grail_mask_t* span, int bspan,
-		    const struct utouch_frame *frame)
-{
-	struct grail_coord pos[DIM_TOUCH];
-	int i, npos = 0;
-	if (!ge->get_clients)
-		return 0;
-	grail_mask_foreach(i, span, bspan) {
-		pos[npos].x = frame->slots[i]->x;
-		pos[npos].y = frame->slots[i]->y;
-		npos++;
-	}
-	return ge->get_clients(ge, info, maxinfo, pos, npos, types, btypes);
-}
-
-void gin_send_event(struct grail *ge, struct slot_state *s,
-		    const struct gesture_event *ev,
-		    const struct utouch_frame *frame)
-{
-	struct grail_impl *impl = ge->impl;
-	struct grail_event gev;
-	int i;
-	if (!ge->gesture)
-		return;
-	gev.type = s->type;
-	gev.id = s->id;
-	gev.status = ev->status;
-	gev.ntouch = ev->ntouch;
-	gev.nprop = ev->nprop;
-	gev.time = ev->time;
-	gev.pos.x = ev->pos.x;
-	gev.pos.y = ev->pos.y;
-	memcpy(gev.prop, ev->prop, ev->nprop * sizeof(grail_prop_t));
-	for (i = 0; i < s->nclient; i++) {
-		gev.client_id = s->client_id[i];
-		grailbuf_put(&impl->gbuf, &gev);
-	}
-}
 
=== removed file 'src/grail-frame.c'
--- src/grail-frame.c	2011-08-31 17:20:48 +0000
+++ src/grail-frame.c	1970-01-01 00:00:00 +0000
@@ -1,410 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-impl.h"
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-
-static void set_center_velocity_and_radius(struct grail_impl *impl,
-					   struct grail_element *slot)
-{
-	const struct utouch_contact **tc = slot->touches;
-	double x, y, vx, vy, r2, dx, dy;
-	int i;
-
-	switch (slot->num_touches) {
-	case 1:
-		x = tc[0]->x;
-		y = tc[0]->y;
-		vx = tc[0]->vx;
-		vy = tc[0]->vy;
-		r2 = 0;
-		break;
-	case 2:
-		dx = 0.5 * (tc[1]->x - tc[0]->x);
-		dy = 0.5 * (tc[1]->y - tc[0]->y);
-		x = tc[0]->x + dx;
-		y = tc[0]->y + dy;
-		vx = 0.5 * (tc[0]->vx + tc[1]->vx);
-		vy = 0.5 * (tc[0]->vy + tc[1]->vy);
-		r2 = dx * dx + dy * dy;
-		break;
-	default:
-		x = y = vx = vy = r2 = 0;
-		for (i = 0; i < slot->num_touches; i++) {
-			x += tc[i]->x;
-			y += tc[i]->y;
-			vx += tc[i]->vx;
-			vy += tc[i]->vy;
-		}
-		x /= slot->num_touches;
-		y /= slot->num_touches;
-		vx /= slot->num_touches;
-		vy /= slot->num_touches;
-		for (i = 0; i < slot->num_touches; i++) {
-			dx = tc[i]->x - x;
-			dy = tc[i]->y - y;
-			r2 += dx * dx + dy * dy;
-		}
-		r2 /= slot->num_touches;
-		break;
-	}
-
-	slot->center.x = x;
-	slot->center.y = y;
-	slot->velocity.x = 1000 * vx;
-	slot->velocity.y = 1000 * vy;
-	slot->radius2 = r2;
-}
-
-static void set_transform(struct grail_impl *impl, struct grail_element *slot,
-			  double ds, double dc)
-{
-	const struct grail_element *pslot = slot->prev;
-	double dx = slot->center.x - pslot->center.x;
-	double dy = slot->center.y - pslot->center.y;
-	float *T = slot->transform;
-
-	T[0] = dc;
-	T[1] = ds;
-	T[2] = dx;
-	T[3] = -ds;
-	T[4] = dc;
-	T[5] = dy;
-
-	slot->drag.x = pslot->drag.x + dx;
-	slot->drag.y = pslot->drag.y + dy;
-}
-
-static void start_slot(struct grail_impl *impl,
-		       struct grail_element *slot,
-		       const struct utouch_frame *touch)
-{
-	float *T = slot->transform;
-
-	slot->id = impl->seqid++ & GRAIL_ID_MAX;
-	slot->expect_mask = GRAIL_EXPECT_MASK;
-	slot->active_mask = 0;
-	slot->start_time = touch->time;
-	set_center_velocity_and_radius(impl, slot);
-	T[0] = T[4] = 1;
-	T[1] = T[2] = T[3] = T[5] = 0;
-	slot->drag.x = 0;
-	slot->drag.y = 0;
-	slot->scale2 = 1;
-	slot->angle = 0;
-}
-
-static void update_slot(struct grail_impl *impl,
-			struct grail_element *slot,
-			double ds, double dc)
-{
-	const struct grail_element *pslot = slot->prev;
-
-	slot->id = pslot->id;
-	slot->start_time = pslot->start_time;
-	slot->expect_mask = pslot->expect_mask;
-	slot->active_mask = pslot->active_mask;
-
-	set_center_velocity_and_radius(impl, slot);
-	set_transform(impl, slot, ds, dc);
-
-	slot->scale2 = pslot->scale2 * (ds * ds + dc * dc);
-	slot->angle = pslot->angle + ds / dc; /* atan2(ds, dc) */
-}
-
-static void stop_slot(struct grail_impl *impl,
-		      struct grail_element *slot)
-{
-	const struct grail_element *pslot = slot->prev;
-	float *T = slot->transform;
-
-	slot->id = -1;
-	slot->num_touches = 0;
-	slot->start_time = pslot->start_time;
-	slot->expect_mask = 0;
-	slot->active_mask = pslot->active_mask;
-	slot->center = pslot->center;
-	slot->velocity = pslot->velocity;
-	slot->radius2 = pslot->radius2;
-	T[0] = T[4] = 1;
-	T[1] = T[2] = T[3] = T[5] = 0;
-	slot->drag = pslot->drag;
-	slot->scale2 = pslot->scale2;
-	slot->angle = pslot->angle;
-}
-
-static void set_slot_one(struct grail_impl *impl,
-			 struct grail_element *slot,
-			 const struct utouch_frame *touch,
-			 const struct utouch_contact *t1)
-{
-	const struct grail_element *pslot = slot->prev;
-	const struct utouch_contact *p1 = pslot->touches[0];
-
-	if (!t1->active) {
-		stop_slot(impl, slot);
-		return;
-	}
-
-	slot->touches[0] = t1;
-	slot->num_touches = 1;
-
-	if (pslot->num_touches != slot->num_touches || t1->id != p1->id) {
-		start_slot(impl, slot, touch);
-		return;
-	}
-
-	update_slot(impl, slot, 0, 1);
-}
-
-static void set_slot_two(struct grail_impl *impl,
-			 struct grail_element *slot,
-			 const struct utouch_frame *touch,
-			 const struct utouch_contact *t1,
-			 const struct utouch_contact *t2)
-{
-	const struct grail_element *pslot = slot->prev;
-	const struct utouch_contact *p1 = pslot->touches[0];
-	const struct utouch_contact *p2 = pslot->touches[1];
-	double tx, ty, px, py, d2;
-
-	if (!t1->active || !t2->active) {
-		stop_slot(impl, slot);
-		return;
-	}
-
-	slot->touches[0] = t1;
-	slot->touches[1] = t2;
-	slot->num_touches = 2;
-
-	if (pslot->num_touches != slot->num_touches ||
-	    t1->id != p1->id || t2->id != p2->id) {
-		start_slot(impl, slot, touch);
-		return;
-	}
-
-	tx = t2->x - t1->x;
-	ty = t2->y - t1->y;
-	px = p2->x - p1->x;
-	py = p2->y - p1->y;
-
-	d2 = px * px + py * py;
-	if (d2 > 0) {
-		px /= d2;
-		py /= d2;
-	}
-
-	update_slot(impl, slot, tx * py - ty * px, tx * px + ty * py);
-}
-
-static void set_slot_multi(struct grail_impl *impl,
-			   struct grail_element *slot,
-			   struct grail_frame *frame,
-			   const struct utouch_frame *touch)
-{
-	const struct grail_element *pslot = slot->prev;
-	struct grail_element **slots = frame->slots;
-	int i, j, n = impl->num_touches;
-	struct grail_element *best = 0;
-
-	if (touch->num_active < 3) {
-		stop_slot(impl, slot);
-		return;
-	}
-
-	memcpy(slot->touches, touch->active,
-	       touch->num_active * sizeof(slot->touches[0]));
-	slot->num_touches = touch->num_active;
-
-	if (pslot->num_touches != slot->num_touches) {
-		start_slot(impl, slot, touch);
-		return;
-	}
-
-	for (i = 0; i < slot->num_touches; i++) {
-		if (slot->touches[i]->id != pslot->touches[i]->id) {
-			start_slot(impl, slot, touch);
-			return;
-		}
-	}
-
-	for (i = 0; i < impl->num_touches; i++) {
-		for (j = i + 1; j < impl->num_touches; j++) {
-			struct grail_element *s = slots[n++];
-			if (!s->num_touches)
-				continue;
-			if (!best || s->radius2 > best->radius2)
-				best = s;
-		}
-	}
-
-	update_slot(impl, slot, best->transform[1], best->transform[0]);
-}
-
-/**
- * Determine the center of rotation point.
- *
- * For any given point q that is transformed by a 2D affine transformation
- * matrix T about anchor point P the new point q' may be determined by the
- * following equation:
- *
- * q' = T * (q - P) + P
- *
- * T and P are dependent, so we can modify one and find a new value for the
- * other. We will label the original T and P as T0 and P0, and the new values
- * will be labeled T1 and P1. We can find new values by solving the following
- * equation:
- *
- * q' = T0 * (q - P0) + P0 = T1 * (q - P1) + P1
- *
- * In the calculations below, we use variables for the scalar values
- * that make up T0, P0, T1, and P1:
- *
- * T0: [ a -b c ]  P0: [ x0 ]  T1: [ a -b 0 ]  P1: [ x1 ]
- *     [ b  a d ]      [ y0 ]      [ b  a 0 ]      [ y1 ]
- *     [ 0  0 1 ]      [  0 ]      [ 0  0 1 ]      [  0 ]
- *
- * Note that rotation and scaling are independent of the anchor point, so a and
- * b are equivalent between the transformation matrices.
- *
- * Since we know all the values of T0, P0, and T1, we can calculate the values
- * x1 and y1 in P1.
- */
-static inline int set_center_of_rotation(struct grail_element *e)
-{
-	float a = e->transform[0];
-	float b = e->transform[3];
-	float c = e->transform[2];
-	float d = e->transform[5];
-	float x0 = e->center.x;
-	float y0 = e->center.y;
-	float x1;
-	float y1;
-
-	float div = a*a - 2*a + b*b + 1;
-
-	if (fabsf(div) < 1e-5)
-		return 0;
-
-	x1 = (a*a*x0 - a*(2*x0+c) + b*b*x0 - b*d + c + x0) / div;
-	y1 = (a*a*y0 - a*(2*y0+d) + b*b*y0 + b*c + d + y0) / div;
-
-	e->rotation_center.x = x1;
-	e->rotation_center.y = y1;
-
-	return 1;
-}
-
-static void set_slots(struct grail_impl *impl,
-		      struct grail_frame *frame,
-		      const struct utouch_frame *touch)
-{
-	struct grail_element **slots = frame->slots;
-	struct utouch_contact *const *tc = touch->slots;
-	int i, j, n = 0;
-
-	for (i = 0; i < impl->num_touches; i++)
-		set_slot_one(impl, slots[n++], touch, tc[i]);
-
-	for (i = 0; i < impl->num_touches; i++)
-		for (j = i + 1; j < impl->num_touches; j++)
-			set_slot_two(impl, slots[n++], touch, tc[i], tc[j]);
-
-	set_slot_multi(impl, slots[n++], frame, touch);
-}
-
-static void collect_transforms(struct grail_impl *impl,
-			       struct grail_frame *frame,
-			       const struct utouch_frame *touch)
-{
-	const struct utouch_surface *s = utouch_frame_get_surface(impl->fh);
-	const struct grail_control *ctl = impl->ctl;
-	float d_x = ctl->bar_drag_x * (s->mapped_max_x - s->mapped_min_x);
-	float d_y = ctl->bar_drag_y * (s->mapped_max_y - s->mapped_min_y);
-	float ds2 = ctl->bar_scale * ctl->bar_scale;
-	float dt;
-	int i;
-
-	for (i = 0; i < impl->num_slots; i++) {
-		struct grail_element *s = frame->slots[i];
-
-		if (!s->num_touches)
-			continue;
-
-		set_center_of_rotation(s);
-
-		dt = touch->time - s->start_time;
-		if (dt > ctl->glue_ms) {
-			unsigned int mask = s->active_mask;
-
-			if (fabs(s->drag.x) > d_x)
-				mask |= GRAIL_EXPECT_DRAG_X;
-			if (fabs(s->drag.y) > d_y)
-				mask |= GRAIL_EXPECT_DRAG_Y;
-			if (fabs(s->scale2 - 1) > ds2)
-				mask |= GRAIL_EXPECT_SCALE;
-			if (fabs(s->angle) > ctl->bar_angle)
-				mask |= GRAIL_EXPECT_ANGLE;
-
-			s->active_mask = mask;
-
-			if (dt < ctl->drop_x_ms)
-				mask |= GRAIL_EXPECT_DRAG_X;
-			if (dt < ctl->drop_y_ms)
-				mask |= GRAIL_EXPECT_DRAG_Y;
-			if (dt < ctl->drop_scale_ms)
-				mask |= GRAIL_EXPECT_SCALE;
-			if (dt < ctl->drop_angle_ms)
-				mask |= GRAIL_EXPECT_ANGLE;
-
-			s->expect_mask &= mask;
-		}
-
-		frame->ongoing[frame->num_ongoing++] = s;
-	}
-}
-
-const struct grail_frame GRAIL_PUBLIC *
-grail_pump_frame(grail_handle ge, const struct utouch_frame *touch)
-{
-	struct grail_impl *impl = ge->impl;
-	struct grail_frame *frame = impl->frames[impl->nextframe];
-	const struct grail_frame *prev = frame->prev;
-	int i;
-
-	if (touch->slot_revision == touch->prev->slot_revision &&
-	    !prev->num_ongoing)
-		return 0;
-
-	frame->touch = touch;
-	frame->num_ongoing = 0;
-	for (i = 0; i < impl->num_slots; i++)
-		frame->slots[i]->prev = prev->slots[i];
-
-	set_slots(impl, frame, touch);
-	collect_transforms(impl, frame, touch);
-
-	impl->nextframe = (impl->nextframe + 1) % impl->num_frames;
-
-	return frame;
-}
 
=== removed file 'src/grail-gestures.c'
--- src/grail-gestures.c	2011-10-03 11:14:32 +0000
+++ src/grail-gestures.c	1970-01-01 00:00:00 +0000
@@ -1,219 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include "grail-impl.h"
-#include <math.h>
-
-/* Units of mm or radians */
-static const float FM_SN[DIM_FM] = { 0.13, 0.13, 0.26, 2 * M_PI / 1000 };
-static const float FM_BAR[DIM_FM] = { 2.6, 2.6, 5.2, 2 * M_PI / 50 };
-
-/* Units of ms */
-static const grail_time_t FM_HOLD_MS[DIM_FM] = { 60, 60, 60, 60 };
-static const grail_time_t FM_BAR_MS[DIM_FM] = { 300, 300, 500, 500 };
-static const grail_time_t SAMPLE_MS = 10;
-
-static const float EPS = 1e-3;
-
-static void compute_position(float *x, float *y,
-			     const struct utouch_frame *frame)
-{
-	int i, n = frame->num_active;
-	*x = 0;
-	*y = 0;
-	if (n < 1)
-		return;
-	for (i = 0; i < n; i++) {
-		const struct utouch_contact *t = frame->active[i];
-		*x += t->x;
-		*y += t->y;
-	}
-	*x /= n;
-	*y /= n;
-}
-
-static float compute_radius(float x, float y,
-			    const struct utouch_frame *frame)
-{
-	int i, n = frame->num_active;
-	float r = 0, r2 = 0;
-	if (n < 2)
-		return r;
-	for (i = 0; i < n; i++) {
-		const struct utouch_contact *t = frame->active[i];
-		float dx = t->x - x;
-		float dy = t->y - y;
-		r2 += dx * dx + dy * dy;
-	}
-	r2 /= n;
-	r = sqrt(r2);
-	return r;
-}
-
-static float compute_rotation(float x, float y, float r,
-			      const struct utouch_frame *frame)
-{
-	int i, n = frame->num_active;
-	float da = 0, darc2 = 0;
-	if (n < 2)
-		return da;
-	for (i = 0; i < n; i++) {
-		const struct utouch_contact *t = frame->active[i];
-		const struct utouch_contact *ot = t->prev;
-		float dx = t->x - x;
-		float dy = t->y - y;
-		float mx = t->x - ot->x;
-		float my = t->y - ot->y;
-		darc2 += dx * my - dy * mx;
-	}
-	darc2 /= n;
-	da = darc2 / (r * r);
-	return da;
-}
-
-static void move_reset(struct move_model *m, int i, float x, grail_time_t t)
-{
-	struct filter_model *fm = &m->fm[i];
-	fm->raw_delta = 0;
-	fm->action_delta = 0;
-	fm->velocity = 0;
-	fm->value = x;
-	fm->original = x;
-	fm->original_ms = t;
-	fm->sample = x;
-	fm->sample_ms = t;
-	m->tickle &= ~(1 << i);
-	m->active &= ~(1 << i);
-	m->timeout &= ~(1 << i);
-}
-
-static void move_update(struct move_model *m, int i, float x, grail_time_t t)
-{
-	struct filter_model *fm = &m->fm[i];
-	float dt = t - fm->sample_ms;
-	fm->raw_delta = x - fm->value;
-	fm->action_delta = fm->raw_delta;
-	fm->value = x;
-	if (dt > SAMPLE_MS) {
-		fm->velocity = (x - fm->sample) / dt;
-		fm->sample = x;
-		fm->sample_ms = t;
-	}
-	if (fabs(fm->raw_delta) > EPS)
-		m->tickle |= (1 << i);
-	else
-		m->tickle &= ~(1 << i);
-	if (m->active & (1 << i))
-		return;
-	fm->action_delta = 0;
-	if (fabs(x - fm->original) > fm->bar) {
-		if (t - fm->original_ms > fm->hold_ms) {
-			m->active |= (1 << i);
-			fm->action_delta = x - fm->original;
-		}
-	} else if (t - fm->original_ms > fm->bar_ms) {
-		m->timeout |= (1 << i);
-	}
-}
-
-void gru_init_motion(struct grail *ge)
-{
-	struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
-	struct gesture_recognizer *gru = ge->gru;
-	struct move_model *m = &gru->move;
-	float U[DIM_FM]; /* Device unit dimensions */
-	float P[DIM_FM]; /* Device physical dimensions */
-	int i;
-	U[FM_X] = s->mapped_max_x - s->mapped_min_x;
-	U[FM_Y] = s->mapped_max_y - s->mapped_min_y;
-	U[FM_R] = sqrt(U[FM_X] * U[FM_X] + U[FM_Y] * U[FM_Y]);
-	U[FM_A] = 2 * M_PI;
-	P[FM_X] = s->phys_width;
-	P[FM_Y] = s->phys_height;
-	P[FM_R] = sqrt(P[FM_X] * P[FM_X] + P[FM_Y] * P[FM_Y]);
-	P[FM_A] = 2 * M_PI;
-	for (i = 0; i < DIM_FM; i++) {
-		m->fm[i].fuzz = U[i] * FM_SN[i] / P[i];
-		m->fm[i].bar = U[i] * FM_BAR[i] / P[i];
-		m->fm[i].hold_ms = FM_HOLD_MS[i];
-		m->fm[i].bar_ms = FM_BAR_MS[i];
-	}
-}
-
-void gru_motion(struct grail *ge,
-		const struct utouch_frame *frame)
-{
-	const struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
-	struct gesture_recognizer *gru = ge->gru;
-	struct move_model *m = &gru->move;
-	grail_time_t t = frame->time;
-	float x, y, r, a;
-
-	compute_position(&x, &y, frame);
-	if (frame->prev->revision != frame->revision) {
-		r = compute_radius(x, y, frame);
-		a = 0;
-		move_reset(m, FM_X, x, t);
-		move_reset(m, FM_Y, y, t);
-		move_reset(m, FM_R, r, t);
-		move_reset(m, FM_A, a, t);
-		m->single = 0;
-		m->multi = 0;
-	} else if (frame->num_active < 2) {
-		r = 0;
-		a = 0;
-		move_update(m, FM_X, x, t);
-		move_update(m, FM_Y, y, t);
-		move_reset(m, FM_R, r, t);
-		move_reset(m, FM_A, a, t);
-		m->single = 1;
-		m->multi = 0;
-	} else {
-		r = compute_radius(x, y, frame);
-		a = m->fm[FM_A].value;
-		if (!s->is_semi_mt)
-			a += compute_rotation(x, y, r, frame);
-		move_update(m, FM_X, x, t);
-		move_update(m, FM_Y, y, t);
-		move_update(m, FM_R, r, t);
-		move_update(m, FM_A, a, t);
-		m->single = 0;
-		m->multi = 1;
-	}
-	m->ntouch = frame->num_active;
-	m->time = t;
-}
-
-void gru_event(struct grail *ge, int gid,
-	       const struct move_model *m,
-	       const grail_prop_t *prop, int nprop)
-{
-	gin_gid_event(ge, gid, m->fm[FM_X].value, m->fm[FM_Y].value, m->ntouch,
-		      prop, nprop, 0);
-}
-
-void gru_end(struct grail *ge, int gid, const struct move_model *m,
-	     const grail_prop_t *prop, int nprop)
-{
-	gin_gid_end(ge, gid, m->fm[FM_X].value, m->fm[FM_Y].value, m->ntouch,
-		    prop, nprop);
-}
 
=== removed file 'src/grail-gestures.h'
--- src/grail-gestures.h	2011-05-17 14:15:22 +0000
+++ src/grail-gestures.h	1970-01-01 00:00:00 +0000
@@ -1,115 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_GESTURES_H
-#define GRAIL_GESTURES_H
-
-#include "grail-inserter.h"
-
-#define PRIO_POINTER	1
-#define PRIO_GESTURE	2
-#define PRIO_ENV	3
-#define PRIO_META	4
-#define PRIO_TAP	5
-
-#define DIM_FM		4
-
-#define FM_X		0
-#define FM_Y		1
-#define FM_R		2
-#define FM_A		3
-
-struct filter_model {
-	float raw_delta;
-	float action_delta;
-	float velocity;
-	float value;
-	float original;
-	float sample;
-	float fuzz;
-	float bar;
-	grail_time_t original_ms;
-	grail_time_t sample_ms;
-	grail_time_t hold_ms;
-	grail_time_t bar_ms;
-};
-
-struct move_model {
-	struct filter_model fm[DIM_FM];
-	int tickle, active, timeout;
-	int single, multi, ntouch;
-	grail_time_t time;
-};
-
-void gru_init_motion(struct grail *ge);
-void gru_motion(struct grail *ge,
-		const struct utouch_frame *frame);
-void gru_event(struct grail *ge, int gid,
-	       const struct move_model *move,
-	       const grail_prop_t *prop, int nprop);
-void gru_end(struct grail *ge, int gid,
-	     const struct move_model *move,
-	     const grail_prop_t *prop, int nprop);
-
-struct combo_model {
-	int active, gid;
-	int mintouch, maxtouch;
-	int nprop;
-	grail_prop_t prop[DIM_GRAIL_PROP];
-};
-
-int gru_touch(struct grail *ge,
-	      const struct utouch_frame *frame);
-int gru_drag(struct grail *ge,
-	     const struct utouch_frame *frame);
-int gru_pinch(struct grail *ge,
-	      const struct utouch_frame *frame);
-int gru_rotate(struct grail *ge,
-	       const struct utouch_frame *frame);
-
-static inline int out_of_bounds(const struct combo_model *s,
-				const struct move_model *m)
-{
-	return m->ntouch < s->mintouch || m->ntouch > s->maxtouch;
-}
-
-int gru_wintouch(struct grail *ge,
-		 const struct utouch_frame *frame);
-int gru_windrag(struct grail *ge,
-		const struct utouch_frame *frame);
-int gru_winpinch(struct grail *ge,
-		 const struct utouch_frame *frame);
-int gru_winrotate(struct grail *ge,
-		  const struct utouch_frame *frame);
-
-struct tapping_model {
-	grail_time_t start;
-	int mintouch, maxtouch;
-	int active, gid, tap;
-	int nprop;
-	grail_prop_t prop[DIM_GRAIL_PROP];
-};
-
-int gru_tapping(struct grail *ge,
-		const struct utouch_frame *frame);
-
-#endif
-
 
=== removed file 'src/grail-impl.h'
--- src/grail-impl.h	2011-08-30 15:10:16 +0000
+++ src/grail-impl.h	1970-01-01 00:00:00 +0000
@@ -1,88 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_IMPL_H
-#define GRAIL_IMPL_H
-
-#define MTDEV_NO_LEGACY_API
-#define GRAIL_NO_LEGACY_API
-
-#include <grail.h>
-#include <utouch/frame-mtdev.h>
-#include "evbuf.h"
-#include "grailbuf.h"
-
-#define DIM_TOUCH		32
-#define DIM_TOUCH_BYTES		((DIM_TOUCH + 7) >> 3)
-#define GRAIL_ID_MAX		0xffff
-
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-
-typedef void *grail_select_callback;
-
-/*
- * In this implementation, there can be N one-gestures, N (N - 1) / 2
- * two-gestures, and one global gesture.
- */
-static inline int get_slot_count(int n)
-{
-	return n + n * (n - 1) / 2 + 1;
-}
-
-int create_grail2(struct grail_impl *x,
-		  utouch_frame_handle fh,
-		  unsigned int num_frames,
-		  void *select,
-		  unsigned int version,
-		  unsigned int control_size,
-		  unsigned int frame_size,
-		  unsigned int slot_size);
-
-void destroy_grail2(struct grail_impl *x);
-
-struct grail_impl {
-	struct evemu_device *evemu;
-	struct mtdev *mtdev;
-	utouch_frame_handle fh;
-	const struct utouch_frame *touch;
-	struct evbuf evbuf;
-	struct grailbuf gbuf;
-	int filter_abs;
-	int ongoing;
-	int gesture;
-	FILE *fptest;
-	int fast_fileread;
-	/* new stuff below */
-	struct grail_control *ctl;
-	grail_select_callback select;
-	int num_frames;
-	int num_slots;
-	int num_touches;
-	int nextframe;
-	int seqid;
-	unsigned int control_size;
-	unsigned int frame_size;
-	unsigned int slot_size;
-	struct grail_frame **frames;
-};
-
-#endif
 
=== removed file 'src/grail-init.c'
--- src/grail-init.c	2011-08-31 17:20:48 +0000
+++ src/grail-init.c	1970-01-01 00:00:00 +0000
@@ -1,236 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-impl.h"
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-
-static struct grail_control *create_control(int size)
-{
-	struct grail_control *c = calloc(1, size);
-
-	if (!c)
-		return 0;
-
-	c->glue_ms = 60;
-	c->bar_drag_x = 0.03;
-	c->bar_drag_y = 0.03;
-	c->bar_scale = 0.3;
-	c->bar_angle = 0.1;
-	c->drop_x_ms = 300;
-	c->drop_y_ms = 300;
-	c->drop_scale_ms = 300;
-	c->drop_angle_ms = 300;
-
-	return c;
-}
-
-static void destroy_slots(struct grail_element **slots, int nslot)
-{
-	int i;
-
-	if (slots) {
-		for (i = nslot - 1; i >= 0; i--)
-			free(slots[i]);
-		free(slots);
-	}
-}
-
-static void destroy_frame(struct grail_frame *frame, int nslot)
-{
-	if (frame) {
-		destroy_slots(frame->slots, nslot);
-		free(frame->ongoing);
-		free(frame);
-	}
-}
-
-static void destroy_frames(struct grail_frame **frames, int nframe, int nslot)
-{
-	int i;
-
-	if (frames) {
-		for (i = nframe - 1; i >= 0; i--)
-			destroy_frame(frames[i], nslot);
-		free(frames);
-	}
-}
-
-static struct grail_element **create_slots(int nslot, int ntouch, int size)
-{
-	struct grail_element **slots;
-	struct grail_element *s;
-	int i;
-
-	slots = calloc(nslot, sizeof(slots[0]));
-	if (!slots)
-		return 0;
-
-	for (i = 0; i < nslot; i++) {
-		s = calloc(1, size + ntouch * sizeof(void *));
-		if (!s)
-			goto out;
-		s->slot = i;
-		s->id = -1;
-		s->touches = (void *)((char *)s + size);
-		slots[i] = s;
-	}
-
-	return slots;
- out:
-	destroy_slots(slots, nslot);
-	return 0;
-}
-
-static struct grail_frame *create_frame(int nslot, int ntouch,
-					int frame_size, int slot_size)
-{
-	struct grail_frame *frame;
-
-	frame = calloc(1, frame_size);
-	if (!frame)
-		return 0;
-
-	frame->ongoing = calloc(nslot, sizeof(frame->ongoing[0]));
-	frame->slots = create_slots(nslot, ntouch, slot_size);
-	if (!frame->ongoing || !frame->slots)
-		goto out;
-
-	return frame;
- out:
-	destroy_frame(frame, nslot);
-	return 0;
-}
-
-static struct grail_frame **create_frames(int nframe, int nslot, int ntouch,
-					  int frame_size, int slot_size)
-{
-	struct grail_frame **frames;
-	struct grail_frame *f;
-	int i;
-
-	frames = calloc(nframe, sizeof(frames[0]));
-	if (!frames)
-		return 0;
-
-	for (i = 0; i < nframe; i++) {
-		f = create_frame(nslot, ntouch, frame_size, slot_size);
-		if (!f)
-			goto out;
-		frames[i] = f;
-	}
-
-	return frames;
- out:
-	destroy_frames(frames, nframe, nslot);
-	return 0;
-}
-
-int create_grail2(struct grail_impl *x,
-		  utouch_frame_handle fh,
-		  unsigned int num_frames,
-		  grail_select_callback select,
-		  unsigned int version,
-		  unsigned int control_size,
-		  unsigned int frame_size,
-		  unsigned int slot_size)
-{
-	unsigned int ntouch = utouch_frame_get_num_slots(fh);
-	unsigned int nslot = get_slot_count(ntouch);
-	int i;
-
-	x->select = select;
-	x->control_size = MAX(control_size, sizeof(struct grail_control));
-	x->frame_size = MAX(frame_size, sizeof(struct grail_frame));
-	x->slot_size = MAX(slot_size, sizeof(struct grail_element));
-
-	x->num_frames = num_frames;
-	x->num_slots = nslot;
-	x->num_touches = ntouch;
-
-	x->ctl = create_control(x->control_size);
-	if (!x->ctl)
-		goto freemem;
-
-	x->frames = create_frames(num_frames, nslot, ntouch,
-				  x->frame_size, x->slot_size);
-	if (!x->frames)
-		goto freemem;
-
-	for (i = 0; i < num_frames; i++)
-		x->frames[(i + 1) % num_frames]->prev = x->frames[i];
-
-	return 0;
-
- freemem:
-	destroy_grail2(x);
-	return -ENOMEM;
-}
-
-void destroy_grail2(struct grail_impl *x)
-{
-	destroy_frames(x->frames, x->num_frames, x->num_slots);
-	free(x->ctl);
-}
-
-grail_handle GRAIL_PUBLIC grail_new_raw(utouch_frame_handle fh,
-					unsigned int num_frames,
-					grail_select_callback select,
-					unsigned int version,
-					unsigned int control_size,
-					unsigned int frame_size,
-					unsigned int slot_size)
-{
-	struct grail *ge;
-	struct grail_impl *x;
-
-	ge = calloc(1, sizeof(*ge));
-	if (!ge)
-		return 0;
-	x = calloc(1, sizeof(*x));
-	if (!x)
-		goto out;
-	x->fh = fh;
-	if (create_grail2(x, fh, num_frames, select,
-			  version, control_size, frame_size, slot_size))
-		goto out;
-
-	ge->impl = x;
-	return ge;
-
- out:
-	free(x);
-	free(ge);
-	return 0;
-}
-
-void GRAIL_PUBLIC grail_delete(grail_handle ge)
-{
-	destroy_grail2(ge->impl);
-	free(ge->impl);
-	free(ge);
-}
-
-struct grail_control GRAIL_PUBLIC *grail_get_control(grail_handle ge)
-{
-	return ge->impl->ctl;
-}
 
=== removed file 'src/grail-inserter.c'
--- src/grail-inserter.c	2011-08-31 17:20:48 +0000
+++ src/grail-inserter.c	1970-01-01 00:00:00 +0000
@@ -1,304 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-gestures.h"
-#include "grail-inserter.h"
-#include "grail-impl.h"
-#include <malloc.h>
-#include <string.h>
-#include <errno.h>
-#include <math.h>
-
-static const int MAX_GESTURE_ID = 0xfff;
-
-static int find_gslot(const struct gesture_inserter *gin, int gid)
-{
-	int i;
-	grail_mask_foreach(i, gin->used, sizeof(gin->used))
-		if (gin->state[i].id == gid)
-			return i;
-	return -1;
-}
-
-static int mask_overlap(const grail_mask_t *a, const grail_mask_t *b,
-			int bytes)
-{
-	int i;
-
-	for (i = 0; i < bytes; i++)
-		if (a[i] & b[i])
-			return 1;
-
-	return 0;
-}
-
-// todo: spanning tree for multi-user case
-static void setup_new_gestures(struct grail *ge,
-			       const struct utouch_frame *frame)
-{
-	struct gesture_inserter *gin = ge->gin;
-	grail_mask_t types[DIM_GRAIL_TYPE_BYTES];
-	grail_mask_t span[DIM_TOUCH_BYTES];
-	struct grail_client_info info[DIM_CLIENT];
-	int i, j, nclient = 0;
-	int nfresh = grail_mask_count(gin->fresh, sizeof(gin->fresh));
-	if (!nfresh)
-		return;
-
-	memset(types, 0, sizeof(types));
-	memset(span, 0, sizeof(span));
-
-	grail_mask_foreach(i, gin->fresh, sizeof(gin->fresh)) {
-		struct slot_state *s = &gin->state[i];
-		grail_mask_set(types, s->type);
-		grail_mask_set_mask(span, s->span, sizeof(span));
-	}
-
-	nclient = gin_get_clients(ge, info, DIM_CLIENT, types, sizeof(types),
-				  span, sizeof(span), frame);
-
-	grail_mask_foreach(i, gin->fresh, sizeof(gin->fresh)) {
-		struct slot_state *s = &gin->state[i];
-		s->nclient = 0;
-		for (j = 0; j < nclient; j++) {
-			if (!grail_mask_get(info[j].mask, s->type))
-				continue;
-			if (gin->grab_active &&
-			    info[j].id.client != gin->grab_client)
-				continue;
-			if (grail_mask_get(info[j].mask, GRAIL_TYPE_SYSFLAG1)) {
-				gin->grab_active = 1;
-				gin->grab_client = info[j].id.client;
-			}
-			s->client_id[s->nclient++] = info[j].id;
-		}
-	}
-
-	memset(gin->fresh, 0, sizeof(gin->fresh));
-}
-
-int gin_init(struct grail *ge)
-{
-	struct gesture_inserter *gin;
-	int i;
-	gin = calloc(1, sizeof(*gin));
-	if (!gin)
-		return -ENOMEM;
-	for (i = 0; i < DIM_INSTANCE; i++)
-		grail_mask_set(gin->unused, i);
-	ge->gin = gin;
-	return 0;
-}
-
-void gin_destroy(struct grail *ge)
-{
-	free(ge->gin);
-	ge->gin = NULL;
-}
-
-void gin_frame_begin(struct grail *ge, const struct utouch_frame *frame)
-{
-	struct gesture_inserter *gin = ge->gin;
-	memset(gin->types, 0, sizeof(gin->types));
-	gin->time = frame->time;
-	if (frame->num_active && !frame->prev->num_active)
-		gin->grab_active = 0;
-}
-
-void gin_frame_end(struct grail *ge, const struct utouch_frame *frame)
-{
-	struct gesture_inserter *gin = ge->gin;
-	grail_mask_t keep[DIM_TOUCH_BYTES];
-	int i, hold[2] = { 0, 0 }, discard[2] = { 0, 0 };
-
-	memset(keep, 0, sizeof(keep));
-	setup_new_gestures(ge, frame);
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		if (!s->nclient)
-			continue;
-		if (s->priority > hold[s->slice])
-			hold[s->slice] = s->priority;
-		if (s->status != GRAIL_STATUS_UPDATE)
-			continue;
-		if (s->priority > discard[s->slice])
-			discard[s->slice] = s->priority;
-	}
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		if (!s->nclient || (s->priority < discard[s->slice] && !s->sent))
-			gin_gid_discard(ge, s->id);
-	}
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		if (s->slice == 1)
-			grail_mask_set_mask(keep, s->span, sizeof(keep));
-	}
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		if (!s->timeout)
-			continue;
-		if (mask_overlap(keep, s->span, sizeof(keep)))
-			continue;
-		gin_gid_discard(ge, s->id);
-	}
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		struct gesture_event ev;
-		grail_mask_set(gin->types, s->type);
-		if (s->priority < hold[s->slice] && !s->sent)
-			continue;
-		while (!gebuf_empty(&s->buf)) {
-			gebuf_get(&s->buf, &ev);
-			gin_send_event(ge, s, &ev, frame);
-		}
-		s->sent = 1;
-	}
-
-	grail_mask_foreach(i, gin->used, sizeof(gin->used)) {
-		struct slot_state *s = &gin->state[i];
-		if (s->status == GRAIL_STATUS_END)
-			gin_gid_discard(ge, s->id);
-	}
-}
-
-int gin_gid_begin(struct grail *ge, int type, int priority,
-		  const struct utouch_frame *frame)
-{
-	struct gesture_inserter *gin = ge->gin;
-	struct slot_state *s;
-	int slot;
-	int i = grail_mask_get_first(gin->unused, sizeof(gin->unused));
-	if (i < 0)
-		return -1;
-	s = &gin->state[i];
-	s->type = type;
-	if (priority < 0) {
-		s->priority = -priority;
-		s->slice = 1;
-	} else {
-		s->priority = priority;
-		s->slice = 0;
-	}
-	s->timeout = 0;
-	s->sent = 0;
-	s->id = gin->gestureid++ & MAX_GESTURE_ID;
-	s->status = GRAIL_STATUS_BEGIN;
-	s->nclient = 0;
-	for (slot = 0; slot < DIM_TOUCH; slot++)
-		grail_mask_modify(s->span, slot, frame->slots[slot]->active);
-	gebuf_clear(&s->buf);
-	grail_mask_clear(gin->unused, i);
-	grail_mask_set(gin->fresh, i);
-	grail_mask_set(gin->used, i);
-	return s->id;
-}
-
-void gin_gid_discard(struct grail *ge, int gid)
-{
-	struct gesture_inserter *gin = ge->gin;
-	struct slot_state *s;
-	int i = find_gslot(gin, gid);
-	if (i < 0)
-		return;
-	s = &gin->state[i];
-	gebuf_clear(&s->buf);
-	s->status = GRAIL_STATUS_END;
-	grail_mask_clear(gin->used, i);
-	grail_mask_set(gin->unused, i);
-}
-
-void gin_gid_timeout(struct grail *ge, int gid)
-{
-	int i = find_gslot(ge->gin, gid);
-	if (i >= 0)
-		ge->gin->state[i].timeout = 1;
-}
-
-void gin_gid_event(struct grail *ge, int gid,
-		   float x, float y, int ntouch,
-		   const grail_prop_t *prop, int nprop,
-		   int transient)
-{
-	struct gesture_inserter *gin = ge->gin;
-	struct gesture_event ev;
-	struct slot_state *s;
-	int i = find_gslot(gin, gid);
-	if (i < 0)
-		return;
-	s = &gin->state[i];
-	ev.status = transient ? GRAIL_STATUS_UPDATE : s->status;
-	ev.ntouch = ntouch;
-	ev.nprop = nprop;
-	ev.time = gin->time;
-	ev.pos.x = x;
-	ev.pos.y = y;
-	memcpy(ev.prop, prop, nprop * sizeof(grail_prop_t));
-	gebuf_put(&s->buf, &ev);
-	if (transient)
-		s->status = GRAIL_STATUS_END;
-	else if (s->status == GRAIL_STATUS_BEGIN)
-		s->status = GRAIL_STATUS_UPDATE;
-}
-
-void gin_gid_end(struct grail *ge, int gid,
-		 float x, float y, int ntouch,
-		 const grail_prop_t *prop, int nprop)
-{
-	struct gesture_inserter *gin = ge->gin;
-	struct gesture_event ev;
-	struct slot_state *s;
-	int i = find_gslot(gin, gid);
-	if (i < 0)
-		return;
-	s = &gin->state[i];
-	if (s->status != GRAIL_STATUS_BEGIN) {
-		ev.status = GRAIL_STATUS_END;
-		ev.ntouch = ntouch;
-		ev.nprop = nprop;
-		ev.time = gin->time;
-		ev.pos.x = x;
-		ev.pos.y = y;
-		memcpy(ev.prop, prop, nprop * sizeof(grail_prop_t));
-		gebuf_put(&s->buf, &ev);
-	}
-	s->status = GRAIL_STATUS_END;
-}
-
-void GRAIL_PUBLIC grail_set_bbox(struct grail *ge,
-				 const struct grail_coord *tmin,
-				 const struct grail_coord *tmax)
-{
-	struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
-
-	s->mapped_min_x = tmin->x;
-	s->mapped_min_y = tmin->y;
-	s->mapped_max_x = tmax->x;
-	s->mapped_max_y = tmax->y;
-
-	if (ge->gru)
-		gru_init_motion(ge);
-}
 
=== removed file 'src/grail-inserter.h'
--- src/grail-inserter.h	2011-05-17 14:15:22 +0000
+++ src/grail-inserter.h	1970-01-01 00:00:00 +0000
@@ -1,93 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_INSERTER_H
-#define GRAIL_INSERTER_H
-
-#include "grail-impl.h"
-#include "gebuf.h"
-
-#define DIM_EV_TYPE		EV_CNT
-#define DIM_EV_TYPE_BYTES	((DIM_EV_TYPE + 7) >> 3)
-
-#define DIM_INSTANCE		32
-#define DIM_INSTANCE_BYTES	((DIM_INSTANCE + 7) >> 3)
-
-#define DIM_CLIENT		32
-
-struct slot_state {
-	int type;
-	int priority;
-	int slice;
-	int timeout;
-	int sent;
-	int id;
-	int status;
-	int nclient;
-	struct grail_client_id client_id[DIM_CLIENT];
-	grail_mask_t span[DIM_TOUCH_BYTES];
-	struct gebuf buf;
-};
-
-struct gesture_inserter {
-	struct slot_state state[DIM_INSTANCE];
-	grail_mask_t types[DIM_GRAIL_TYPE_BYTES];
-	grail_mask_t unused[DIM_INSTANCE_BYTES];
-	grail_mask_t fresh[DIM_INSTANCE_BYTES];
-	grail_mask_t used[DIM_INSTANCE_BYTES];
-	grail_time_t time;
-	int gestureid;
-	int grab_active;
-	int grab_client;
-};
-
-int gin_add_contact_props(const struct gesture_inserter *gin,
-			  grail_prop_t *prop, const struct utouch_frame *frame);
-
-int gin_get_clients(struct grail *ge,
-		    struct grail_client_info *info, int maxinfo,
-		    const grail_mask_t* types, int btypes,
-		    const grail_mask_t* span, int bspan,
-		    const struct utouch_frame *frame);
-void gin_send_event(struct grail *ge, struct slot_state *s,
-		    const struct gesture_event *ev,
-		    const struct utouch_frame *frame);
-
-int gin_init(struct grail *ge);
-void gin_destroy(struct grail *ge);
-
-void gin_frame_begin(struct grail *ge, const struct utouch_frame *frame);
-void gin_frame_end(struct grail *ge, const struct utouch_frame *frame);
-
-int gin_gid_begin(struct grail *ge, int type, int priority,
-		  const struct utouch_frame *frame);
-void gin_gid_discard(struct grail *ge, int gid);
-void gin_gid_timeout(struct grail *ge, int gid);
-
-void gin_gid_event(struct grail *ge, int gid,
-		   float x, float y, int ntouch,
-		   const grail_prop_t *prop, int nprop,
-		   int transient);
-void gin_gid_end(struct grail *ge, int gid,
-		 float x, float y, int ntouch,
-		 const grail_prop_t *prop, int nprop);
-
-#endif
 
=== removed file 'src/grail-legacy.c'
--- src/grail-legacy.c	2011-08-31 17:20:48 +0000
+++ src/grail-legacy.c	1970-01-01 00:00:00 +0000
@@ -1,64 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include <grail.h>
-#include "grail-inserter.h"
-#include <string.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <malloc.h>
-#include <errno.h>
-#include <stdlib.h>
-
-#ifndef GRAIL_NO_LEGACY_ABI
-
-void GRAIL_PUBLIC grail_filter_abs_events(struct grail *ge, int usage)
-{
-	struct grail_impl *x = ge->impl;
-	x->filter_abs = usage;
-}
-
-int GRAIL_PUBLIC grail_get_contacts(const struct grail *ge,
-				    struct grail_contact *touch, int max_touch)
-{
-	const struct utouch_frame *frame = ge->impl->touch;
-	int i;
-	if (frame->num_active < max_touch)
-		max_touch = frame->num_active;
-	for (i = 0; i < max_touch; i++) {
-		struct grail_contact *t = &touch[i];
-		const struct utouch_contact *ct = frame->active[i];
-		t->id = ct->id;
-		t->tool_type = ct->tool_type;
-		t->pos.x = ct->x;
-		t->pos.y = ct->y;
-		t->touch_major = ct->touch_major;
-		t->touch_minor = ct->touch_minor;
-		t->width_major = ct->width_major;
-		t->width_minor = ct->width_minor;
-		t->angle = ct->orientation;
-		t->pressure = ct->pressure;
-	}
-	return max_touch;
-}
-
-#endif
 
=== removed file 'src/grail-recognizer.c'
--- src/grail-recognizer.c	2011-04-28 16:53:57 +0000
+++ src/grail-recognizer.c	1970-01-01 00:00:00 +0000
@@ -1,58 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include "grail-recognizer.h"
-#include <string.h>
-#include <malloc.h>
-#include <errno.h>
-
-int gru_init(struct grail *ge)
-{
-	struct gesture_recognizer *gru;
-	gru = calloc(1, sizeof(struct gesture_recognizer));
-	if (!gru)
-		return -ENOMEM;
-	ge->gru = gru;
-	gru_init_motion(ge);
-	return 0;
-}
-
-void gru_destroy(struct grail *ge)
-{
-	free(ge->gru);
-	ge->gru = NULL;
-}
-
-void gru_recognize(struct grail *ge, const struct utouch_frame *frame)
-{
-	if (!ge->gin || !ge->gru)
-		return;
-	gru_motion(ge, frame);
-	gru_touch(ge, frame);
-	gru_drag(ge, frame);
-	gru_pinch(ge, frame);
-	gru_rotate(ge, frame);
-	gru_wintouch(ge, frame);
-	gru_windrag(ge, frame);
-	gru_winpinch(ge, frame);
-	gru_winrotate(ge, frame);
-	gru_tapping(ge, frame);
-}
 
=== removed file 'src/grail-recognizer.h'
--- src/grail-recognizer.h	2011-05-17 14:15:22 +0000
+++ src/grail-recognizer.h	1970-01-01 00:00:00 +0000
@@ -1,44 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_RECOGNIZER_H
-#define GRAIL_RECOGNIZER_H
-
-#include "grail-gestures.h"
-
-struct gesture_recognizer {
-	struct move_model move;
-	struct combo_model touch;
-	struct combo_model drag;
-	struct combo_model pinch;
-	struct combo_model rotate;
-	struct combo_model wintouch;
-	struct combo_model windrag;
-	struct combo_model winpinch;
-	struct combo_model winrotate;
-	struct tapping_model tapping;
-};
-
-int gru_init(struct grail *ge);
-void gru_recognize(struct grail *ge, const struct utouch_frame *frame);
-void gru_destroy(struct grail *ge);
-
-#endif
 
=== removed file 'src/grailbuf.h'
--- src/grailbuf.h	2011-05-17 14:15:22 +0000
+++ src/grailbuf.h	1970-01-01 00:00:00 +0000
@@ -1,59 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010-2011 Canonical Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#ifndef GRAIL_BUFFER_H
-#define GRAIL_BUFFER_H
-
-#include <grail.h>
-
-#define DIM_GRAIL_EVENTS 512
-
-struct grailbuf {
-	int head;
-	int tail;
-	struct grail_event buffer[DIM_GRAIL_EVENTS];
-};
-
-static inline void grailbuf_clear(struct grailbuf *buf)
-{
-	buf->head = buf->tail = 0;
-}
-
-static inline int grailbuf_empty(const struct grailbuf *buf)
-{
-	return buf->head == buf->tail;
-}
-
-static inline void grailbuf_put(struct grailbuf *buf,
-				const struct grail_event *ev)
-{
-	buf->buffer[buf->head++] = *ev;
-	buf->head &= DIM_GRAIL_EVENTS - 1;
-}
-
-static inline void grailbuf_get(struct grailbuf *buf,
-				struct grail_event *ev)
-{
-	*ev = buf->buffer[buf->tail++];
-	buf->tail &= DIM_GRAIL_EVENTS - 1;
-}
-
-#endif
 
=== added directory 'src/v2'
=== added file 'src/v2/evbuf.h'
--- src/v2/evbuf.h	1970-01-01 00:00:00 +0000
+++ src/v2/evbuf.h	2012-01-25 15:53:29 +0000
@@ -0,0 +1,57 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2010-2011 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#ifndef GRAIL_EVBUF_H
+#define GRAIL_EVBUF_H
+
+#define DIM_EVENTS 4096
+
+struct evbuf {
+	int head;
+	int tail;
+	struct input_event buffer[DIM_EVENTS];
+};
+
+static inline void evbuf_clear(struct evbuf *evbuf)
+{
+	evbuf->head = evbuf->tail = 0;
+}
+
+static inline int evbuf_empty(const struct evbuf *evbuf)
+{
+	return evbuf->head == evbuf->tail;
+}
+
+static inline void evbuf_put(struct evbuf *evbuf,
+			     const struct input_event *ev)
+{
+	evbuf->buffer[evbuf->head++] = *ev;
+	evbuf->head &= DIM_EVENTS - 1;
+}
+
+static inline void evbuf_get(struct evbuf *evbuf,
+			     struct input_event *ev)
+{
+	*ev = evbuf->buffer[evbuf->tail++];
+	evbuf->tail &= DIM_EVENTS - 1;
+}
+
+#endif
 
=== added file 'src/v2/gebuf.h'
--- src/v2/gebuf.h	1970-01-01 00:00:00 +0000
+++ src/v2/gebuf.h	2012-01-25 15:53:29 +0000
@@ -0,0 +1,68 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2010-2011 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#ifndef GRAIL_GESTURE_BUFFER_H
+#define GRAIL_GESTURE_BUFFER_H
+
+#include "grail-impl.h"
+
+#define DIM_GESTURE_EVENTS 512
+
+struct gesture_event {
+	int status;
+	int ntouch;
+	int nprop;
+	utouch_frame_time_t time;
+	struct grail_coord pos;
+	grail_prop_t prop[DIM_GRAIL_PROP];
+};
+
+struct gebuf {
+	int head;
+	int tail;
+	struct gesture_event buffer[DIM_GESTURE_EVENTS];
+};
+
+static inline void gebuf_clear(struct gebuf *gebuf)
+{
+	gebuf->head = gebuf->tail = 0;
+}
+
+static inline int gebuf_empty(const struct gebuf *gebuf)
+{
+	return gebuf->head == gebuf->tail;
+}
+
+static inline void gebuf_put(struct gebuf *gebuf,
+			     const struct gesture_event *ev)
+{
+	gebuf->buffer[gebuf->head++] = *ev;
+	gebuf->head &= DIM_GESTURE_EVENTS - 1;
+}
+
+static inline void gebuf_get(struct gebuf *gebuf,
+			     struct gesture_event *ev)
+{
+	*ev = gebuf->buffer[gebuf->tail++];
+	gebuf->tail &= DIM_GESTURE_EVENTS - 1;
+}
+
+#endif
 
=== added file 'src/v2/gestures-drag.c'
--- src/v2/gestures-drag.c	1970-01-01 00:00:00 +0000
+++ src/v2/gestures-drag.c	2012-01-25 15:53:29 +0000
@@ -0,0 +1,135 @@
+/*****************************************************************************
+ *
+ * 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-recognizer.h"
+#include <math.h>
+#include <stdio.h>
+
+static const int getype[DIM_TOUCH + 1] = {
+	-1,
+	GRAIL_TYPE_DRAG1,
+	GRAIL_TYPE_DRAG2,
+	GRAIL_TYPE_DRAG3,
+	GRAIL_TYPE_DRAG4,
+	GRAIL_TYPE_DRAG5,
+};
+
+static void set_props(const struct gesture_inserter *gin,
+		      struct combo_model *s, const struct move_model *m,
+		      const struct utouch_frame *frame)
+{
+	if (m->single) {
+		s->prop[GRAIL_PROP_DRAG_DX] = m->fm[FM_X].raw_delta;
+		s->prop[GRAIL_PROP_DRAG_DY] = m->fm[FM_Y].raw_delta;
+	} else {
+		s->prop[GRAIL_PROP_DRAG_DX] = m->fm[FM_X].action_delta;
+		s->prop[GRAIL_PROP_DRAG_DY] = m->fm[FM_Y].action_delta;
+	}
+	s->prop[GRAIL_PROP_DRAG_VX] = m->fm[FM_X].velocity;
+	s->prop[GRAIL_PROP_DRAG_VY] = m->fm[FM_Y].velocity;
+	s->prop[GRAIL_PROP_DRAG_X] = m->fm[FM_X].value;
+	s->prop[GRAIL_PROP_DRAG_Y] = m->fm[FM_Y].value;
+	s->nprop = 6;
+	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
+}
+
+static const int fm_mask = 0x03;
+
+int gru_drag(struct grail *ge,
+	    const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct combo_model *state = &gru->drag;
+	struct move_model *move = &gru->move;
+	int mask = state->active ? (move->active & fm_mask) : fm_mask;
+	if (!move->multi && !move->single) {
+		if (state->active) {
+			gru_end(ge, state->gid, move,
+				state->prop, state->nprop);
+			state->active = 0;
+		}
+	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_timeout(ge, state->gid);
+		}
+	}
+	if (!state->active) {
+		int type = getype[move->ntouch];
+		if (type < 0)
+			return 0;
+		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
+		state->active = 1;
+	}
+	if (!(move->tickle & mask))
+		return 0;
+	if (!(move->active & fm_mask))
+		return 0;
+	set_props(ge->gin, state, move, frame);
+	gru_event(ge, state->gid, move, state->prop, state->nprop);
+	return 1;
+}
+
+int gru_windrag(struct grail *ge,
+		const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct combo_model *state = &gru->windrag;
+	struct move_model *move = &gru->move;
+	int mask = state->active ? (move->active & fm_mask) : fm_mask;
+	if (!move->multi && !move->single) {
+		if (state->active && out_of_bounds(state, move)) {
+			gru_end(ge, state->gid, move,
+				state->prop, state->nprop);
+			state->active = 0;
+		}
+	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_timeout(ge, state->gid);
+		}
+	}
+	if (!state->active) {
+		if (move->ntouch == 4) {
+			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MDRAG,
+						   PRIO_META, frame);
+			state->mintouch = 1;
+			state->maxtouch = 4;
+			state->active = 1;
+		} else if (move->ntouch == 3) {
+			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EDRAG,
+						   PRIO_ENV, frame);
+			state->mintouch = 1;
+			state->maxtouch = 3;
+			state->active = 1;
+		} else {
+			return 0;
+		}
+	}
+	if (!(move->tickle & mask))
+		return 0;
+	if (!(move->active & fm_mask))
+		return 0;
+	set_props(ge->gin, state, move, frame);
+	gru_event(ge, state->gid, move, state->prop, state->nprop);
+	return 1;
+}
+
 
=== added file 'src/v2/gestures-pinch.c'
--- src/v2/gestures-pinch.c	1970-01-01 00:00:00 +0000
+++ src/v2/gestures-pinch.c	2012-01-25 15:53:29 +0000
@@ -0,0 +1,131 @@
+/*****************************************************************************
+ *
+ * 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-recognizer.h"
+#include <math.h>
+#include <stdio.h>
+
+static const int getype[DIM_TOUCH + 1] = {
+	0,
+	0,
+	GRAIL_TYPE_PINCH2,
+	GRAIL_TYPE_PINCH3,
+	GRAIL_TYPE_PINCH4,
+	GRAIL_TYPE_PINCH5,
+};
+
+static const int fm_mask = 0x04;
+
+static void set_props(const struct gesture_inserter *gin,
+		      struct combo_model *s,
+		      const struct move_model *m,
+		      const struct utouch_frame *frame)
+{
+	s->prop[GRAIL_PROP_PINCH_DR] = m->fm[FM_R].action_delta;
+	s->prop[GRAIL_PROP_PINCH_VR] = m->fm[FM_R].velocity;
+	s->prop[GRAIL_PROP_PINCH_R] = m->fm[FM_R].value;
+	s->prop[GRAIL_PROP_PINCH_X] = m->fm[FM_X].value;
+	s->prop[GRAIL_PROP_PINCH_Y] = m->fm[FM_Y].value;
+	s->nprop = 5;
+	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
+}
+
+int gru_pinch(struct grail *ge,
+	      const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct combo_model *state = &gru->pinch;
+	struct move_model *move = &gru->move;
+	int mask = state->active ? (move->active & fm_mask) : fm_mask;
+	if (!move->multi && !move->single) {
+		if (state->active) {
+			gru_end(ge, state->gid, move,
+				state->prop, state->nprop);
+			state->active = 0;
+		}
+		return 0;
+	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_timeout(ge, state->gid);
+		}
+	}
+	if (!(move->tickle & mask))
+		return 0;
+	if (!state->active) {
+		int type = getype[move->ntouch];
+		if (!type)
+			return 0;
+		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
+		state->active = 1;
+	}
+	if (!(move->active & fm_mask))
+		return 0;
+	set_props(ge->gin, state, move, frame);
+	gru_event(ge, state->gid, move, state->prop, state->nprop);
+	return 1;
+}
+
+int gru_winpinch(struct grail *ge,
+		 const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct combo_model *state = &gru->winpinch;
+	struct move_model *move = &gru->move;
+	int mask = state->active ? (move->active & fm_mask) : fm_mask;
+	if (!move->multi) {
+		if (state->active && out_of_bounds(state, move)) {
+			gru_end(ge, state->gid, move,
+				state->prop, state->nprop);
+			state->active = 0;
+		}
+		return 0;
+	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_timeout(ge, state->gid);
+		}
+	}
+	if (!(move->tickle & mask))
+		return 0;
+	if (!state->active) {
+		if (move->ntouch == 4) {
+			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MPINCH,
+						   PRIO_META, frame);
+			state->mintouch = 2;
+			state->maxtouch = 4;
+			state->active = 1;
+		} else if (move->ntouch == 3) {
+			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EPINCH,
+						   PRIO_ENV, frame);
+			state->mintouch = 2;
+			state->maxtouch = 3;
+			state->active = 1;
+		} else {
+			return 0;
+		}
+	}
+	if (!(move->active & fm_mask))
+		return 0;
+	set_props(ge->gin, state, move, frame);
+	gru_event(ge, state->gid, move, state->prop, state->nprop);
+	return 1;
+}
 
=== added file 'src/v2/gestures-rotate.c'
--- src/v2/gestures-rotate.c	1970-01-01 00:00:00 +0000
+++ src/v2/gestures-rotate.c	2012-01-25 15:53:29 +0000
@@ -0,0 +1,130 @@
+/*****************************************************************************
+ *
+ * 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-recognizer.h"
+#include <math.h>
+#include <stdio.h>
+
+static const int getype[DIM_TOUCH + 1] = {
+	0,
+	0,
+	GRAIL_TYPE_ROTATE2,
+	GRAIL_TYPE_ROTATE3,
+	GRAIL_TYPE_ROTATE4,
+	GRAIL_TYPE_ROTATE5,
+};
+
+static const int fm_mask = 0x08;
+
+static void set_props(const struct gesture_inserter *gin,
+		      struct combo_model *s, const struct move_model *m,
+		      const struct utouch_frame *frame)
+{
+	s->prop[GRAIL_PROP_ROTATE_DA] = m->fm[FM_A].action_delta;
+	s->prop[GRAIL_PROP_ROTATE_VA] = m->fm[FM_A].velocity;
+	s->prop[GRAIL_PROP_ROTATE_A] = m->fm[FM_A].value;
+	s->prop[GRAIL_PROP_ROTATE_X] = m->fm[FM_X].value;
+	s->prop[GRAIL_PROP_ROTATE_Y] = m->fm[FM_Y].value;
+	s->nprop = 5;
+	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
+}
+
+int gru_rotate(struct grail *ge,
+	       const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct combo_model *state = &gru->rotate;
+	struct move_model *move = &gru->move;
+	int mask = state->active ? (move->active & fm_mask) : fm_mask;
+	if (!move->multi && !move->single) {
+		if (state->active) {
+			gru_end(ge, state->gid, move,
+				state->prop, state->nprop);
+			state->active = 0;
+		}
+		return 0;
+	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_timeout(ge, state->gid);
+		}
+	}
+	if (!(move->tickle & mask))
+		return 0;
+	if (!state->active) {
+		int type = getype[move->ntouch];
+		if (!type)
+			return 0;
+		state->gid = gin_gid_begin(ge, type, PRIO_GESTURE, frame);
+		state->active = 1;
+	}
+	if (!(move->active & fm_mask))
+		return 0;
+	set_props(ge->gin, state, move, frame);
+	gru_event(ge, state->gid, move, state->prop, state->nprop);
+	return 1;
+}
+
+int gru_winrotate(struct grail *ge,
+		  const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct combo_model *state = &gru->winrotate;
+	struct move_model *move = &gru->move;
+	int mask = state->active ? (move->active & fm_mask) : fm_mask;
+	if (!move->multi) {
+		if (state->active && out_of_bounds(state, move)) {
+			gru_end(ge, state->gid, move,
+				state->prop, state->nprop);
+			state->active = 0;
+		}
+		return 0;
+	}
+	if ((move->timeout & fm_mask) == fm_mask) {
+		if (state->active) {
+			gin_gid_timeout(ge, state->gid);
+		}
+	}
+	if (!(move->tickle & mask))
+		return 0;
+	if (!state->active) {
+		if (move->ntouch == 4) {
+			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MROTATE,
+						   PRIO_META, frame);
+			state->mintouch = 2;
+			state->maxtouch = 4;
+			state->active = 1;
+		} else if (move->ntouch == 3) {
+			state->gid = gin_gid_begin(ge, GRAIL_TYPE_EROTATE,
+						   PRIO_ENV, frame);
+			state->mintouch = 2;
+			state->maxtouch = 3;
+			state->active = 1;
+		} else {
+			return 0;
+		}
+	}
+	if (!(move->active & fm_mask))
+		return 0;
+	set_props(ge->gin, state, move, frame);
+	gru_event(ge, state->gid, move, state->prop, state->nprop);
+	return 1;
+}
 
=== added file 'src/v2/gestures-tapping.c'
--- src/v2/gestures-tapping.c	1970-01-01 00:00:00 +0000
+++ src/v2/gestures-tapping.c	2012-01-25 15:53:29 +0000
@@ -0,0 +1,100 @@
+/*****************************************************************************
+ *
+ * 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-recognizer.h"
+#include <math.h>
+
+static const int fm_mask = 0x07;
+
+static void set_props(const struct gesture_inserter *gin,
+		      struct tapping_model *s, const struct move_model *m,
+		      const struct utouch_frame *frame)
+{
+	s->prop[GRAIL_PROP_TAP_DT] = m->time - s->start;
+	s->prop[GRAIL_PROP_TAP_X] = m->fm[FM_X].value;
+	s->prop[GRAIL_PROP_TAP_Y] = m->fm[FM_Y].value;
+	s->nprop = 3;
+	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
+}
+
+int gru_tapping(struct grail *ge,
+		const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct tapping_model *state = &gru->tapping;
+	struct move_model *move = &gru->move;
+	state->tap = 0;
+	if (frame->num_active && !frame->prev->num_active) {
+		state->mintouch = 0;
+		state->maxtouch = 0;
+	}
+	if (move->ntouch > state->maxtouch) {
+		if (state->active) {
+			gin_gid_discard(ge, state->gid);
+			state->active = 0;
+		}
+		state->start = move->time;
+		state->maxtouch = move->ntouch;
+		set_props(ge->gin, state, move, frame);
+		if (state->maxtouch <= 5) {
+			int type = GRAIL_TYPE_TAP1 + state->maxtouch - 1;
+			state->gid = gin_gid_begin(ge, type, PRIO_TAP, frame);
+			state->active = 1;
+		}
+		return 0;
+	}
+	if (!state->active) {
+		state->mintouch = move->ntouch;
+		state->maxtouch = move->ntouch;
+		return 0;
+	}
+	if (move->ntouch <= state->mintouch) {
+		int x = state->prop[GRAIL_PROP_TAP_X];
+		int y = state->prop[GRAIL_PROP_TAP_Y];
+		int t = move->time - state->start;
+		if (t > move->fm[FM_X].bar_ms) {
+			gin_gid_discard(ge, state->gid);
+			state->mintouch = move->ntouch;
+			state->maxtouch = move->ntouch;
+			state->active = 0;
+			return 0;
+		}
+		state->tap = state->maxtouch;
+		state->prop[GRAIL_PROP_TAP_DT] = t;
+		gin_gid_event(ge, state->gid, x, y, state->maxtouch,
+			      state->prop, state->nprop, 1);
+		state->mintouch = move->ntouch;
+		state->maxtouch = move->ntouch;
+		state->active = 0;
+		return 1;
+	}
+	if (!move->ntouch)
+		return 0;
+	state->prop[GRAIL_PROP_TAP_DT] = move->time - state->start;
+	if ((move->active & fm_mask) ||
+	    move->time - state->start > move->fm[FM_X].bar_ms) {
+		gin_gid_discard(ge, state->gid);
+		state->mintouch = move->ntouch;
+		state->maxtouch = move->ntouch;
+		state->active = 0;
+	}
+	return 0;
+}
 
=== added file 'src/v2/gestures-touch.c'
--- src/v2/gestures-touch.c	1970-01-01 00:00:00 +0000
+++ src/v2/gestures-touch.c	2012-01-25 15:53:29 +0000
@@ -0,0 +1,98 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2010 Canonical Ltd.
+ * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#include "grail-recognizer.h"
+#include <math.h>
+#include <stdio.h>
+
+static const int getype[DIM_TOUCH + 1] = {
+	-1,
+	GRAIL_TYPE_TOUCH1,
+	GRAIL_TYPE_TOUCH2,
+	GRAIL_TYPE_TOUCH3,
+	GRAIL_TYPE_TOUCH4,
+	GRAIL_TYPE_TOUCH5,
+};
+
+int gru_touch(struct grail *ge,
+	      const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct combo_model *state = &gru->touch;
+	struct move_model *move = &gru->move;
+	if (frame->slot_revision != frame->prev->slot_revision) {
+		if (state->active) {
+			gru_end(ge, state->gid, move,
+				state->prop, state->nprop);
+			state->active = 0;
+		}
+	}
+	if (!state->active) {
+		int type = getype[move->ntouch];
+		if (type <= 0)
+			return 0;
+		state->gid = gin_gid_begin(ge, type, -PRIO_GESTURE, frame);
+		state->active = 1;
+	}
+	if (move->time - move->fm[FM_X].original_ms <= move->fm[FM_X].hold_ms)
+		return 0;
+	state->nprop = gin_add_contact_props(ge->gin, state->prop, frame);
+	gru_event(ge, state->gid, move, state->prop, state->nprop);
+	return 1;
+}
+
+int gru_wintouch(struct grail *ge,
+		 const struct utouch_frame *frame)
+{
+	struct gesture_recognizer *gru = ge->gru;
+	struct combo_model *state = &gru->wintouch;
+	struct move_model *move = &gru->move;
+	if (frame->slot_revision != frame->prev->slot_revision) {
+		if (state->active && out_of_bounds(state, move)) {
+			gru_end(ge, state->gid, move,
+				state->prop, state->nprop);
+			state->active = 0;
+		}
+	}
+	if (!state->active) {
+		if (move->ntouch == 4) {
+			state->gid = gin_gid_begin(ge, GRAIL_TYPE_MTOUCH,
+						   -PRIO_META, frame);
+			state->mintouch = 1;
+			state->maxtouch = 4;
+			state->active = 1;
+		} else if (move->ntouch == 3) {
+			state->gid = gin_gid_begin(ge, GRAIL_TYPE_ETOUCH,
+						   -PRIO_ENV, frame);
+			state->mintouch = 1;
+			state->maxtouch = 3;
+			state->active = 1;
+		} else {
+			return 0;
+		}
+	}
+	if (move->time - move->fm[FM_X].original_ms <= move->fm[FM_X].hold_ms)
+		return 0;
+	state->nprop = gin_add_contact_props(ge->gin, state->prop, frame);
+	gru_event(ge, state->gid, move, state->prop, state->nprop);
+	return 1;
+}
 
=== added file 'src/v2/grail-api.c'
--- src/v2/grail-api.c	1970-01-01 00:00:00 +0000
+++ src/v2/grail-api.c	2012-01-25 15:53:29 +0000
@@ -0,0 +1,328 @@
+/*****************************************************************************
+ *
+ * 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 "grail-inserter.h"
+#include "grail-recognizer.h"
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <malloc.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+
+#define DIM_FRAMES 100
+#define FRAME_RATE 100
+
+unsigned int GRAIL_PUBLIC grail_get_version(void)
+{
+	return GRAIL_VERSION;
+}
+
+int GRAIL_PUBLIC grail_open(struct grail *ge, int fd)
+{
+	struct grail_impl *x;
+	struct stat fs;
+	int ret;
+
+	ret = fstat(fd, &fs);
+	if (ret)
+		return ret;
+
+	x = calloc(1, sizeof(*x));
+	if (!x)
+		return -ENOMEM;
+
+	if (!fs.st_rdev)
+		x->fptest = fdopen(fd, "r");
+
+	x->evemu = evemu_new(x->fptest ? "fptest" : 0);
+	if (!x->evemu) {
+		ret = -ENOMEM;
+		goto freemem;
+	}
+	if (x->fptest)
+		ret = evemu_read(x->evemu, x->fptest) <= 0;
+	else
+		ret = evemu_extract(x->evemu, fd);
+	if (ret)
+		goto freemem;
+	if (!utouch_frame_is_supported_mtdev(x->evemu)) {
+		ret = -ENODEV;
+		goto freemem;
+	}
+
+	if (!x->fptest) {
+		x->mtdev = mtdev_new_open(fd);
+		if (!x->mtdev) {
+			ret = -ENOMEM;
+			goto freemem;
+		}
+	}
+	x->fh = utouch_frame_new_engine(DIM_FRAMES, DIM_TOUCH, FRAME_RATE);
+	if (!x->fh) {
+		ret = -ENOMEM;
+		goto freedev;
+	}
+	ret = utouch_frame_init_mtdev(x->fh, x->evemu);
+	if (ret)
+		goto freeframe;
+
+	ge->impl = x;
+
+	ret = gin_init(ge);
+	if (ret)
+		goto freeframe;
+
+	ret = gru_init(ge);
+	if (ret)
+		goto freegin;
+
+	return 0;
+ freegin:
+	gin_destroy(ge);
+ freeframe:
+	utouch_frame_delete_engine(x->fh);
+ freedev:
+	if (x->mtdev)
+		mtdev_close_delete(x->mtdev);
+ freemem:
+	evemu_delete(x->evemu);
+	if (x->fptest)
+		fclose(x->fptest);
+	free(x);
+	ge->impl = 0;
+	return ret;
+}
+
+void GRAIL_PUBLIC grail_close(struct grail *ge, int fd)
+{
+	struct grail_impl *x = ge->impl;
+	gru_destroy(ge);
+	gin_destroy(ge);
+	utouch_frame_delete_engine(x->fh);
+	if (x->mtdev)
+		mtdev_close_delete(x->mtdev);
+	evemu_delete(x->evemu);
+	if (x->fptest)
+		fclose(x->fptest);
+	free(x);
+	ge->impl = 0;
+}
+
+int GRAIL_PUBLIC grail_idle(struct grail *ge, int fd, int ms)
+{
+	struct grail_impl *x = ge->impl;
+	if (x->fptest)
+		return 0;
+	if (x->mtdev)
+		return mtdev_idle(x->mtdev, fd, ms);
+	return 1;
+}
+
+void GRAIL_PUBLIC grail_get_units(const struct grail *ge,
+				  struct grail_coord *min, struct grail_coord *max)
+{
+	struct utouch_surface *s = utouch_frame_get_surface(ge->impl->fh);
+	min->x = s->min_x;
+	min->y = s->min_y;
+	max->x = s->max_x;
+	max->y = s->max_y;
+}
+
+const struct utouch_frame GRAIL_PUBLIC *
+grail_get_contact_frame(const struct grail *ge)
+{
+	return ge->impl->touch;
+}
+
+static void flush_events(struct grail *ge)