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

[Henrik Rydberg]

The last big change before release

1. Simplify the touch frame handling
2. Add the grail_get_contacts() function to the api
3. Simplify property scaling
4. Add information about the five first contacts to the property list

Point 4 is a suboptimal solution to bring individual touches to unity. The rest
are simplifications to accommodate the changes needed.

[Chase Douglas (chasedouglas)]

I hadn't reviewed grail before, so I tried to do so before looking at the changes. I think I understand some of the basic concepts of how grail works, and the changes in this merge request seem good.

review: Approve

[Chase Douglas (chasedouglas)]

Hrm, I reviewed the code changes and everything seemed ok. I then tried to make a tarball with make dist and I hit a snag. Revision 58 adds touch-caps.c to src/Makefile.am, but the file doesn't exist. I tried to fix this in lp:~chasedouglas/utouch-grail/trunk. However, now I get compile errors. I also got a different compile error when I imported into a local package branch and attempted to build.

One thing to note: don't even try to rewrite history in bzr. I just tried to find ways for the past two hours, and I haven't found anything that worked.

review: Needs Fixing

[Henrik Rydberg (rydberg)]

On 08/20/2010 02:57 AM, Chase Douglas wrote:

> Review: Needs Fixing
> Hrm, I reviewed the code changes and everything seemed ok. I then tried to make a tarball with make dist and I hit a snag. Revision 58 adds touch-caps.c to src/Makefile.am, but the file doesn't exist. I tried to fix this in lp:~chasedouglas/utouch-grail/trunk. However, now I get compile errors. I also got a different compile error when I imported into a local package branch and attempted to build.
>
> One thing to note: don't even try to rewrite history in bzr. I just tried to find ways for the past two hours, and I haven't found anything that worked.

Thanks for finding this, new version uploaded.

Henrik

=== modified file 'configure.ac'
--- configure.ac	2010-08-12 15:56:04 +0000
+++ configure.ac	2010-08-19 20:46:41 +0000
@@ -1,7 +1,7 @@
 # Initialize Autoconf
 AC_PREREQ([2.60])
 AC_INIT([Gesture Recognition And Instantiation Library],
-        [1.0.8],
+        [1.0.9],
         [],
         [utouch-grail])
 AC_CONFIG_SRCDIR([Makefile.am])

=== modified file 'include/grail-touch.h'
--- include/grail-touch.h	2010-08-06 20:30:20 +0000
+++ include/grail-touch.h	2010-08-19 20:46:41 +0000
@@ -29,27 +29,20 @@
 #define DIM_TOUCH 32
 #define DIM_TOUCH_BYTES ((DIM_TOUCH + 7) >> 3)
 
-typedef int touch_prop_t;
 typedef __u64 touch_time_t;
 
-enum touch_prop_list {
-	TP_POS_X,
-	TP_POS_Y,
-	TP_TOUCH_MAJOR,
-	TP_TOUCH_MINOR,
-	TP_WIDTH_MAJOR,
-	TP_WIDTH_MINOR,
-	TP_ORIENTATION,
-	TP_PRESSURE,
-	DIM_TOUCH_PROP
-};
-
-#define DIM_TOUCH_PROP_BYTES ((DIM_TOUCH_PROP + 7) >> 3)
-
 struct touch {
 	int active;
 	int slot;
-	touch_prop_t prop[DIM_TOUCH_PROP];
+	int id;
+	int tool_type;
+	int x, y;
+	int touch_major;
+	int touch_minor;
+	int width_major;
+	int width_minor;
+	int orientation;
+	int pressure;
 };
 
 struct touch_frame {
@@ -61,45 +54,31 @@
 	struct touch touch[DIM_TOUCH];
 };
 
-struct touch_dev_caps {
-	grail_mask_t mask[DIM_TOUCH_PROP_BYTES];
-	struct input_absinfo info[DIM_TOUCH_PROP];
+struct touch_caps {
+	float min_x, max_x;
+	float min_y, max_y;
+	float min_orient, max_orient;
+	float min_press, max_press;
 };
 
 struct touch_dev {
 	void (*event)(struct touch_dev *dev, const struct input_event *ev);
-	void (*create)(struct touch_dev *dev, int slot,
-		       const grail_mask_t *mask, const touch_prop_t *prop);
-	void (*modify)(struct touch_dev *dev, int slot,
-		       const grail_mask_t *mask, const touch_prop_t *prop);
-	void (*destroy)(struct touch_dev *dev, int slot);
 	void (*sync)(struct touch_dev *dev, const struct input_event *syn);
-	struct touch_dev_caps caps;
-	struct touch_dev_impl *impl;
 	void *priv;
-};
-
-struct touch_engine {
-	void (*event)(struct touch_engine *engine,
-		      const struct input_event *ev);
-	void (*sync)(struct touch_engine *engine,
-		     const struct input_event *syn);
+	struct mtdev mtdev;
 	struct touch_frame frame;
-	void *priv;
+	struct touch_caps caps;
+	int slot;
+	int state;
 };
 
+void touch_caps_init(struct touch_dev *dev);
+float touch_angle(const struct touch_dev *dev, int orientation);
+float touch_pressure(const struct touch_dev *dev, int pressure);
+
 int touch_dev_open(struct touch_dev *dev, int fd);
 int touch_dev_idle(struct touch_dev *dev, int fd, int ms);
 int touch_dev_pull(struct touch_dev *dev, int fd);
 void touch_dev_close(struct touch_dev *dev, int fd);
 
-void touch_engine_init(struct touch_engine *engine,
-		       void (*event)(struct touch_engine *engine,
-				     const struct input_event *ev),
-		       void (*sync)(struct touch_engine *engine,
-				    const struct input_event *ev),
-		       void *priv);
-void touch_engine_attach(struct touch_engine *engine, struct touch_dev *dev);
-void touch_engine_detach(struct touch_engine *engine, struct touch_dev *dev);
-
 #endif

=== modified file 'include/grail-types.h'
--- include/grail-types.h	2010-08-11 17:07:08 +0000
+++ include/grail-types.h	2010-08-19 20:46:41 +0000
@@ -57,15 +57,40 @@
 #define GRAIL_TYPE_MPINCH	24	/* four-finger meta drag */
 #define GRAIL_TYPE_MROTATE	25	/* four-finger meta drag */
 
+#define GRAIL_TYPE_SYSFLAG1	26	/* reserved system flag */
+
 #define GRAIL_MAIN_DRAG		0
+#define GRAIL_MAIN_PINCH	1
+#define GRAIL_MAIN_ROTATE	2
+#define GRAIL_MAIN_TAP		3
+#define GRAIL_MAIN_SYSFLAG	4
+
 #define GRAIL_PROP_DRAG_DX	0	/* horizontal position delta */
 #define GRAIL_PROP_DRAG_DY	1	/* vertical position delta */
 #define GRAIL_PROP_DRAG_VX	2	/* horizontal velocity */
 #define GRAIL_PROP_DRAG_VY	3	/* vertical velocity */
 #define GRAIL_PROP_DRAG_X	4	/* horizontal position */
 #define GRAIL_PROP_DRAG_Y	5	/* vertical position */
+#define GRAIL_PROP_DRAG_X1	6	/* bounding box x1 */
+#define GRAIL_PROP_DRAG_Y1	7	/* bounding box y1 */
+#define GRAIL_PROP_DRAG_X2	8	/* bounding box x2 */
+#define GRAIL_PROP_DRAG_Y2	9	/* bounding box y2 */
+#define GRAIL_PROP_DRAG_ID_T0	10	/* first touch id */
+#define GRAIL_PROP_DRAG_X_T0	11	/* first touch horizontal position */
+#define GRAIL_PROP_DRAG_Y_T0	12	/* first touch vertical position */
+#define GRAIL_PROP_DRAG_ID_T1	13
+#define GRAIL_PROP_DRAG_X_T1	14
+#define GRAIL_PROP_DRAG_Y_T1	15
+#define GRAIL_PROP_DRAG_ID_T2	16
+#define GRAIL_PROP_DRAG_X_T2	17
+#define GRAIL_PROP_DRAG_Y_T2	18
+#define GRAIL_PROP_DRAG_ID_T3	19
+#define GRAIL_PROP_DRAG_X_T3	20
+#define GRAIL_PROP_DRAG_Y_T3	21
+#define GRAIL_PROP_DRAG_ID_T4	22
+#define GRAIL_PROP_DRAG_X_T4	23
+#define GRAIL_PROP_DRAG_Y_T4	24
 
-#define GRAIL_MAIN_PINCH	1
 #define GRAIL_PROP_PINCH_DR	0	/* radius delta */
 #define GRAIL_PROP_PINCH_VR	1	/* radial velocity */
 #define GRAIL_PROP_PINCH_R	2	/* radius */
@@ -73,8 +98,22 @@
 #define GRAIL_PROP_PINCH_Y1	4	/* bounding box y1 */
 #define GRAIL_PROP_PINCH_X2	5	/* bounding box x2 */
 #define GRAIL_PROP_PINCH_Y2	6	/* bounding box y2 */
+#define GRAIL_PROP_PINCH_ID_T0	7	/* first touch id */
+#define GRAIL_PROP_PINCH_X_T0	8	/* first touch horizontal position */
+#define GRAIL_PROP_PINCH_Y_T0	9	/* first touch vertical position */
+#define GRAIL_PROP_PINCH_ID_T1	10
+#define GRAIL_PROP_PINCH_X_T1	11
+#define GRAIL_PROP_PINCH_Y_T1	12
+#define GRAIL_PROP_PINCH_ID_T2	13
+#define GRAIL_PROP_PINCH_X_T2	14
+#define GRAIL_PROP_PINCH_Y_T2	15
+#define GRAIL_PROP_PINCH_ID_T3	16
+#define GRAIL_PROP_PINCH_X_T3	17
+#define GRAIL_PROP_PINCH_Y_T3	18
+#define GRAIL_PROP_PINCH_ID_T4	19
+#define GRAIL_PROP_PINCH_X_T4	20
+#define GRAIL_PROP_PINCH_Y_T4	21
 
-#define GRAIL_MAIN_ROTATE	2
 #define GRAIL_PROP_ROTATE_DA	0	/* angle delta */
 #define GRAIL_PROP_ROTATE_VA	1	/* angular velocity */
 #define GRAIL_PROP_ROTATE_A	2	/* angle */
@@ -82,10 +121,44 @@
 #define GRAIL_PROP_ROTATE_Y1	4	/* bounding box y1 */
 #define GRAIL_PROP_ROTATE_X2	5	/* bounding box x2 */
 #define GRAIL_PROP_ROTATE_Y2	6	/* bounding box y2 */
+#define GRAIL_PROP_ROTATE_ID_T0	7	/* first touch id */
+#define GRAIL_PROP_ROTATE_X_T0	8	/* first touch horizontal position */
+#define GRAIL_PROP_ROTATE_Y_T0	9	/* first touch vertical position */
+#define GRAIL_PROP_ROTATE_ID_T1	10
+#define GRAIL_PROP_ROTATE_X_T1	11
+#define GRAIL_PROP_ROTATE_Y_T1	12
+#define GRAIL_PROP_ROTATE_ID_T2	13
+#define GRAIL_PROP_ROTATE_X_T2	14
+#define GRAIL_PROP_ROTATE_Y_T2	15
+#define GRAIL_PROP_ROTATE_ID_T3	16
+#define GRAIL_PROP_ROTATE_X_T3	17
+#define GRAIL_PROP_ROTATE_Y_T3	18
+#define GRAIL_PROP_ROTATE_ID_T4	19
+#define GRAIL_PROP_ROTATE_X_T4	20
+#define GRAIL_PROP_ROTATE_Y_T4	21
 
-#define GRAIL_MAIN_TAP		3
 #define GRAIL_PROP_TAP_DT	0	/* tap time (ms) */
 #define GRAIL_PROP_TAP_X	1	/* horizontal position */
 #define GRAIL_PROP_TAP_Y	2	/* vertical position */
+#define GRAIL_PROP_TAP_X1	3	/* bounding box x1 */
+#define GRAIL_PROP_TAP_Y1	4	/* bounding box y1 */
+#define GRAIL_PROP_TAP_X2	5	/* bounding box x2 */
+#define GRAIL_PROP_TAP_Y2	6	/* bounding box y2 */
+#define GRAIL_PROP_TAP_ID_T0	7	/* first touch id */
+#define GRAIL_PROP_TAP_X_T0	8	/* first touch horizontal position */
+#define GRAIL_PROP_TAP_Y_T0	9	/* first touch vertical position */
+#define GRAIL_PROP_TAP_ID_T1	10
+#define GRAIL_PROP_TAP_X_T1	11
+#define GRAIL_PROP_TAP_Y_T1	12
+#define GRAIL_PROP_TAP_ID_T2	13
+#define GRAIL_PROP_TAP_X_T2	14
+#define GRAIL_PROP_TAP_Y_T2	15
+#define GRAIL_PROP_TAP_ID_T3	16
+#define GRAIL_PROP_TAP_X_T3	17
+#define GRAIL_PROP_TAP_Y_T3	18
+#define GRAIL_PROP_TAP_ID_T4	19
+#define GRAIL_PROP_TAP_X_T4	20
+#define GRAIL_PROP_TAP_Y_T4	21
+
 
 #endif

=== modified file 'include/grail.h'
--- include/grail.h	2010-08-11 17:07:40 +0000
+++ include/grail.h	2010-08-19 20:46:41 +0000
@@ -30,30 +30,92 @@
 #define DIM_GRAIL_TYPE		64
 #define DIM_GRAIL_TYPE_BYTES	((DIM_GRAIL_TYPE + 7) >> 3)
 
-#define DIM_GRAIL_PROP		16
+#define DIM_GRAIL_PROP		32
 #define DIM_GRAIL_PROP_BYTES	((DIM_GRAIL_PROP + 7) >> 3)
 
 #define GRAIL_STATUS_BEGIN	0
 #define GRAIL_STATUS_UPDATE	1
 #define GRAIL_STATUS_END	2
 
-typedef float grail_prop_t;
-typedef __u64 grail_time_t;
+typedef float grail_prop_t;		/* gesture properties */
+typedef __u64 grail_time_t;		/* time in milliseconds */
 
+/**
+ * struct grail_coord - coordinate in bounding box units
+ * @x: the horizontal position (bbox units)
+ * @y: the vertical position (bbox units)
+ */
 struct grail_coord {
 	float x, y;
 };
 
+/**
+ * struct grail_contact - MT event information in bounding box units
+ * @id: Contact tracking id
+ * @tool_type: Tool type (ABS_MT_TOOL_TYPE)
+ * @pos: Position of contact (bbox units)
+ * @touch_major: Major axis of contact shape (bbox units)
+ * @touch_minor: Minor axis of contact shape (bbox units)
+ * @width_major: Major axis of perimeter (bbox units)
+ * @width_minor: Minor axis of perimeter (bbox units)
+ * @angle: Angle of orientation (vertical: 0 horizontal: +-M_PI_2)
+ * @pressure: Pressure of contact (min: 0 max: 1)
+ *
+ * Depending on the native support of the underlying device, some or all of
+ * the listed properties may be computed.
+ */
+struct grail_contact {
+	int id;
+	int tool_type;
+	struct grail_coord pos;
+	float touch_major;
+	float touch_minor;
+	float width_major;
+	float width_minor;
+	float angle;
+	float pressure;
+};
+
+/**
+ * struct grail_client_id - Gesture client information
+ * @client: Client id
+ * @root: Root window
+ * @event: Window to route events to
+ * @child: Window the event occured in
+ *
+ * This struct is treated opaquely, and only has meaning to the gesture
+ * client. Details are subject to change.
+ */
 struct grail_client_id {
 	int client;
 	int root, event, child;
 };
 
+/**
+ * struct grail_client_info - Gesture request information
+ * @id: Gesture client id
+ * @mask: Gestures the client is listening to
+ */
 struct grail_client_info {
 	struct grail_client_id id;
 	grail_mask_t mask[DIM_GRAIL_TYPE_BYTES];
 };
 
+/**
+ * struct grail_event - Gesture event
+ * @type: The gesture type
+ * @id: Unique identifier foof the gesture instance
+ * @status: Gesture status (begin, update, end)
+ * @ntouch: Number of current touches
+ * @nprop: Number of properties in the gesture
+ * @pos: Focus point of the gesture (bbox coordinates)
+ * @touch: Array of individual touch information
+ * @client_id: The gesture client to route the gesture to
+ * @time: Time of event (milliseconds)
+ * @prop: Array of properties of the event
+ *
+ * Gesture events are passed to the client via the gesture() callback.
+ */
 struct grail_event {
 	int type;
 	int id;
@@ -66,6 +128,25 @@
 	grail_prop_t prop[DIM_GRAIL_PROP];
 };
 
+/**
+ * struct grail - Main grail device
+ * @get_clients: Called at the onset of new gestures to retrieve the list
+ * of listening clients.
+ * @event: Callback for kernel events passing through grail.
+ * @gesture: Main gesture callback.
+ * @impl: Grail implementation details.
+ * @gin: Gesture instatiation details.
+ * @gru: Gesture recognition details.
+ * @priv: Generic pointer to user-defined content.
+ *
+ * The grail device pulls events from the underlying device, detects
+ * gestures, and passes them on to the client via the gesture()
+ * callback. Events that are not gesture or for other reasons held back are
+ * passed on via the event() callback. The user provides information about
+ * windows and listening clients via the get_clients callback, which is
+ * called during gesture instantiation.
+ *
+ */
 struct grail {
 	int (*get_clients)(struct grail *ge,
 			   struct grail_client_info *client, int max_clients,
@@ -81,18 +162,108 @@
 	void *priv;
 };
 
+/**
+ * grail_open - open a grail device
+ * @ge: the grail device to open
+ * @fd: file descriptor of the kernel device
+ *
+ * Initialize the internal grail structures and configure it by reading the
+ * protocol capabilities through the file descriptor.
+ *
+ * The callbacks, parameters and priv pointer should be set prior to this
+ * call.
+ *
+ * Returns zero on success, negative error number otherwise.
+ */
 int grail_open(struct grail *ge, int fd);
+
+/**
+ * grail_idle - check state of kernel device
+ * @ge: the grail device in use
+ * @fd: file descriptor of the kernel device
+ * @ms: number of milliseconds to wait for activity
+ *
+ * Returns true if the device is idle, i.e., there are no fetched
+ * events in the pipe and there is nothing to fetch from the device.
+ */
 int grail_idle(struct grail *ge, int fd, int ms);
+
+/**
+ * grail_pull - pull and process available events from the kernel device
+ * @ge: the grail device in use
+ * @fd: file descriptor of the kernel device
+ *
+ * Pull all available events and process them. The grail callbacks are
+ * invoked during this call.
+ *
+ * The underlying file descriptor must have O_NONBLOCK set, or this method
+ * will not return until the file is closed.
+ *
+ * On success, returns the number of events read. Otherwise,
+ * a standard negative error number is returned.
+ */
 int grail_pull(struct grail *ge, int fd);
+
+/**
+ * grail_close - close the grail device
+ * @ge: the grail device to close
+ * @fd: file descriptor of the kernel device
+ *
+ * Deallocates all memory associated with grail, and clears the grail
+ * structure.
+ */
 void grail_close(struct grail *ge, int fd);
 
+/**
+ * grail_set_bbox - set the grail unit bounding box
+ * @ge: the grail device in use
+ * @min: the minimum (lower-left) corner of the bounding box
+ * @max: the maximum (upper-right) corner of the bounding box
+ *
+ * Sets the box within which the device coordinates should be presented.
+ */
 void grail_set_bbox(struct grail *ge,
 		    const struct grail_coord *min,
 		    const struct grail_coord *max);
 
+/**
+ * grail_filter_abs_events - filter kernel motion events
+ * @ge: the grail device in use
+ * @usage: When true, filter kernel motion events.
+ *
+ * Single-finger pointer events are treated as pointer gestures in
+ * grail. When filter_motion_events is non-zero, the kernel events
+ * corresponding to pointer movement are removed from the event
+ * stream.
+ *
+ */
+void grail_filter_abs_events(struct grail *ge, int usage);
+
+/**
+ * grail_get_units - get device coordinate ranges
+ * @ge: the grail device in use
+ * @min: minimum x and y coordinates
+ * @max: maximum x and y coordinates
+ *
+ * The grail event attributes pos, touch_major, touch_minor,
+ * width_major, and width_minor are all given in device coordinate
+ * units, unless specified otherwise using the grail_set_bbox()
+ * function. This function reports the device coordinate ranges.
+ *
+ */
 void grail_get_units(const struct grail *ge,
 		     struct grail_coord *min, struct grail_coord *max);
 
-void grail_filter_abs_events(struct grail *ge, int usage);
+/**
+ * grail_get_contacts - get current contact state
+ * @ge: the grail device in use
+ * @touch: array of contacts to be filled in
+ * @max_touch: maximum number of contacts supported by the array
+ *
+ * Extract the contact state as currently seen by grail.
+ *
+ */
+int grail_get_contacts(const struct grail *ge,
+		       struct grail_contact *touch, int max_touch);
 
 #endif

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2010-08-12 15:55:30 +0000
+++ src/Makefile.am	2010-08-19 20:46:41 +0000
@@ -9,7 +9,7 @@
 	evbuf.h \
 	gebuf.h \
 	touch-dev.c \
-	touch-engine.c \
+	touch-caps.c \
 	grail-bits.c \
 	grail-inserter.c \
 	grail-inserter.h \
@@ -21,6 +21,7 @@
 	gestures-tapping.c \
 	grail-recognizer.c \
 	grail-recognizer.h \
+	grail-event.c \
 	grail-api.c
 
 AM_CFLAGS = $(CWARNFLAGS)

=== modified file 'src/gestures-drag.c'
--- src/gestures-drag.c	2010-08-11 17:04:45 +0000
+++ src/gestures-drag.c	2010-08-19 20:46:41 +0000
@@ -33,20 +33,27 @@
 	GRAIL_TYPE_DRAG5,
 };
 
-static void set_props(struct combo_model *s, const struct move_model *m)
+static void set_props(const struct gesture_inserter *gin,
+		      struct combo_model *s, const struct move_model *m,
+		      const struct touch_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;
+		s->prop[GRAIL_PROP_DRAG_DX] =
+			gin->scale_x * m->fm[FM_X].raw_delta;
+		s->prop[GRAIL_PROP_DRAG_DY] =
+			gin->scale_y * 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_DX] =
+			gin->scale_x * m->fm[FM_X].action_delta;
+		s->prop[GRAIL_PROP_DRAG_DY] =
+			gin->scale_y * 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->prop[GRAIL_PROP_DRAG_VX] = gin->scale_x * m->fm[FM_X].velocity;
+	s->prop[GRAIL_PROP_DRAG_VY] = gin->scale_y * m->fm[FM_Y].velocity;
+	s->prop[GRAIL_PROP_DRAG_X] = gin_prop_x(gin, m->fm[FM_X].value);
+	s->prop[GRAIL_PROP_DRAG_Y] = gin_prop_y(gin, 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;
@@ -77,7 +84,7 @@
 	}
 	if (!move->single && !(move->active & fm_mask))
 		return 0;
-	set_props(state, move);
+	set_props(ge->gin, state, move, frame);
 	gru_event(ge, state->gid, move, state->prop, state->nprop);
 	return 1;
 }
@@ -118,7 +125,7 @@
 	}
 	if (!move->single && !(move->active & fm_mask))
 		return 0;
-	set_props(state, move);
+	set_props(ge->gin, state, move, frame);
 	gru_event(ge, state->gid, move, state->prop, state->nprop);
 	return 1;
 }

=== modified file 'src/gestures-pinch.c'
--- src/gestures-pinch.c	2010-08-11 17:06:36 +0000
+++ src/gestures-pinch.c	2010-08-19 20:46:41 +0000
@@ -35,23 +35,16 @@
 
 static const int fm_mask = 0x04;
 
-static void set_props(struct combo_model *s,
+static void set_props(const struct gesture_inserter *gin,
+		      struct combo_model *s,
 		      const struct move_model *m,
 		      const struct touch_frame *frame)
 {
-	struct grail_coord min, max;
-	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_DR] = gin->scale_r * m->fm[FM_R].action_delta;
+	s->prop[GRAIL_PROP_PINCH_VR] = gin->scale_r * m->fm[FM_R].velocity;
+	s->prop[GRAIL_PROP_PINCH_R] = gin->scale_r * m->fm[FM_R].value;
 	s->nprop = 3;
-	if (!frame->nactive)
-		return;
-	gru_compute_bbox(&min, &max, frame);
-	s->prop[GRAIL_PROP_PINCH_X1] = min.x;
-	s->prop[GRAIL_PROP_PINCH_Y1] = min.y;
-	s->prop[GRAIL_PROP_PINCH_X2] = max.x;
-	s->prop[GRAIL_PROP_PINCH_Y2] = max.y;
-	s->nprop = 7;
+	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
 }
 
 int gru_pinch(struct grail *ge,
@@ -80,7 +73,7 @@
 	}
 	if (!(move->active & fm_mask))
 		return 0;
-	set_props(state, move, frame);
+	set_props(ge->gin, state, move, frame);
 	gru_event(ge, state->gid, move, state->prop, state->nprop);
 	return 1;
 }
@@ -121,7 +114,7 @@
 	}
 	if (!(move->active & fm_mask))
 		return 0;
-	set_props(state, move, frame);
+	set_props(ge->gin, state, move, frame);
 	gru_event(ge, state->gid, move, state->prop, state->nprop);
 	return 1;
 }

=== modified file 'src/gestures-rotate.c'
--- src/gestures-rotate.c	2010-08-11 17:07:08 +0000
+++ src/gestures-rotate.c	2010-08-19 20:46:41 +0000
@@ -35,22 +35,15 @@
 
 static const int fm_mask = 0x08;
 
-static void set_props(struct combo_model *s, const struct move_model *m,
+static void set_props(const struct gesture_inserter *gin,
+		      struct combo_model *s, const struct move_model *m,
 		      const struct touch_frame *frame)
 {
-	struct grail_coord min, max;
 	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->nprop = 3;
-	if (!frame->nactive)
-		return;
-	gru_compute_bbox(&min, &max, frame);
-	s->prop[GRAIL_PROP_ROTATE_X1] = min.x;
-	s->prop[GRAIL_PROP_ROTATE_Y1] = min.y;
-	s->prop[GRAIL_PROP_ROTATE_X2] = max.x;
-	s->prop[GRAIL_PROP_ROTATE_Y2] = max.y;
-	s->nprop = 7;
+	s->nprop += gin_add_contact_props(gin, s->prop + s->nprop, frame);
 }
 
 int gru_rotate(struct grail *ge,
@@ -79,7 +72,7 @@
 	}
 	if (!(move->active & fm_mask))
 		return 0;
-	set_props(state, move, frame);
+	set_props(ge->gin, state, move, frame);
 	gru_event(ge, state->gid, move, state->prop, state->nprop);
 	return 1;
 }
@@ -120,7 +113,7 @@
 	}
 	if (!(move->active & fm_mask))
 		return 0;
-	set_props(state, move, frame);
+	set_props(ge->gin, state, move, frame);
 	gru_event(ge, state->gid, move, state->prop, state->nprop);
 	return 1;
 }

=== modified file 'src/gestures-tapping.c'
--- src/gestures-tapping.c	2010-08-10 16:42:10 +0000
+++ src/gestures-tapping.c	2010-08-19 20:46:41 +0000
@@ -31,6 +31,17 @@
 
 static const int fm_mask = 0x03;
 
+static void set_props(const struct gesture_inserter *gin,
+		      struct tapping_model *s, const struct move_model *m,
+		      const struct touch_frame *frame)
+{
+	s->prop[GRAIL_PROP_TAP_DT] = m->time - s->start;
+	s->prop[GRAIL_PROP_TAP_X] = gin_prop_x(gin, m->fm[FM_X].value);
+	s->prop[GRAIL_PROP_TAP_Y] = gin_prop_y(gin, 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 touch_frame *frame)
 {
@@ -44,11 +55,7 @@
 		if (!state->ntouch)
 			state->start = move->time;
 		if (move->ntouch >= state->ntouch) {
-			state->prop[GRAIL_PROP_TAP_DT] =
-				move->time - state->start;
-			state->prop[GRAIL_PROP_TAP_X] = move->fm[FM_X].value;
-			state->prop[GRAIL_PROP_TAP_Y] = move->fm[FM_Y].value;
-			state->nprop = 3;
+			set_props(ge->gin, state, move, frame);
 		}
 		if (move->ntouch > state->ntouch) {
 			state->ntouch = move->ntouch;

=== modified file 'src/grail-api.c'
--- src/grail-api.c	2010-08-11 17:05:21 +0000
+++ src/grail-api.c	2010-08-19 20:46:41 +0000
@@ -22,27 +22,18 @@
 
 #include "grail-inserter.h"
 #include "grail-recognizer.h"
-#include <grail.h>
+#include "grail-impl.h"
 #include <string.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <malloc.h>
 #include <errno.h>
-#include "evbuf.h"
-
-struct grail_impl {
-	struct touch_dev dev;
-	struct touch_engine engine;
-	struct evbuf evbuf;
-	int filter_abs;
-	int hack_status;
-};
-
-static void tp_event(struct touch_engine *engine,
+
+static void tp_event(struct touch_dev *dev,
 		     const struct input_event *ev)
 {
-	struct grail *ge = engine->priv;
+	struct grail *ge = dev->priv;
 	struct grail_impl *x = ge->impl;
 	evbuf_put(&x->evbuf, ev);
 }
@@ -62,14 +53,14 @@
 	return 0;
 }
 
-static void tp_sync(struct touch_engine *engine,
+static void tp_sync(struct touch_dev *dev,
 		    const struct input_event *syn)
 {
 	struct input_event ev;
-	struct grail *ge = engine->priv;
+	struct grail *ge = dev->priv;
 	struct grail_impl *x = ge->impl;
 	struct gesture_recognizer *gru = ge->gru;
-	struct touch_frame *frame = &engine->frame;
+	struct touch_frame *frame = &dev->frame;
 	grail_mask_t filtered[DIM_EV_TYPE_BYTES];
 	int dofilt, hack, nevent = 0;
 	gin_frame_begin(ge, frame);
@@ -120,22 +111,27 @@
 	if (!x)
 		return -ENOMEM;
 	ge->impl = x;
+
+	ret = touch_dev_open(&x->dev, fd);
+	if (ret)
+		goto freemem;
+	x->dev.event = tp_event;
+	x->dev.sync = tp_sync;
+	x->dev.priv = ge;
+
 	ret = gin_init(ge);
 	if (ret)
-		goto freemem;
-	ret = touch_dev_open(&x->dev, fd);
+		goto freedev;
+
+	ret = gru_init(ge);
 	if (ret)
 		goto freegin;
-	ret = gru_init(ge);
-	if (ret)
-		goto freedev;
-	touch_engine_init(&x->engine, tp_event, tp_sync, ge);
-	touch_engine_attach(&x->engine, &x->dev);
+
 	return 0;
+ freegin:
+	gin_destroy(ge);
  freedev:
 	touch_dev_close(&x->dev, fd);
- freegin:
-	gin_destroy(ge);
  freemem:
 	free(x);
 	ge->impl = 0;
@@ -146,10 +142,9 @@
 {
 	struct grail_impl *x = ge->impl;
 	void *status;
-	touch_engine_detach(&x->engine, &x->dev);
 	gru_destroy(ge);
+	gin_destroy(ge);
 	touch_dev_close(&x->dev, fd);
-	gin_destroy(ge);
 	free(ge->impl);
 	ge->impl = 0;
 }
@@ -169,9 +164,10 @@
 void grail_get_units(const struct grail *ge,
 		     struct grail_coord *min, struct grail_coord *max)
 {
-	const struct touch_dev_caps *caps = &ge->impl->dev.caps;
-	min->x = caps->info[TP_POS_X].minimum;
-	min->y = caps->info[TP_POS_Y].minimum;
-	max->x = caps->info[TP_POS_X].maximum;
-	max->y = caps->info[TP_POS_Y].maximum;
+	const struct touch_caps *caps = &ge->impl->dev.caps;
+	min->x = caps->min_x;
+	min->y = caps->min_y;
+	max->x = caps->max_x;
+	max->y = caps->max_y;
 }
+

=== added file 'src/grail-event.c'
--- src/grail-event.c	1970-01-01 00:00:00 +0000
+++ src/grail-event.c	2010-08-19 20:46:41 +0000
@@ -0,0 +1,144 @@
+/*****************************************************************************
+ *
+ * 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-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 touch_frame *frame)
+{
+	float x, y;
+	int i;
+	if (frame->nactive < 1)
+		return;
+	x = frame->active[0]->x;
+	y = frame->active[0]->y;
+	min->x = max->x = x;
+	min->y = max->y = y;
+	for (i = 1; i < frame->nactive; i++) {
+		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 touch_frame *frame)
+{
+	struct grail_coord min, max;
+	int i, n = 0, ntouch = frame->nactive;
+	if (!ntouch)
+		return n;
+	if (ntouch > 5)
+		ntouch = 5;
+	compute_bbox(&min, &max, frame);
+	prop[n++] = gin_prop_x(gin, min.x);
+	prop[n++] = gin_prop_y(gin, min.y);
+	prop[n++] = gin_prop_x(gin, max.x);
+	prop[n++] = gin_prop_y(gin, max.y);
+	for (i = 0; i < ntouch; i++) {
+		const struct touch *ct = frame->active[i];
+		prop[n++] = ct->id;
+		prop[n++] = gin_prop_x(gin, ct->x);
+		prop[n++] = gin_prop_y(gin, 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 touch_frame *frame)
+{
+	struct grail_coord pos[DIM_TOUCH];
+	int i, npos = 0;
+	if (!ge->get_clients)
+		return 0;
+	grail_mask_foreach(i, span, bspan) {
+		pos[npos].x = gin_prop_x(ge->gin, frame->touch[i].x);
+		pos[npos].y = gin_prop_y(ge->gin, frame->touch[i].y);
+		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 touch_frame *frame)
+{
+	const struct gesture_inserter *gin = ge->gin;
+	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 = gin_prop_x(gin, ev->pos.x);
+	gev.pos.y = gin_prop_y(gin, 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];
+		ge->gesture(ge, &gev);
+	}
+}
+
+int grail_get_contacts(const struct grail *ge,
+		       struct grail_contact *touch, int max_touch)
+{
+	const struct touch_dev *dev = &ge->impl->dev;
+	const struct gesture_inserter *gin = ge->gin;
+	const struct touch_frame *frame = &dev->frame;
+	int i;
+	if (frame->nactive < max_touch)
+		max_touch = frame->nactive;
+	for (i = 0; i < max_touch; i++) {
+		struct grail_contact *t = &touch[i];
+		const struct touch *ct = frame->active[i];
+		t->id = ct->id;
+		t->tool_type = ct->tool_type;
+		t->pos.x = gin_prop_x(gin, ct->x);
+		t->pos.y = gin_prop_y(gin, ct->y);
+		t->touch_major = gin->scale_r * ct->touch_major;
+		t->touch_minor = gin->scale_r * ct->touch_minor;
+		t->width_major = gin->scale_r * ct->width_major;
+		t->width_minor = gin->scale_r * ct->width_minor;
+		t->angle = touch_angle(dev, ct->orientation);
+		t->pressure = touch_pressure(dev, ct->pressure);
+	}
+	return max_touch;
+}

=== modified file 'src/grail-gestures.c'
--- src/grail-gestures.c	2010-08-11 17:06:36 +0000
+++ src/grail-gestures.c	2010-08-19 20:46:41 +0000
@@ -21,6 +21,7 @@
  ****************************************************************************/
 
 #include "grail-recognizer.h"
+#include "grail-impl.h"
 #include <math.h>
 
 static const float FM_SN[DIM_FM] = { 1000, 1000, 200, 1000 };
@@ -39,8 +40,8 @@
 		return;
 	for (i = 0; i < n; i++) {
 		const struct touch *t = frame->active[i];
-		*x += t->prop[TP_POS_X];
-		*y += t->prop[TP_POS_Y];
+		*x += t->x;
+		*y += t->y;
 	}
 	*x /= n;
 	*y /= n;
@@ -55,8 +56,8 @@
 		return r;
 	for (i = 0; i < n; i++) {
 		const struct touch *t = frame->active[i];
-		float dx = t->prop[TP_POS_X] - x;
-		float dy = t->prop[TP_POS_Y] - y;
+		float dx = t->x - x;
+		float dy = t->y - y;
 		r2 += dx * dx + dy * dy;
 	}
 	r2 /= n;
@@ -75,10 +76,10 @@
 	for (i = 0; i < n; i++) {
 		const struct touch *t = frame->active[i];
 		const struct touch *ot = &prev->touch[t->slot];
-		float dx = t->prop[TP_POS_X] - x;
-		float dy = t->prop[TP_POS_Y] - y;
-		float mx = t->prop[TP_POS_X] - ot->prop[TP_POS_X];
-		float my = t->prop[TP_POS_Y] - ot->prop[TP_POS_Y];
+		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;
@@ -141,14 +142,13 @@
 
 void gru_init_motion(struct grail *ge)
 {
+	struct touch_caps *caps = &ge->impl->dev.caps;
 	struct gesture_recognizer *gru = ge->gru;
 	struct move_model *m = &gru->move;
-	struct grail_coord min, max;
 	float D[DIM_FM];
 	int i;
-	grail_get_units(ge, &min, &max);
-	D[FM_X] = max.x - min.x;
-	D[FM_Y] = max.y - min.y;
+	D[FM_X] = caps->max_x - caps->min_x;
+	D[FM_Y] = caps->max_y - caps->min_y;
 	D[FM_R] = sqrt(D[FM_X] * D[FM_X] + D[FM_Y] * D[FM_Y]);
 	D[FM_A] = 2 * M_PI;
 	for (i = 0; i < DIM_FM; i++) {
@@ -217,28 +217,3 @@
 	gin_gid_end(ge, gid, m->fm[FM_X].value, m->fm[FM_Y].value, m->ntouch,
 		    prop, nprop);
 }
-
-void gru_compute_bbox(struct grail_coord *min, struct grail_coord *max,
-		      const struct touch_frame *frame)
-{
-	float x, y;
-	int i;
-	if (frame->nactive < 1)
-		return;
-	x = frame->active[0]->prop[TP_POS_X];
-	y = frame->active[0]->prop[TP_POS_Y];
-	min->x = max->x = x;
-	min->y = max->y = y;
-	for (i = 1; i < frame->nactive; i++) {
-		x = frame->active[i]->prop[TP_POS_X];
-		y = frame->active[i]->prop[TP_POS_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;
-	}
-}

=== modified file 'src/grail-gestures.h'
--- src/grail-gestures.h	2010-08-11 17:06:36 +0000
+++ src/grail-gestures.h	2010-08-19 20:46:41 +0000
@@ -68,8 +68,6 @@
 void gru_end(struct grail *ge, int gid,
 	     const struct move_model *move,
 	     const grail_prop_t *prop, int nprop);
-void gru_compute_bbox(struct grail_coord *min, struct grail_coord *max,
-		      const struct touch_frame *frame);
 
 struct combo_model {
 	int active, gid;

=== added file 'src/grail-impl.h'
--- src/grail-impl.h	1970-01-01 00:00:00 +0000
+++ src/grail-impl.h	2010-08-19 20:46:41 +0000
@@ -0,0 +1,36 @@
+/*****************************************************************************
+ *
+ * grail - Gesture Recognition And Instantiation Library
+ *
+ * Copyright (C) 2010 Canonical Ltd.
+ * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+
+#ifndef _GRAIL_IMPL_H
+#define _GRAIL_IMPL_H
+
+#include <grail-touch.h>
+#include "evbuf.h"
+
+struct grail_impl {
+	struct touch_dev dev;
+	struct evbuf evbuf;
+	int filter_abs;
+	int hack_status;
+};
+
+#endif

=== modified file 'src/grail-inserter.c'
--- src/grail-inserter.c	2010-08-11 17:07:40 +0000
+++ src/grail-inserter.c	2010-08-19 20:46:41 +0000
@@ -21,6 +21,7 @@
  ****************************************************************************/
 
 #include "grail-inserter.h"
+#include "grail-impl.h"
 #include <malloc.h>
 #include <string.h>
 #include <errno.h>
@@ -28,106 +29,6 @@
 
 static const int MAX_GESTURE_ID = 0xfff;
 
-struct gesture_inserter {
-	struct slot_state state[DIM_INSTANCE];
-	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 transformed;
-	float scale_x, scale_y, scale_r;
-	float trans_x, trans_y;
-};
-
-static const int grail_main_type[DIM_GRAIL_TYPE] = {
-	GRAIL_MAIN_DRAG,
-	GRAIL_MAIN_PINCH,
-	GRAIL_MAIN_ROTATE,
-	GRAIL_MAIN_DRAG,
-	GRAIL_MAIN_PINCH,
-	GRAIL_MAIN_ROTATE,
-	GRAIL_MAIN_DRAG,
-	GRAIL_MAIN_PINCH,
-	GRAIL_MAIN_ROTATE,
-	GRAIL_MAIN_DRAG,
-	GRAIL_MAIN_PINCH,
-	GRAIL_MAIN_ROTATE,
-	GRAIL_MAIN_DRAG,
-	GRAIL_MAIN_PINCH,
-	GRAIL_MAIN_ROTATE,
-	GRAIL_MAIN_TAP,
-	GRAIL_MAIN_TAP,
-	GRAIL_MAIN_TAP,
-	GRAIL_MAIN_TAP,
-	GRAIL_MAIN_TAP,
-	GRAIL_MAIN_DRAG,
-	GRAIL_MAIN_PINCH,
-	GRAIL_MAIN_ROTATE,
-	GRAIL_MAIN_DRAG,
-	GRAIL_MAIN_PINCH,
-	GRAIL_MAIN_ROTATE,
-};
-
-static void transform_pos(const struct gesture_inserter *gin,
-			  struct grail_coord *pos)
-{
-	if (gin->transformed) {
-		pos->x *= gin->scale_x;
-		pos->x += gin->trans_x;
-		pos->y *= gin->scale_y;
-		pos->y += gin->trans_y;
-	}
-}
-
-static void transform_prop(const struct gesture_inserter *gin, int type,
-			   grail_prop_t *prop, int nprop)
-{
-	if (!gin->transformed)
-		return;
-	switch (grail_main_type[type]) {
-	case GRAIL_MAIN_DRAG:
-		prop[GRAIL_PROP_DRAG_DX] *= gin->scale_x;
-		prop[GRAIL_PROP_DRAG_DY] *= gin->scale_y;
-		prop[GRAIL_PROP_DRAG_VX] *= gin->scale_x;
-		prop[GRAIL_PROP_DRAG_VY] *= gin->scale_y;
-		prop[GRAIL_PROP_DRAG_X] *= gin->scale_x;
-		prop[GRAIL_PROP_DRAG_X] += gin->trans_x;
-		prop[GRAIL_PROP_DRAG_Y] *= gin->scale_y;
-		prop[GRAIL_PROP_DRAG_Y] += gin->trans_y;
-		break;
-	case GRAIL_MAIN_PINCH:
-		prop[GRAIL_PROP_PINCH_DR] *= gin->scale_r;
-		prop[GRAIL_PROP_PINCH_VR] *= gin->scale_r;
-		prop[GRAIL_PROP_PINCH_R] *= gin->scale_r;
-		prop[GRAIL_PROP_PINCH_X1] *= gin->scale_x;
-		prop[GRAIL_PROP_PINCH_X1] += gin->trans_x;
-		prop[GRAIL_PROP_PINCH_Y1] *= gin->scale_y;
-		prop[GRAIL_PROP_PINCH_Y1] += gin->trans_y;
-		prop[GRAIL_PROP_PINCH_X2] *= gin->scale_x;
-		prop[GRAIL_PROP_PINCH_X2] += gin->trans_x;
-		prop[GRAIL_PROP_PINCH_Y2] *= gin->scale_y;
-		prop[GRAIL_PROP_PINCH_Y2] += gin->trans_y;
-		break;
-	case GRAIL_MAIN_ROTATE:
-		prop[GRAIL_PROP_ROTATE_X1] *= gin->scale_x;
-		prop[GRAIL_PROP_ROTATE_X1] += gin->trans_x;
-		prop[GRAIL_PROP_ROTATE_Y1] *= gin->scale_y;
-		prop[GRAIL_PROP_ROTATE_Y1] += gin->trans_y;
-		prop[GRAIL_PROP_ROTATE_X2] *= gin->scale_x;
-		prop[GRAIL_PROP_ROTATE_X2] += gin->trans_x;
-		prop[GRAIL_PROP_ROTATE_Y2] *= gin->scale_y;
-		prop[GRAIL_PROP_ROTATE_Y2] += gin->trans_y;
-		break;
-	case GRAIL_MAIN_TAP:
-		prop[GRAIL_PROP_TAP_X] *= gin->scale_x;
-		prop[GRAIL_PROP_TAP_X] += gin->trans_x;
-		prop[GRAIL_PROP_TAP_Y] *= gin->scale_y;
-		prop[GRAIL_PROP_TAP_Y] += gin->trans_y;
-		break;
-	};
-}
-
 static int find_gslot(const struct gesture_inserter *gin, int gid)
 {
 	int i;
@@ -137,29 +38,6 @@
 	return -1;
 }
 
-static void send_event(struct grail *ge, struct slot_state *s,
-		       const struct gesture_event *ev)
-{
-	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 = ev->pos;
-	transform_pos(ge->gin, &gev.pos);
-	memcpy(gev.prop, ev->prop, ev->nprop * sizeof(grail_prop_t));
-	transform_prop(ge->gin, gev.type, gev.prop, gev.nprop);
-	for (i = 0; i < s->nclient; i++) {
-		gev.client_id = s->client_id[i];
-		ge->gesture(ge, &gev);
-	}
-}
-
 // todo: spanning tree for multi-user case
 static void setup_new_gestures(struct grail *ge,
 			       const struct touch_frame *frame)
@@ -182,19 +60,8 @@
 		grail_mask_set_mask(span, s->span, sizeof(span));
 	}
 
-	if (ge->get_clients) {
-		struct grail_coord coord[DIM_CLIENT];
-		int ncoord = 0;
-		grail_mask_foreach(i, span, sizeof(span)) {
-			const struct touch *t = &frame->touch[i];
-			coord[ncoord].x = t->prop[TP_POS_X];
-			coord[ncoord].y = t->prop[TP_POS_Y];
-			transform_pos(gin, &coord[ncoord]);
-			ncoord++;
-		}
-		nclient = ge->get_clients(ge, info, DIM_CLIENT,
-					  coord, ncoord, types, sizeof(types));
-	}
+	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];
@@ -218,6 +85,11 @@
 		return -ENOMEM;
 	for (i = 0; i < DIM_INSTANCE; i++)
 		grail_mask_set(gin->unused, i);
+	gin->scale_x = 1;
+	gin->scale_y = 1;
+	gin->scale_r = 1;
+	gin->trans_x = 1;
+	gin->trans_y = 1;
 	ge->gin = gin;
 	return 0;
 }
@@ -273,7 +145,7 @@
 			continue;
 		while (!gebuf_empty(&s->buf)) {
 			gebuf_get(&s->buf, &ev);
-			send_event(ge, s, &ev);
+			gin_send_event(ge, s, &ev, frame);
 		}
 	}
 
@@ -384,16 +256,18 @@
 		    const struct grail_coord *tmin,
 		    const struct grail_coord *tmax)
 {
+	struct touch_caps *caps = &ge->impl->dev.caps;
 	struct gesture_inserter *gin = ge->gin;
-	struct grail_coord dmin, dmax;
-	double sx, sy;
-	grail_get_units(ge, &dmin, &dmax);
-	sx = (tmax->x - tmin->x) / (dmax.x - dmin.x);
-	sy = (tmax->y - tmin->y) / (dmax.y - dmin.y);
+	double tx, ty, dx, dy, sx, sy;
+	tx = tmax->x - tmin->x;
+	ty = tmax->y - tmin->y;
+	dx = caps->max_x - caps->min_x;
+	dy = caps->max_y - caps->min_y;
+	sx = tx / dx;
+	sy = ty / dy;
 	gin->scale_x = sx;
 	gin->scale_y = sy;
-	gin->scale_r = sqrt((sx * sx + sy * sy) / 2);
-	gin->trans_x = tmin->x - dmin.x * sx;
-	gin->trans_y = tmin->y - dmin.y * sy;
-	gin->transformed = 1;
+	gin->scale_r = sqrt((tx * tx + ty * ty) / (dx * dx + dy * dy));
+	gin->trans_x = tmin->x - caps->min_x * sx;
+	gin->trans_y = tmin->y - caps->min_y * sy;
 }

=== modified file 'src/grail-inserter.h'
--- src/grail-inserter.h	2010-08-10 16:39:47 +0000
+++ src/grail-inserter.h	2010-08-19 20:46:41 +0000
@@ -46,6 +46,39 @@
 	struct gebuf buf;
 };
 
+struct gesture_inserter {
+	struct slot_state state[DIM_INSTANCE];
+	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;
+	float scale_x, scale_y, scale_r;
+	float trans_x, trans_y;
+};
+
+static inline float gin_prop_x(const struct gesture_inserter *gin, float x)
+{
+	return gin->scale_x * x + gin->trans_x;
+}
+
+static inline float gin_prop_y(const struct gesture_inserter *gin, float y)
+{
+	return gin->scale_y * y + gin->trans_y;
+}
+
+int gin_add_contact_props(const struct gesture_inserter *gin,
+			  grail_prop_t *prop, const struct touch_frame *frame);
+
+int gin_get_clients(struct grail *ge,
+		    struct grail_client_info *info, int maxinfo,
+		    const grail_mask_t* types, int btypes,
+		    const grail_mask_t* span, int bspan,
+		    const struct touch_frame *frame);
+void gin_send_event(struct grail *ge, struct slot_state *s,
+		    const struct gesture_event *ev,
+		    const struct touch_frame *frame);
+
 int gin_init(struct grail *ge);
 void gin_destroy(struct grail *ge);
 

=== modified file 'src/touch-dev.c'
--- src/touch-dev.c	2010-08-07 20:13:32 +0000
+++ src/touch-dev.c	2010-08-19 20:46:41 +0000
@@ -25,128 +25,97 @@
 #include <string.h>
 #include <errno.h>
 
-/* from mtdev-mapping.h */
-#define MT_TOUCH_MAJOR	0
-#define MT_TOUCH_MINOR	1
-#define MT_WIDTH_MAJOR	2
-#define MT_WIDTH_MINOR	3
-#define MT_ORIENTATION	4
-#define MT_POSITION_X	5
-#define MT_POSITION_Y	6
-#define MT_TRACKING_ID	9
-#define MT_PRESSURE	10
-
-struct touch_dev_impl {
-	int id[DIM_TOUCH];
-	int slot;
-	int status;
-	grail_mask_t mask[DIM_TOUCH_BYTES];
-	touch_prop_t prop[DIM_TOUCH_PROP];
-	struct mtdev mtdev;
-};
-
-static inline void set_info(struct touch_dev_caps *caps, int code,
-			    const struct input_absinfo *info)
-{
-	grail_mask_set(caps->mask, code);
-	caps->info[code] = *info;
-}
-
-static void set_caps(struct touch_dev_caps *caps,
-		     const struct mtdev_caps *mtcaps)
-{
-	if (mtcaps->has_abs[MT_POSITION_X])
-		set_info(caps, TP_POS_X, &mtcaps->abs[MT_POSITION_X]);
-	if (mtcaps->has_abs[MT_POSITION_Y])
-		set_info(caps, TP_POS_Y, &mtcaps->abs[MT_POSITION_Y]);
-	if (mtcaps->has_abs[MT_TOUCH_MAJOR])
-		set_info(caps, TP_TOUCH_MAJOR, &mtcaps->abs[MT_TOUCH_MAJOR]);
-	if (mtcaps->has_abs[MT_TOUCH_MINOR])
-		set_info(caps, TP_TOUCH_MINOR, &mtcaps->abs[MT_TOUCH_MINOR]);
-	if (mtcaps->has_abs[MT_WIDTH_MAJOR])
-		set_info(caps, TP_WIDTH_MAJOR, &mtcaps->abs[MT_WIDTH_MAJOR]);
-	if (mtcaps->has_abs[MT_WIDTH_MINOR])
-		set_info(caps, TP_WIDTH_MINOR, &mtcaps->abs[MT_WIDTH_MINOR]);
-	if (mtcaps->has_abs[MT_ORIENTATION])
-		set_info(caps, TP_ORIENTATION, &mtcaps->abs[MT_ORIENTATION]);
-	if (mtcaps->has_abs[MT_PRESSURE])
-		set_info(caps, TP_PRESSURE, &mtcaps->abs[MT_PRESSURE]);
-}
-
-static inline void set_prop(struct touch_dev_impl *x, int code, int value)
-{
-	grail_mask_set(x->mask, code);
-	x->prop[code] = value;
-}
-
-static void finish_touch(struct touch_dev *dev,
-			 struct touch_dev_impl *x)
-{
-	if (x->status < 0 && dev->destroy)
-		dev->destroy(dev, x->slot);
-	if (x->status > 0 && dev->create)
-		dev->create(dev, x->slot, x->mask, x->prop);
-	if (x->status == 0 && dev->modify &&
-	    grail_mask_count(x->mask, sizeof(x->mask)))
-		dev->modify(dev, x->slot, x->mask, x->prop);
-	x->status = 0;
-	memset(x->mask, 0, sizeof(x->mask));
+#define SET_PROP(name, value)						\
+	if (t->name != value) {						\
+		t->name = value;					\
+		frame->nmodify++;					\
+	}
+
+static void finish_touch(struct touch_dev *dev, struct touch_frame *frame)
+{
+	struct touch *t = &frame->touch[dev->slot];
+	if (dev->state > 0) {
+		t->active = 1;
+		grail_mask_set(frame->touches, dev->slot);
+		frame->ncreate++;
+	}
+	if (dev->state < 0) {
+		t->active = 0;
+		grail_mask_clear(frame->touches, dev->slot);
+		frame->ndestroy++;
+	}
+	dev->state = 0;
 }
 
 static void finish_packet(struct touch_dev *dev,
 			  const struct input_event *syn)
 {
-	finish_touch(dev, dev->impl);
+	static const touch_time_t ms = 1000;
+	struct touch_frame *frame = &dev->frame;
+	int i, nslot = 0;
+	finish_touch(dev, frame);
+	grail_mask_foreach(i, frame->touches, DIM_TOUCH_BYTES)
+		frame->active[nslot++] = &frame->touch[i];
+	frame->nactive = nslot;
+	frame->time = syn->time.tv_usec / ms + syn->time.tv_sec * ms;
 	if (dev->sync)
 		dev->sync(dev, syn);
+	frame->ncreate = 0;
+	frame->nmodify = 0;
+	frame->ndestroy = 0;
 }
 
 static int handle_abs_event(struct touch_dev *dev,
 			    const struct input_event *ev)
 {
-	struct touch_dev_impl *x = dev->impl;
+	struct touch_frame *frame = &dev->frame;
+	struct touch *t = &frame->touch[dev->slot];
 	switch (ev->code) {
 	case ABS_MT_SLOT:
 		if (ev->value >= 0 && ev->value < DIM_TOUCH) {
-			if (x->slot != ev->value)
-				finish_touch(dev, x);
-			x->slot = ev->value;
+			if (dev->slot != ev->value)
+				finish_touch(dev, frame);
+			dev->slot = ev->value;
+			t = &frame->touch[dev->slot];
 		}
 		return 1;
 	case ABS_MT_POSITION_X:
-		set_prop(x, TP_POS_X, ev->value);
+		SET_PROP(x, ev->value);
 		return 1;
 	case ABS_MT_POSITION_Y:
-		set_prop(x, TP_POS_Y, ev->value);
+		SET_PROP(y, ev->value);
 		return 1;
 	case ABS_MT_TOUCH_MAJOR:
-		set_prop(x, TP_TOUCH_MAJOR, ev->value);
+		SET_PROP(touch_major, ev->value);
 		return 1;
 	case ABS_MT_TOUCH_MINOR:
-		set_prop(x, TP_TOUCH_MINOR, ev->value);
+		SET_PROP(touch_minor, ev->value);
 		return 1;
 	case ABS_MT_WIDTH_MAJOR:
-		set_prop(x, TP_WIDTH_MAJOR, ev->value);
+		SET_PROP(width_major, ev->value);
 		return 1;
 	case ABS_MT_WIDTH_MINOR:
-		set_prop(x, TP_WIDTH_MINOR, ev->value);
+		SET_PROP(width_minor, ev->value);
 		return 1;
 	case ABS_MT_ORIENTATION:
-		set_prop(x, TP_ORIENTATION, ev->value);
+		SET_PROP(orientation, ev->value);
 		return 1;
 	case ABS_MT_PRESSURE:
-		set_prop(x, TP_PRESSURE, ev->value);
+		SET_PROP(pressure, ev->value);
+		return 1;
+	case ABS_MT_TOOL_TYPE:
+		SET_PROP(tool_type, ev->value);
 		return 1;
 	case ABS_MT_TRACKING_ID:
-		if (x->id[x->slot] != ev->value) {
-			if (x->id[x->slot] != MT_ID_NULL) {
-				x->status = -1;
-				finish_touch(dev, x);
+		if (t->id != ev->value) {
+			if (t->id != MT_ID_NULL) {
+				dev->state = -1;
+				finish_touch(dev, frame);
 			}
 			if (ev->value != MT_ID_NULL)
-				x->status = 1;
+				dev->state = 1;
+			t->id = ev->value;
 		}
-		x->id[x->slot] = ev->value;
 		return 1;
 	default:
 		return 0;
@@ -155,38 +124,35 @@
 
 int touch_dev_open(struct touch_dev *dev, int fd)
 {
-	struct touch_dev_impl *x;
+	struct touch_frame *frame = &dev->frame;
 	int ret, i;
 	memset(dev, 0, sizeof(*dev));
-	x = calloc(1, sizeof(*x));
-	if (!x)
-		return -ENOMEM;
-	ret = mtdev_open(&x->mtdev, fd);
-	if (!ret && !x->mtdev.caps.has_mtdata)
+	for (i = 0; i < DIM_TOUCH; i++) {
+		struct touch *t = &frame->touch[i];
+		t->slot = i;
+		t->id = MT_ID_NULL;
+	}
+	ret = mtdev_open(&dev->mtdev, fd);
+	if (!ret && !dev->mtdev.caps.has_mtdata)
 		ret = -ENODEV;
 	if (ret)
 		goto error;
-	for (i = 0; i < DIM_TOUCH; i++)
-		x->id[i] = MT_ID_NULL;
-	set_caps(&dev->caps, &x->mtdev.caps);
-	dev->impl = x;
+	touch_caps_init(dev);
 	return 0;
  error:
-	free(x);
 	return ret;
 }
 
 int touch_dev_idle(struct touch_dev *dev, int fd, int ms)
 {
-	return mtdev_idle(&dev->impl->mtdev, fd, ms);
+	return mtdev_idle(&dev->mtdev, fd, ms);
 }
 
 int touch_dev_pull(struct touch_dev *dev, int fd)
 {
-	struct touch_dev_impl *x = dev->impl;
 	struct input_event ev;
 	int ret, count = 0, consumed;
-	while ((ret = mtdev_get(&x->mtdev, fd, &ev, 1)) > 0) {
+	while ((ret = mtdev_get(&dev->mtdev, fd, &ev, 1)) > 0) {
 		consumed = 0;
 		if (ev.type == EV_SYN) {
 			if (ev.code == SYN_REPORT)
@@ -204,8 +170,6 @@
 
 void touch_dev_close(struct touch_dev *dev, int fd)
 {
-	struct touch_dev_impl *x = dev->impl;
-	mtdev_close(&x->mtdev);
-	free(x);
+	mtdev_close(&dev->mtdev);
 	memset(dev, 0, sizeof(*dev));
 }

=== removed file 'src/touch-engine.c'
--- src/touch-engine.c	2010-08-06 20:30:20 +0000
+++ src/touch-engine.c	1970-01-01 00:00:00 +0000
@@ -1,135 +0,0 @@
-/*****************************************************************************
- *
- * grail - Gesture Recognition And Instantiation Library
- *
- * Copyright (C) 2010 Canonical Ltd.
- * Copyright (C) 2010 Henrik Rydberg <[e-mail]>
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- ****************************************************************************/
-
-#include <grail-touch.h>
-#include <string.h>
-
-static void tp_event(struct touch_dev *dev, const struct input_event *ev)
-{
-	struct touch_engine *engine = dev->priv;
-	if (engine && engine->event)
-		engine->event(engine, ev);
-}
-
-static void update_frame(struct touch_frame *frame,
-			 int slot, int active,
-			 const grail_mask_t *mask,
-			 const touch_prop_t *prop)
-{
-	struct touch *t = &frame->touch[slot];
-	int i;
-	t->active = active;
-	grail_mask_modify(frame->touches, slot, active);
-	if (mask && prop)
-		grail_mask_foreach(i, mask, DIM_TOUCH_PROP_BYTES)
-			t->prop[i] = prop[i];
-}
-
-static void finalize_frame(struct touch_frame *frame, touch_time_t time)
-{
-	int i, nslot = 0;
-	grail_mask_foreach(i, frame->touches, DIM_TOUCH_BYTES)
-		frame->active[nslot++] = &frame->touch[i];
-	frame->nactive = nslot;
-	frame->time = time;
-}
-
-static void tp_create(struct touch_dev *dev, int slot,
-		      const grail_mask_t *mask, const touch_prop_t *prop)
-{
-	struct touch_engine *engine = dev->priv;
-	if (engine) {
-		engine->frame.ncreate++;
-		update_frame(&engine->frame, slot, 1, mask, prop);
-	}
-}
-
-static void tp_modify(struct touch_dev *dev, int slot,
-		      const grail_mask_t *mask, const touch_prop_t *prop)
-{
-	struct touch_engine *engine = dev->priv;
-	if (engine) {
-		engine->frame.nmodify++;
-		update_frame(&engine->frame, slot, 1, mask, prop);
-	}
-}
-
-static void tp_destroy(struct touch_dev *dev, int slot)
-{
-	struct touch_engine *engine = dev->priv;
-	if (engine) {
-		engine->frame.ndestroy++;
-		update_frame(&engine->frame, slot, 0, 0, 0);
-	}
-}
-
-static void tp_sync(struct touch_dev *dev, const struct input_event *syn)
-{
-	static const touch_time_t ms = 1000;
-	struct touch_engine *engine = dev->priv;
-	touch_time_t time = syn->time.tv_usec / ms + syn->time.tv_sec * ms;
-	if (engine) {
-		finalize_frame(&engine->frame, time);
-		if (engine->sync)
-			engine->sync(engine, syn);
-		engine->frame.ncreate = 0;
-		engine->frame.nmodify = 0;
-		engine->frame.ndestroy = 0;
-	}
-}
-
-void touch_engine_init(struct touch_engine *engine,
-		       void (*event)(struct touch_engine *engine,
-				     const struct input_event *ev),
-		       void (*sync)(struct touch_engine *engine,
-				    const struct input_event *ev),
-		       void *priv)
-{
-	int i;
-	memset(engine, 0, sizeof(*engine));
-	for (i = 0; i < DIM_TOUCH; i++)
-		engine->frame.touch[i].slot = i;
-	engine->event = event;
-	engine->sync = sync;
-	engine->priv = priv;
-}
-
-void touch_engine_attach(struct touch_engine *engine, struct touch_dev *dev)
-{
-	dev->priv = engine;
-	dev->event = tp_event;
-	dev->create = tp_create;
-	dev->modify = tp_modify;
-	dev->destroy = tp_destroy;
-	dev->sync = tp_sync;
-}
-
-void touch_engine_detach(struct touch_engine *engine, struct touch_dev *dev)
-{
-	dev->sync = 0;
-	dev->destroy = 0;
-	dev->modify = 0;
-	dev->create = 0;
-	dev->event = 0;
-	dev->priv = 0;
-}
-

=== modified file 'test/grail-gesture.c'
--- test/grail-gesture.c	2010-08-11 17:07:40 +0000
+++ test/grail-gesture.c	2010-08-19 20:46:41 +0000
@@ -53,11 +53,21 @@
 
 static void tp_gesture(struct grail *ge, const struct grail_event *ev)
 {
-	int i;
+	struct grail_contact touch[32];
+	int i, ntouch;
 	fprintf(stderr, "gesture %d %d %d %d - %f %f %d - %d\n",
 		ev->type, ev->id, ev->client_id.client, ev->client_id.event,
 		ev->pos.x, ev->pos.y, ev->ntouch,
 		ev->status);
+	ntouch = grail_get_contacts(ge, touch, 32);
+	for (i = 0; i < ntouch; i++) {
+		const struct grail_contact *t = &touch[i];
+		fprintf(stderr, "\t%d: %d %d\n", i, t->id, t->tool_type);
+		fprintf(stderr, "\t   %f %f\n", t->pos.x, t->pos.y);
+		fprintf(stderr, "\t   %f %f %f %f\n", t->touch_major,
+			t->touch_minor, t->width_major, t->width_minor);
+		fprintf(stderr, "\t   %f %f\n", t->angle, t->pressure);
+	}
 	for (i = 0; i < ev->nprop; i++)
 		fprintf(stderr, "\t%d: %f\n", i, ev->prop[i]);
 }

=== modified file 'test/grail-touch.c'
--- test/grail-touch.c	2010-08-06 12:33:32 +0000
+++ test/grail-touch.c	2010-08-19 20:46:41 +0000
@@ -28,22 +28,33 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-static void tp_event(struct touch_engine *engine,
+static void tp_event(struct touch_dev *dev,
 		     const struct input_event *ev)
 {
 	fprintf(stderr, "event %d 0x%x %d\n", ev->type, ev->code, ev->value);
 }
 
-static void tp_sync(struct touch_engine *engine,
+static void tp_sync(struct touch_dev *dev,
 		    const struct input_event *syn)
 {
-	struct touch_frame *frame = &engine->frame;
+	struct touch_frame *frame = &dev->frame;
 	int i, j;
 	for (i = 0; i < frame->nactive; i++) {
 		struct touch *t = frame->active[i];
-		fprintf(stderr, "touch %d %d\n", i, t->slot);
-		for (j = 0; j < DIM_TOUCH_PROP; j++)
-			fprintf(stderr, "  %d\n", t->prop[j]);
+		fprintf(stderr, "touch %d\n", i);
+		fprintf(stderr, "  slot:         %d\n", t->slot);
+		fprintf(stderr, "  id:           %d\n", t->id);
+		fprintf(stderr, "  tool_type:    %d\n", t->tool_type);
+		fprintf(stderr, "  x:            %d\n", t->x);
+		fprintf(stderr, "  y:            %d\n", t->y);
+		fprintf(stderr, "  touch_major:  %d\n", t->touch_major);
+		fprintf(stderr, "  touch_minor:  %d\n", t->touch_minor);
+		fprintf(stderr, "  width_major:  %d\n", t->width_major);
+		fprintf(stderr, "  width_minor:  %d\n", t->width_minor);
+		fprintf(stderr, "  angle:        %f\n",
+			touch_angle(dev, t->orientation));
+		fprintf(stderr, "  pressure:     %f\n",
+			touch_pressure(dev, t->pressure));
 	}
 	fprintf(stderr, "sync %d %lld %d %d\n",
 		frame->nactive, frame->time, frame->ncreate, frame->ndestroy);
@@ -51,12 +62,10 @@
 
 static void loop_device(struct touch_dev *dev, int fd)
 {
-	struct touch_engine engine;
-	touch_engine_init(&engine, tp_event, tp_sync, 0);
-	touch_engine_attach(&engine, dev);
+	dev->event = tp_event;
+	dev->sync = tp_sync;
 	while (!touch_dev_idle(dev, fd, 5000))
 		touch_dev_pull(dev, fd);
-	touch_engine_detach(&engine, dev);
 }
 
 int main(int argc, char *argv[])