Merge lp:~bregma/libgrip/lp-1168370 into lp:libgrip

[Stephen M. Webb]

Moved to GEISv2 to fix an unfortunate lack of events (lp: #1168370).

Rewrote libgrip to use GEISv2 instead of GEISv1 because libgrip's assumptions about device tracking across instances was invalid, and GEISv1 is deprecated.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:78
http://jenkins.qa.ubuntu.com/job/libgrip-ci/1/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libgrip-raring-amd64-ci/1
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libgrip-raring-armhf-ci/1
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libgrip-raring-i386-ci/1

Click here to trigger a rebuild:
http://s-jenkins:8080/job/libgrip-ci/1/rebuild

review: Approve (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

120 -static const gchar *geis_gesture_types[] = {

Moved?

252 + g_ptr_array_add(manager->priv->devices, input_device);
496 + g_ptr_array_foreach (priv->devices, (GFunc) g_object_unref, NULL);

Does manager->priv->devices get clean up? Or who owns input_device?

230 + goto final_exit;

333 +final_exit:
334 + return;
335 +}

Cant you just do a 'return;'? Instead of a goto?

362 + for (l = priv->classes; l != NULL; l = l->next)
363 + {

355 + switch (geis_event_type(geis_event))
356 + {

Most likely just the coding style, but how come its switched from new line style to GNU style? (or the new line + spaces style).

Hopefully these stay constant during the loop:

1172 + for (i = 0; i < geis_groupset_group_count (groupset); ++i)
1182 + for (j = 0; j < geis_group_frame_count (group); ++j)

I couldn't find them defined, or how you add to it soo I wasn't sure if:
1184 + GeisFrame frame = geis_group_frame(group, j);

Would extract, and remove anything from the group_frame. Hopefully not!

[lp:~bregma/libgrip/lp-1168370]

79. By Stephen M. Webb on 2013-04-17

replaced gotos with something more GTK-like

80. By Stephen M. Webb on 2013-04-17

small stylistic repair

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:80
http://jenkins.qa.ubuntu.com/job/libgrip-ci/3/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libgrip-raring-amd64-ci/3
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libgrip-raring-armhf-ci/3
    SUCCESS: http://jenkins.qa.ubuntu.com/job/libgrip-raring-i386-ci/3

Click here to trigger a rebuild:
http://s-jenkins:8080/job/libgrip-ci/3/rebuild

review: Approve (continuous-integration)

[Stephen M. Webb (bregma)]

(1) manager->priv->devices gets unreffed (freed) on the next line.

(2) gotos replaced

(3) style fixed

(4) the data returned from GEIS is readonly, none of the group/frame accessor calls modifiy the data

=== modified file 'src/gripgesturemanager.c'
--- src/gripgesturemanager.c	2012-05-29 20:47:37 +0000
+++ src/gripgesturemanager.c	2013-04-17 15:02:24 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010, 2011 Canonical, Ltd.
+ * Copyright 2010, 2011, 2013 Canonical, Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of either or both of the following licenses:
@@ -29,25 +29,49 @@
 #include <geis/geis.h>
 #include "gripinputdevice.h"
 
-typedef struct _GripGestureRegistration GripGestureRegistration;
 typedef struct _GripGestureBinding      GripGestureBinding;
 typedef struct _GripRegistrationRequest GripRegistrationRequest;
 
 typedef GPtrArray GripDevices;
 
-struct Registrations {
-  GripGestureRegistration *touchscreen;
-  GripGestureRegistration *touchpad;
-  GripGestureRegistration *independent;
-};
+/*
+ * GripGestureClassMap:
+ * @grip_type: the libgrip gesture type
+ * @geis_class: the geis gesture class
+ *
+ * Provides a mapping between a grip gesture type and a geis gesture class.
+ */
+typedef struct _GripGestureClassMap
+{
+  GripGestureType  grip_type;
+  GeisGestureClass geis_class;
+} GripGestureClassMap;
 
+/*
+ * GripGestureManagerPrivate:
+ * @geis: the GEIS instance
+ * @iochannel: connects the geis object with the main loop
+ * @iochannel_id: the identifier for the iochannel
+ * @devices: a collection of recognized input devices
+ * @classes: a list of grip type to geis class mappings
+ * @requests: a list of pending binding requests
+ * @bindings: a list of current gesture bindings
+ */
 struct _GripGestureManagerPrivate
 {
-  GHashTable  *registered_windows;
-  GList       *requests;
-  GripDevices *devices;
+  Geis              geis;
+  GIOChannel       *iochannel;
+  int               iochannel_id;
+  GripDevices      *devices;
+  GList            *classes;
+  GList            *requests;
+  GList            *bindings;
 };
 
+G_DEFINE_TYPE (GripGestureManager, grip_gesture_manager, G_TYPE_OBJECT)
+
+#define GRIP_GESTURE_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GRIP_TYPE_GESTURE_MANAGER, GripGestureManagerPrivate))
+
 /*
  * GripGestureBinding:
  * @type:
@@ -64,32 +88,27 @@
   GripGestureType      type;
   GtkWidget           *widget;
   guint                touches;
+  GeisSubscription     subscription;
   GripGestureCallback  callback;
   gpointer             data;
   GDestroyNotify       destroy;
 };
 
+
 /*
- * GripGestureRegistration:
- * @window: the GTK window
- * @bindings: a list of #GripGestureBinding
- * @gesture_list: a list the names of GEIS gestures beging subscribed to 
- * @instance:
- * @iochannel:
+ * GripRegistrationRequest:
+ * @manager: the @GripGestureManager
+ * @widget: the GtkWidget to be bound
+ * @gesture_type: the type of gesture to subscribe for
+ * @device_type: the type of input device to subscribe for
+ * @touch_points: the number of touches making the gesture
+ * @callback: the callback to be invoked on gesture events
+ * @user_data: the callback context to be passed back on gesture events
+ * @destroy: function to destroy the callback context (NULL for no function)
  *
- * A collection of all gesture subscriptions for all widgets contained within a
- * top-level GTK window.
+ * A collection of information required to register a callback for a
+ * particulatr type of gestures on a window.
  */
-struct _GripGestureRegistration
-{
-  GtkWindow         *window;
-  GList             *bindings;
-  GPtrArray         *gesture_list;
-  GeisInstance       instance;
-  GIOChannel        *iochannel;
-  int                iochannel_id;
-};
-
 struct _GripRegistrationRequest
 {
   GripGestureManager *manager;
@@ -102,30 +121,8 @@
   GDestroyNotify      destroy;
 };
 
-static const gchar *geis_gesture_types[] = {
-  GEIS_GESTURE_TYPE_DRAG1,
-  GEIS_GESTURE_TYPE_DRAG2,
-  GEIS_GESTURE_TYPE_DRAG3,
-  GEIS_GESTURE_TYPE_DRAG4,
-  GEIS_GESTURE_TYPE_DRAG5,
-  GEIS_GESTURE_TYPE_PINCH1,
-  GEIS_GESTURE_TYPE_PINCH2,
-  GEIS_GESTURE_TYPE_PINCH3,
-  GEIS_GESTURE_TYPE_PINCH4,
-  GEIS_GESTURE_TYPE_PINCH5,
-  GEIS_GESTURE_TYPE_ROTATE1,
-  GEIS_GESTURE_TYPE_ROTATE2,
-  GEIS_GESTURE_TYPE_ROTATE3,
-  GEIS_GESTURE_TYPE_ROTATE4,
-  GEIS_GESTURE_TYPE_ROTATE5,
-  GEIS_GESTURE_TYPE_TAP1,
-  GEIS_GESTURE_TYPE_TAP2,
-  GEIS_GESTURE_TYPE_TAP3,
-  GEIS_GESTURE_TYPE_TAP4,
-  GEIS_GESTURE_TYPE_TAP5,
-};
-
-enum {
+enum
+{
   DEVICE_AVAILABLE,
   DEVICE_UNAVAILABLE,
   SIGNAL_LAST
@@ -133,132 +130,151 @@
 
 static guint signals[SIGNAL_LAST];
 
-static void gesture_added (void              *cookie,
-                           GeisGestureType    gesture_type,
-                           GeisGestureId      gesture_id,
-                           GeisSize           attr_count,
-                           GeisGestureAttr   *attrs);
-
-static void gesture_removed (void              *cookie,
-                             GeisGestureType    gesture_type,
-                             GeisGestureId      gesture_id,
-                             GeisSize           attr_count,
-                             GeisGestureAttr   *attrs);
-
-static void gesture_start (void              *cookie,
-                           GeisGestureType    gesture_type,
-                           GeisGestureId      gesture_id,
-                           GeisSize           attr_count,
-                           GeisGestureAttr   *attrs);
-
-static void gesture_update (void              *cookie,
-                            GeisGestureType    gesture_type,
-                            GeisGestureId      gesture_id,
-                            GeisSize           attr_count,
-                            GeisGestureAttr   *attrs);
-
-static void gesture_finish (void              *cookie,
-                            GeisGestureType    gesture_type,
-                            GeisGestureId      gesture_id,
-                            GeisSize           attr_count,
-                            GeisGestureAttr   *attrs);
+static void process_gesture_events (GripGestureManager *manager,
+                                    GeisEvent geis_event);
 
 static void toplevel_mapped_cb (GtkWidget       *toplevel,
                                 GdkEvent        *event,
                                 gpointer         user_data);
 
-static GeisGestureFuncs gesture_funcs = {
-  gesture_added,
-  gesture_removed,
-  gesture_start,
-  gesture_update,
-  gesture_finish
-};
-
-
-static void
-device_added (void *cookie, GeisInputDeviceId id G_GNUC_UNUSED, void *attrs)
-{
-  GripGestureManager *gesture_manager = (GripGestureManager *) cookie;
-  GripInputDevice *input_device = g_object_new (GRIP_TYPE_INPUT_DEVICE,
-                                                "device-attrs", attrs,
-                                                NULL);
-
-  g_ptr_array_add(gesture_manager->priv->devices, input_device);
-  g_signal_emit (gesture_manager, signals[DEVICE_AVAILABLE], 0, input_device);
-}
-
-
-static void
-device_removed (void *cookie, GeisInputDeviceId id, void *attrs G_GNUC_UNUSED)
-{
-  guint i;
-  GripGestureManager *gesture_manager = (GripGestureManager *) cookie;
-  GripDevices *devices = gesture_manager->priv->devices;
-
-  for (i = 0; i < devices->len; ++i)
-  {
-    GripInputDevice *input_device = g_ptr_array_index (devices, i);
-    if (id == grip_input_device_get_id (input_device))
-    {
-      g_signal_emit (gesture_manager, signals[DEVICE_UNAVAILABLE], 0,
-                     input_device);
-      g_ptr_array_remove_index (devices, i);
-      break;
-    }
-  }
-}
-
-
-static GeisInputFuncs input_funcs = {
-  device_added,
-  NULL,
-  device_removed,
-};
-
-
-static void
-grip_get_devices (GripGestureManager *gesture_manager)
-{
-  GeisXcbWinInfo xcb_win_info = {
-    .display_name = NULL,
-    .screenp = NULL,
-    .window_id = 0,
-  };
-  GeisWinInfo win_info = {
-    GEIS_XCB_FULL_WINDOW,
-    &xcb_win_info,
-  };
-  GeisInstance instance;
-  GeisStatus status;
-
-  status = geis_init (&win_info, &instance);
-  if (status != GEIS_STATUS_SUCCESS)
-  {
-    g_warning ("failed to determine device types\n");
-    return;
-  }
-
-  status = geis_input_devices (instance, &input_funcs, gesture_manager);
-  if (status != GEIS_STATUS_SUCCESS)
-  {
-    g_warning ("failed to determine device types\n");
-    return;
-  }
-
-  status = geis_event_dispatch (instance);
-  if (status != GEIS_STATUS_SUCCESS)
-  {
-    g_warning ("failed to determine device types\n");
-    return;
-  }
-
-  geis_finish (instance);
-}
-
-G_DEFINE_TYPE (GripGestureManager, grip_gesture_manager, G_TYPE_OBJECT)
-
-#define GRIP_GESTURE_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GRIP_TYPE_GESTURE_MANAGER, GripGestureManagerPrivate))
+
+static void
+grip_geis_device_added(GripGestureManager *manager G_GNUC_UNUSED, GeisEvent geis_event)
+{
+  GeisAttr attr = geis_event_attr_by_name(geis_event, GEIS_EVENT_ATTRIBUTE_DEVICE);
+  g_return_if_fail (attr);
+
+  GeisDevice device = geis_attr_value_to_pointer(attr);
+  g_return_if_fail (device);
+
+  switch (geis_event_type(geis_event))
+    {
+      case GEIS_EVENT_DEVICE_AVAILABLE:
+        {
+          GripInputDevice *input_device = g_object_new (GRIP_TYPE_INPUT_DEVICE,
+                                                        "geis-device", device,
+                                                        NULL);
+
+          g_ptr_array_add(manager->priv->devices, input_device);
+          g_signal_emit (manager, signals[DEVICE_AVAILABLE], 0, input_device);
+        }
+        break;
+
+      case GEIS_EVENT_DEVICE_UNAVAILABLE:
+        {
+          guint device_id = geis_device_id (device);
+          GripDevices *devices = manager->priv->devices;
+          guint i;
+          for (i = 0; i < devices->len; ++i)
+          {
+            GripInputDevice *input_device = g_ptr_array_index (devices, i);
+            if (device_id == grip_input_device_get_id (input_device))
+            {
+              g_signal_emit (manager, signals[DEVICE_UNAVAILABLE], 0,
+                             input_device);
+              g_ptr_array_remove_index (devices, i);
+              break;
+            }
+          }
+        }
+        break;
+
+      default:
+        break;
+    }
+}
+
+
+static void
+process_class_event(GripGestureManagerPrivate *priv G_GNUC_UNUSED, GeisEvent geis_event)
+{
+  GeisAttr attr = geis_event_attr_by_name (geis_event,
+                                           GEIS_EVENT_ATTRIBUTE_CLASS);
+  g_return_if_fail (attr);
+
+  GeisGestureClass gesture_class = geis_attr_value_to_pointer (attr);
+  g_return_if_fail (gesture_class);
+
+  switch (geis_event_type (geis_event))
+    {
+      case GEIS_EVENT_CLASS_AVAILABLE:
+        {
+          gchar const *class_name = geis_gesture_class_name (gesture_class);
+          /* check for dups */
+          GList *l;
+          for (l = priv->classes; l != NULL; l = l->next)
+            {
+              GripGestureClassMap *p = (GripGestureClassMap *)l->data;
+              if (0 == g_strcmp0 (geis_gesture_class_name (p->geis_class),
+                                  class_name))
+                {
+                  g_warning ("multiple class definitions for '%s' received",
+                             class_name);
+                  return;
+                }
+            }
+
+          GripGestureClassMap *m = g_new0 (GripGestureClassMap, 1);
+          if (0 == g_strcmp0 (class_name, "Drag"))
+            m->grip_type = GRIP_GESTURE_DRAG;
+          else if (0 == g_strcmp0 (class_name, "Pinch"))
+            m->grip_type = GRIP_GESTURE_PINCH;
+          else if (0 == g_strcmp0 (class_name, "Rotate"))
+            m->grip_type = GRIP_GESTURE_ROTATE;
+          else if (0 == g_strcmp0 (class_name, "Tap"))
+            m->grip_type = GRIP_GESTURE_TAP;
+          else
+            m->grip_type = (GripGestureType)100;
+          m->geis_class = gesture_class;
+          priv->classes = g_list_append (priv->classes, m);
+        }
+        break;
+
+      default:
+        /* @todo handle class-changed and class-unavailable events */
+        g_warning ("gesture class event ignored");
+        break;
+    }
+}
+
+
+static void
+grip_geis_event_callback(Geis geis G_GNUC_UNUSED, GeisEvent geis_event, void *context)
+{
+  GripGestureManager *self = GRIP_GESTURE_MANAGER (context);
+  GripGestureManagerPrivate *priv = GRIP_GESTURE_MANAGER_GET_PRIVATE (self);
+
+  switch (geis_event_type(geis_event))
+  {
+    case GEIS_EVENT_DEVICE_AVAILABLE:
+    case GEIS_EVENT_DEVICE_UNAVAILABLE:
+      grip_geis_device_added (self, geis_event);
+      break;
+
+    case GEIS_EVENT_CLASS_AVAILABLE:
+    case GEIS_EVENT_CLASS_CHANGED:
+    case GEIS_EVENT_CLASS_UNAVAILABLE:
+      process_class_event(priv, geis_event);
+      break;
+
+    case GEIS_EVENT_INIT_COMPLETE:
+      break;
+
+    case GEIS_EVENT_GESTURE_BEGIN:
+    case GEIS_EVENT_GESTURE_UPDATE:
+    case GEIS_EVENT_GESTURE_END:
+      process_gesture_events(self, geis_event);
+      break;
+
+    default:
+      g_warning ("event ignored");
+      break;
+  }
+
+  geis_event_delete(geis_event);
+  return;
+}
+
 
 static void
 grip_gesture_manager_dispose (GObject *object G_GNUC_UNUSED)
@@ -267,59 +283,18 @@
 
 
 static void
-free_registration(GripGestureRegistration *reg)
-{
-  GList *tmp = NULL;
-
-  if (!reg)
-    return;
-
-  geis_unsubscribe (reg->instance,
-      (GeisGestureType*)reg->gesture_list->pdata);
-
-  /* We don't need to free the values in the GPtrArray. */
-  g_ptr_array_free (reg->gesture_list, TRUE);
-
-  for (tmp = reg->bindings; tmp != NULL; tmp = tmp->next)
-    {
-      g_free (tmp->data);
-    }
-
-  g_list_free (reg->bindings);
-}
-
-/* Helper function needed to make things work with GTK. */
-
-static void
-free_registration_adapter (gpointer key G_GNUC_UNUSED,
-                           gpointer value,
-                           gpointer user_data G_GNUC_UNUSED)
-{
-  struct Registrations *regs = (struct Registrations *)value;
-  free_registration(regs->touchscreen);
-  free_registration(regs->touchpad);
-  free_registration(regs->independent);
-}
-
-static void
 grip_gesture_manager_finalize (GObject *object)
 {
   GripGestureManagerPrivate *priv = GRIP_GESTURE_MANAGER_GET_PRIVATE (object);
 
-  if (priv->registered_windows != NULL)
-    {
-      g_hash_table_foreach (priv->registered_windows,
-			    free_registration_adapter,
-			    NULL);
-
-      g_hash_table_unref (priv->registered_windows);
-      priv->registered_windows = NULL;
-
-      g_ptr_array_foreach (priv->devices, (GFunc) g_object_unref, NULL);
-      g_ptr_array_unref (priv->devices);
-    }
+  g_list_foreach(priv->classes, (GFunc) g_free, NULL);
+  g_list_free(priv->classes);
+
+  g_ptr_array_foreach (priv->devices, (GFunc) g_object_unref, NULL);
+  g_ptr_array_unref (priv->devices);
 }
 
+
 static GObject *
 grip_gesture_manager_constructor (GType                  type,
                                   guint                  n_params,
@@ -332,12 +307,12 @@
     self = G_OBJECT_CLASS (grip_gesture_manager_parent_class)->
                               constructor (type, n_params, params);
     g_object_add_weak_pointer (self, (gpointer) &self);
-    grip_get_devices (GRIP_GESTURE_MANAGER (self));
   }
 
   return g_object_ref (self);
 }
 
+
 static void
 grip_gesture_manager_class_init (GripGestureManagerClass *class)
 {
@@ -386,7 +361,6 @@
                                               G_TYPE_NONE,
                                               1,
                                               GRIP_TYPE_INPUT_DEVICE);
-
 }
 
 
@@ -420,592 +394,306 @@
   return input_device;
 }
 
-/*
- * registration_for_input_device:
- * @registrations: A collection of #GripGestureRegistration
- * @input_device: A pointer to a #GripInputDevice
- *
- * Determines which #GripGestureRegistration to use dependeng on properties of
- * the #GripInputDevice.
- *
- * Returns: a pointer to a #GripGestureRegistration or %NULL if not found.
- */
-static GripGestureRegistration *
-registration_for_input_device (struct Registrations *registrations,
-                               GripInputDevice      *input_device)
-{
-  GripDeviceType device_type = grip_get_device_type(input_device);
-  if (device_type == GRIP_DEVICE_TOUCHSCREEN)
-  {
-    return registrations->touchscreen;
-  }
-  else if (GRIP_DEVICE_TOUCHPAD)
-  {
-    return registrations->touchpad;
-  }
-  else if (GRIP_DEVICE_INDEPENDENT)
-  {
-    return registrations->independent;
-  }
-  return NULL;
-}
-
 
 static gint
 pinch_gesture_handle_properties (GripEventGesturePinch *event,
-                                 GeisSize               attr_count,
-                                 GeisGestureAttr       *attrs)
+                                 GeisFrame             frame)
 {
-  guint i = 0;
-  gint touches = 0;
-
+  guint attr_count = geis_frame_attr_count (frame);
+  gint num_touches = 0;
+  guint i;
   for (i = 0; i < attr_count; ++i)
     {
-      if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_TOUCHES) == 0 &&
-          attrs[i].type == GEIS_ATTR_TYPE_INTEGER)
-        {
-          touches = attrs[i].integer_val;
-        }
-      if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_TIMESTAMP) == 0 &&
-          attrs[i].type == GEIS_ATTR_TYPE_INTEGER)
-        {
-          event->timestamp = attrs[i].integer_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_FOCUS_X) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->focus_x = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_FOCUS_Y) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->focus_y = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_RADIUS_DELTA) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->radius_delta = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_RADIAL_VELOCITY) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->radial_velocity = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_RADIUS) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->radius = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_POSITION_X) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->position_x = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_POSITION_Y) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->position_y = attrs[i].float_val;
-        }
-    }
+      GeisAttr attr = geis_frame_attr(frame, i);
+      GeisString attr_name = geis_attr_name(attr);
 
-  return touches;
+      if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_TOUCHES) == 0)
+          num_touches = geis_attr_value_to_integer(attr);
+      if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_TIMESTAMP) == 0)
+          event->timestamp = geis_attr_value_to_integer(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_FOCUS_X) == 0)
+          event->focus_x = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_FOCUS_Y) == 0)
+          event->focus_y = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_RADIUS_DELTA) == 0)
+          event->radius_delta = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_RADIAL_VELOCITY) == 0)
+          event->radial_velocity = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_RADIUS) == 0)
+          event->radius = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_POSITION_X) == 0)
+          event->position_x = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_POSITION_Y) == 0)
+          event->position_y = geis_attr_value_to_float(attr);
+   }
+  return num_touches;
 }
 
 static gint
 drag_gesture_handle_properties (GripEventGestureDrag *event,
-                                GeisSize              attr_count,
-                                GeisGestureAttr      *attrs)
+                                GeisFrame             frame)
 {
+  guint attr_count = geis_frame_attr_count (frame);
+  gint num_touches = 0;
   guint i;
-  gint touches = 0;
-
   for (i = 0; i < attr_count; ++i)
     {
-      if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_TOUCHES) == 0 &&
-          attrs[i].type == GEIS_ATTR_TYPE_INTEGER)
-        {
-          touches = attrs[i].integer_val;
-        }
-      if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_TIMESTAMP) == 0 &&
-          attrs[i].type == GEIS_ATTR_TYPE_INTEGER)
-        {
-          event->timestamp = attrs[i].integer_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_FOCUS_X) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->focus_x = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_FOCUS_Y) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->focus_y = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_DELTA_X) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->delta_x = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_DELTA_Y) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->delta_y = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_VELOCITY_X) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->velocity_x = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_VELOCITY_Y) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->velocity_y = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_POSITION_X) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->position_x = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_POSITION_Y) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->position_y = attrs[i].float_val;
-        }
-    }
+      GeisAttr attr = geis_frame_attr(frame, i);
+      GeisString attr_name = geis_attr_name(attr);
 
-  return touches;
+      if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_TOUCHES) == 0)
+          num_touches = geis_attr_value_to_integer(attr);
+      if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_TIMESTAMP) == 0)
+          event->timestamp = geis_attr_value_to_integer(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_FOCUS_X) == 0)
+          event->focus_x = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_FOCUS_Y) == 0)
+          event->focus_y = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_DELTA_X) == 0)
+          event->delta_x = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_DELTA_Y) == 0)
+          event->delta_y = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_VELOCITY_X) == 0)
+          event->velocity_x = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_VELOCITY_Y) == 0)
+          event->velocity_y = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_POSITION_X) == 0)
+          event->position_x = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_POSITION_Y) == 0)
+          event->position_y = geis_attr_value_to_float(attr);
+   }
+  return num_touches;
 }
 
+
 static gint
 rotate_gesture_handle_properties (GripEventGestureRotate *event,
-                                  GeisSize                attr_count,
-                                  GeisGestureAttr        *attrs)
+                                  GeisFrame               frame)
 {
+  guint attr_count = geis_frame_attr_count (frame);
+  gint num_touches = 0;
   guint i;
-  gint touches = 0;
-
   for (i = 0; i < attr_count; ++i)
     {
-      if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_TOUCHES) == 0 &&
-          attrs[i].type == GEIS_ATTR_TYPE_INTEGER)
-        {
-          touches = attrs[i].integer_val;
-        }
-      if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_TIMESTAMP) == 0 &&
-          attrs[i].type == GEIS_ATTR_TYPE_INTEGER)
-        {
-          event->timestamp = attrs[i].integer_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_FOCUS_X) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->focus_x = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_FOCUS_Y) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->focus_y = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_ANGLE_DELTA) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->angle_delta = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_ANGULAR_VELOCITY) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->angular_velocity = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_ANGLE) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->angle = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_POSITION_X) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->position_x = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_POSITION_Y) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->position_y = attrs[i].float_val;
-        }
-    }
+      GeisAttr attr = geis_frame_attr(frame, i);
+      GeisString attr_name = geis_attr_name(attr);
 
-  return touches;
+      if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_TOUCHES) == 0)
+          num_touches = geis_attr_value_to_integer(attr);
+      if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_TIMESTAMP) == 0)
+          event->timestamp = geis_attr_value_to_integer(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_FOCUS_X) == 0)
+          event->focus_x = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_FOCUS_Y) == 0)
+          event->focus_y = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_ANGLE_DELTA) == 0)
+          event->angle_delta = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_ANGULAR_VELOCITY) == 0)
+          event->angular_velocity = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_ANGLE) == 0)
+          event->angle = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_POSITION_X) == 0)
+          event->position_x = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_POSITION_Y) == 0)
+          event->position_y = geis_attr_value_to_float(attr);
+   }
+  return num_touches;
 }
 
+
 static gint
 tap_gesture_handle_properties (GripEventGestureTap *event,
-			       GeisSize             attr_count,
-			       GeisGestureAttr     *attrs)
+                               GeisFrame            frame)
 {
+  guint attr_count = geis_frame_attr_count (frame);
+  gint num_touches = 0;
   guint i;
-  gint touches = 0;
-
   for (i = 0; i < attr_count; ++i)
     {
-      if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_TOUCHES) == 0 &&
-	  attrs[i].type == GEIS_ATTR_TYPE_INTEGER)
-	{
-	  touches = attrs[i].integer_val;
-	}
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_TIMESTAMP) == 0 &&
-          attrs[i].type == GEIS_ATTR_TYPE_INTEGER)
-        {
-          event->timestamp = attrs[i].integer_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_FOCUS_X) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->focus_x = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_FOCUS_Y) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->focus_y = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_POSITION_X) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->position_x = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_POSITION_Y) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_FLOAT)
-        {
-          event->position_y = attrs[i].float_val;
-        }
-      else if (g_strcmp0 (attrs[i].name, GEIS_GESTURE_ATTRIBUTE_TAP_TIME) == 0 &&
-               attrs[i].type == GEIS_ATTR_TYPE_INTEGER)
-        {
-          event->tap_time = attrs[i].float_val;
-        }
-    }
-
-  return touches;
-}
-
-static void
-gesture_added (void              *cookie G_GNUC_UNUSED,
-               GeisGestureType    gesture_type G_GNUC_UNUSED,
-               GeisGestureId      gesture_id G_GNUC_UNUSED,
-               GeisSize           attr_count G_GNUC_UNUSED,
-               GeisGestureAttr   *attrs G_GNUC_UNUSED)
-{
-}
-
-static void
-gesture_removed (void              *cookie G_GNUC_UNUSED,
-                 GeisGestureType    gesture_type G_GNUC_UNUSED,
-                 GeisGestureId      gesture_id G_GNUC_UNUSED,
-                 GeisSize           attr_count G_GNUC_UNUSED,
-                 GeisGestureAttr   *attrs G_GNUC_UNUSED)
-{
-}
-
-static gboolean
-matches_widget (GtkWidget *widget,
-                GdkWindow *window,
-                gint       x,
-                gint       y)
-{
-  GtkAllocation alloc;
-  gint ax, ay;
-
-  gtk_widget_get_allocation (widget, &alloc);
-  gdk_window_get_root_coords (window, alloc.x, alloc.y, &ax, &ay);
-
-  return (x >= ax && x < ax + alloc.width && y >= ay && y < ay + alloc.height);
-}
-
-
-/*
- * process_gesture:
- * @cookie:
- * @type:
- * @id:
- * @attr_count:
- * @attrs:
- * @time_type:
- *
- * The generic gesture event dispatch engine.
- */
-static void
-process_gesture (void              *cookie,
-                 GeisGestureType    type,
-                 GeisGestureId      id,
-                 GeisSize           attr_count,
-                 GeisGestureAttr   *attrs,
-                 GripTimeType       time_type)
-{
-  GripGestureManager *manager = (GripGestureManager *) cookie;
-  GripInputDevice *input_device = NULL;
-  GtkWindow *gtk_window = NULL;
-  struct Registrations *registrations = NULL;
-  GripGestureRegistration *reg = NULL;
-  GList *l = NULL;
+      GeisAttr attr = geis_frame_attr(frame, i);
+      GeisString attr_name = geis_attr_name(attr);
+
+      if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_TOUCHES) == 0)
+          num_touches = geis_attr_value_to_integer(attr);
+      if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_TIMESTAMP) == 0)
+          event->timestamp = geis_attr_value_to_integer(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_FOCUS_X) == 0)
+          event->focus_x = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_FOCUS_Y) == 0)
+          event->focus_y = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_POSITION_X) == 0)
+          event->position_x = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_POSITION_Y) == 0)
+          event->position_y = geis_attr_value_to_float(attr);
+      else if (g_strcmp0 (attr_name, GEIS_GESTURE_ATTRIBUTE_TAP_TIME) == 0)
+          event->tap_time = geis_attr_value_to_float(attr);
+   }
+  return num_touches;
+}
+
+
+static void
+process_gesture_events(GripGestureManager *manager, GeisEvent geis_event)
+{
+  GripGestureManagerPrivate *priv = manager->priv;
+
+  GripTimeType time_type = GRIP_TIME_UPDATE;
+  if (geis_event_type(geis_event) == GEIS_EVENT_GESTURE_BEGIN)
+    time_type = GRIP_TIME_START;
+  else if (geis_event_type(geis_event) == GEIS_EVENT_GESTURE_END)
+    time_type = GRIP_TIME_END;
+
+  GeisAttr attr = geis_event_attr_by_name (geis_event, GEIS_EVENT_ATTRIBUTE_GROUPSET);
+  g_return_if_fail (attr);
+
+  GeisGroupSet groupset = geis_attr_value_to_pointer (attr);
+  g_return_if_fail (groupset);
+
   GeisSize i;
-
-  for (i = 0; i < attr_count; ++i)
-  {
-    if (0 == g_strcmp0(attrs[i].name, GEIS_GESTURE_ATTRIBUTE_DEVICE_ID))
-    {
-      input_device = device_id_to_input_device(manager, attrs[i].integer_val);
-    }
-    else if (0 == g_strcmp0(attrs[i].name, GEIS_GESTURE_ATTRIBUTE_EVENT_WINDOW_ID))
-    {
-      GHashTableIter iter;
-      GtkWidget *key;
-      struct Registrations *value;
-      guint window_id = attrs[i].integer_val;
-
-      g_hash_table_iter_init (&iter, manager->priv->registered_windows);
-      while (g_hash_table_iter_next(&iter, (gpointer *)&key, (gpointer *)&value)) 
-      {
-        if (GDK_WINDOW_XID (gtk_widget_get_window (key)) == window_id)
-        {
-          gtk_window = (GtkWindow *)key;
-          break;
-        }
-      }
-    }
-  }
-  g_return_if_fail(input_device != NULL);
-  g_return_if_fail(gtk_window != NULL);
-
-  registrations = g_hash_table_lookup (manager->priv->registered_windows, gtk_window);
-  g_return_if_fail(registrations != NULL);
-  reg = registration_for_input_device (registrations, input_device);
-  g_return_if_fail(reg != NULL);
-
-  for (l = reg->bindings; l != NULL; l = l->next)
-    {
-      GripGestureBinding *binding = (GripGestureBinding *)l->data;
-
-      if (binding->type == type)
-        {
-          GripGestureEvent *event = grip_gesture_event_new (type);
-
-          if (type == GRIP_GESTURE_DRAG)
-            {
-              GripEventGestureDrag *drag = (GripEventGestureDrag *)event;
-
-              drag->type    = type;
-              drag->id      = id;
-              drag->input_device = input_device;
-              drag->fingers = drag_gesture_handle_properties (drag,
-                  attr_count,
-                  attrs);
-
-              if (drag->fingers == (gint)binding->touches)
-                {
-                  if (matches_widget (binding->widget,
-                                      gtk_widget_get_window(GTK_WIDGET (reg->window)),
-                                      (gint)drag->focus_x,
-                                      (gint)drag->focus_y))
-                    {
-                      binding->callback (binding->widget,
-                                         time_type,
-                                         event,
-                                         binding->data);
-                    }
-                }
-            }
-          else if (type == GRIP_GESTURE_PINCH)
-            {
-              GripEventGesturePinch *pinch = (GripEventGesturePinch *)event;
-
-              pinch->type    = type;
-              pinch->id      = id;
-              pinch->input_device = input_device;
-              pinch->fingers = pinch_gesture_handle_properties (pinch,
-                  attr_count,
-                  attrs);
-
-              if (pinch->fingers == binding->touches)
-                {
-                  if (matches_widget (binding->widget,
-                                      gtk_widget_get_window(GTK_WIDGET (reg->window)),
-                                      (gint)pinch->focus_x,
-                                      (gint)pinch->focus_y))
-                    {
-                      binding->callback (binding->widget,
-                                         time_type,
-                                         event,
-                                         binding->data);
-                    }
-                }
-            }
-          else if (type == GRIP_GESTURE_ROTATE)
-            {
-              GripEventGestureRotate *rotate = (GripEventGestureRotate *)event;
-
-              rotate->type    = type;
-              rotate->id      = id;
-              rotate->input_device = input_device;
-              rotate->fingers = rotate_gesture_handle_properties (rotate,
-                  attr_count,
-                  attrs);
-
-              if (rotate->fingers == binding->touches)
-                {
-                  if (matches_widget (binding->widget,
-                                      gtk_widget_get_window(GTK_WIDGET (reg->window)),
-                                      (gint)rotate->focus_x,
-                                      (gint)rotate->focus_y))
-                    {
-                      binding->callback (binding->widget,
-                                         time_type,
-                                         event,
-                                         binding->data);
-                    }
-                }
-            }
-          else if (type == GRIP_GESTURE_TAP)
-            {
-              GripEventGestureTap *tap = (GripEventGestureTap *)event;
-
-              tap->type    = type;
-              tap->id      = id;
-              tap->input_device = input_device;
-              tap->fingers = tap_gesture_handle_properties (tap,
-                  attr_count,
-                  attrs);
-
-              if (tap->fingers == binding->touches)
-                {
-                  if (matches_widget (binding->widget,
-                                      gtk_widget_get_window(GTK_WIDGET (reg->window)),
-                                      (gint)tap->focus_x,
-                                      (gint)tap->focus_y))
-                    {
-                      binding->callback (binding->widget,
-                                         time_type,
-                                         event,
-                                         binding->data);
-                    }
-                }
-            }
-
-          grip_gesture_event_free (event);
-        }
-    }
-}
-
-static void
-gesture_start (void              *cookie,
-               GeisGestureType    type,
-               GeisGestureId      id,
-               GeisSize           attr_count,
-               GeisGestureAttr   *attrs)
-{
-  process_gesture(cookie, type, id, attr_count, attrs, GRIP_TIME_START);
-}
-
-static void
-gesture_update (void              *cookie,
-                GeisGestureType    type,
-                GeisGestureId      id,
-                GeisSize           attr_count,
-                GeisGestureAttr   *attrs)
-{
-  process_gesture(cookie, type, id, attr_count, attrs, GRIP_TIME_UPDATE);
-}
-
-static void
-gesture_finish (void              *cookie,
-                GeisGestureType    type,
-                GeisGestureId      id,
-                GeisSize           attr_count,
-                GeisGestureAttr   *attrs)
-{
-  process_gesture(cookie, type, id, attr_count, attrs, GRIP_TIME_END);
-}
-
-static void
-grip_gesture_manager_init (GripGestureManager *item)
-{
-  GripGestureManagerPrivate *priv;
-
-  priv = item->priv = GRIP_GESTURE_MANAGER_GET_PRIVATE (item);
-
-  priv->registered_windows = g_hash_table_new (g_direct_hash, g_direct_equal);
-
+  for (i = 0; i < geis_groupset_group_count (groupset); ++i)
+    {
+      GeisGroup group = geis_groupset_group (groupset, i);
+      g_return_if_fail (group);
+
+      GeisSize j;
+      for (j = 0; j < geis_group_frame_count (group); ++j)
+        {
+          GeisFrame frame = geis_group_frame(group, j);
+          g_return_if_fail (frame);
+
+          GeisAttr window_attr = geis_frame_attr_by_name(frame, GEIS_GESTURE_ATTRIBUTE_EVENT_WINDOW_ID);
+          guint window_id = geis_attr_value_to_integer(window_attr);
+
+          GeisAttr device_attr = geis_frame_attr_by_name(frame, GEIS_GESTURE_ATTRIBUTE_DEVICE_ID);
+          guint device_id = geis_attr_value_to_integer(device_attr);
+          GripInputDevice *input_device = device_id_to_input_device (manager, device_id);
+
+          GList *l;
+          for (l = priv->bindings; l != NULL; l = l->next)
+            {
+              GripGestureBinding *binding = (GripGestureBinding *)l->data;
+              guint widget_window_id = GDK_WINDOW_XID (gtk_widget_get_window (binding->widget));
+              if (widget_window_id == window_id)
+                {
+                  GList *class_list;
+                  for (class_list = priv->classes; class_list != NULL; class_list = class_list->next)
+                    {
+                      GripGestureClassMap *p = (GripGestureClassMap *)class_list->data;
+                      if (p->grip_type == binding->type)
+                        {
+                          if (geis_frame_is_class(frame, p->geis_class))
+                            {
+                              GripGestureEvent *grip_event = grip_gesture_event_new (p->grip_type);
+                              if (p->grip_type == GRIP_GESTURE_DRAG)
+                                {
+                                  GripEventGestureDrag *drag = (GripEventGestureDrag *)grip_event;
+                                  drag->type    = p->grip_type;
+                                  drag->id      = geis_frame_id(frame);
+                                  drag->input_device = input_device;
+                                  drag->fingers = drag_gesture_handle_properties (drag, frame);
+                                  binding->callback (binding->widget,
+                                                     time_type,
+                                                     grip_event,
+                                                     binding->data);
+                                }
+                              else if (p->grip_type == GRIP_GESTURE_PINCH)
+                                {
+                                  GripEventGesturePinch *pinch = (GripEventGesturePinch *)grip_event;
+                                  pinch->type    = p->grip_type;
+                                  pinch->id      = geis_frame_id(frame);
+                                  pinch->input_device = input_device;
+                                  pinch->fingers = pinch_gesture_handle_properties (pinch, frame);
+                                  binding->callback (binding->widget,
+                                                     time_type,
+                                                     grip_event,
+                                                     binding->data);
+                                }
+                              else if (p->grip_type == GRIP_GESTURE_ROTATE)
+                                {
+                                  GripEventGestureRotate *rotate = (GripEventGestureRotate *)grip_event;
+                                  rotate->type    = p->grip_type;
+                                  rotate->id      = geis_frame_id(frame);
+                                  rotate->input_device = input_device;
+                                  rotate->fingers = rotate_gesture_handle_properties (rotate, frame);
+                                  binding->callback (binding->widget,
+                                                     time_type,
+                                                     grip_event,
+                                                     binding->data);
+                                }
+                              else if (p->grip_type == GRIP_GESTURE_TAP)
+                                {
+                                  GripEventGestureTap *tap = (GripEventGestureTap *)grip_event;
+                                  tap->type    = p->grip_type;
+                                  tap->id      = geis_frame_id(frame);
+                                  tap->input_device = input_device;
+                                  tap->fingers = tap_gesture_handle_properties (tap, frame);
+                                  binding->callback (binding->widget,
+                                                     time_type,
+                                                     grip_event,
+                                                     binding->data);
+                                }
+                              grip_gesture_event_free (grip_event);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+static gboolean
+grip_geis_event_ready (GIOChannel   *source G_GNUC_UNUSED,
+                       GIOCondition  condition G_GNUC_UNUSED,
+                       gpointer      context)
+{
+  Geis geis = (Geis)context;
+  GeisStatus status G_GNUC_UNUSED = geis_dispatch_events(geis);
+  return TRUE;
+}
+
+
+static void
+grip_gesture_manager_init (GripGestureManager *self)
+{
+  GripGestureManagerPrivate *priv = self->priv = GRIP_GESTURE_MANAGER_GET_PRIVATE (self);
   priv->devices = g_ptr_array_new ();
-}
-
-static gboolean
-io_callback (GIOChannel   *source G_GNUC_UNUSED,
-             GIOCondition  condition G_GNUC_UNUSED,
-             gpointer      data)
-{
-  GripGestureRegistration *reg = (GripGestureRegistration *)data;
-
-  geis_event_dispatch (reg->instance);
-
-  return TRUE;
-}
-
-static void
-destroy_registration(GripGestureRegistration *reg)
-{
-  GList *list;
-
-  for (list = reg->bindings; list != NULL; list = list->next)
-    {
-      GripGestureBinding *binding = (GripGestureBinding *)list->data;
-
-      if (binding->destroy)
-        {
-          GDestroyNotify d = binding->destroy;
-
-          d (binding->data);
-        }
-
-      g_free (binding);
-    }
-
-  g_list_free (reg->bindings);
-
-  g_io_channel_shutdown (reg->iochannel, FALSE, NULL);
-  g_source_remove (reg->iochannel_id);
-  g_io_channel_unref (reg->iochannel);
-
-  geis_finish (reg->instance);
-
-  reg->instance = NULL;
-  reg->iochannel = NULL;
-}
+
+  priv->geis = geis_new (GEIS_INIT_TRACK_DEVICES, GEIS_INIT_TRACK_GESTURE_CLASSES, NULL);
+  g_return_if_fail (priv->geis);
+
+  int fd;
+  geis_get_configuration(priv->geis, GEIS_CONFIGURATION_FD, &fd);
+  priv->iochannel = g_io_channel_unix_new (fd);
+  priv->iochannel_id = g_io_add_watch (priv->iochannel, G_IO_IN, grip_geis_event_ready, priv->geis);
+  geis_register_device_callback (priv->geis, grip_geis_event_callback, self);
+  geis_register_class_callback (priv->geis, grip_geis_event_callback, self);
+  geis_register_event_callback (priv->geis, grip_geis_event_callback, self);
+}
+
 
 static void
 window_destroyed_cb (GtkWidget *object,
                      gpointer   user_data)
 {
   GripGestureManager *manager = (GripGestureManager *)user_data;
-  GripGestureManagerPrivate *priv = manager->priv;
-  struct Registrations *reg = g_hash_table_lookup (priv->registered_windows, object);
-
-  if (!reg)
-    return;
-
-  destroy_registration(reg->touchpad);
-  destroy_registration(reg->touchscreen);
-  destroy_registration(reg->independent);
-
-  g_hash_table_remove (priv->registered_windows, object);
-  g_free (reg);
-}
-
-static const gchar *
-grip_type_to_geis_type (GripGestureType gesture_type,
-			gint            touch_points)
-{
-  /* grail taps begin at 15, so let's convert that into something we
-   * can index in geis_gesture_types. */
-  int t = gesture_type == 15 ? 3 : gesture_type;
-
-  return geis_gesture_types[(t * 5 + touch_points) - 1];
+  GList *l = manager->priv->bindings;
+  while (l != NULL)
+    {
+      GList *next = l->next;
+      GripGestureBinding *binding = l->data;
+      if (gtk_widget_get_toplevel (binding->widget) == object)
+        {
+          geis_subscription_delete (binding->subscription);
+
+          if (binding->destroy)
+            binding->destroy (binding->data);
+          g_free (binding);
+          manager->priv->bindings = g_list_delete_link (manager->priv->bindings, l);
+        }
+      l = next;
+    }
 }
 
 
@@ -1017,232 +705,207 @@
 }
 
 
+/*
+ * processed_mapped_window_request:
+ * @reg: a #GripRegistrationRequest (removed from the GripGestureManager
+ * requests listand freed).
+ *
+ * Creates a subscription for a widget mapped to a window.
+ */
 static void
-grip_devices_for_type (GripDeviceType type, GArray *selection,
-                       GripDevices *devices)
+processed_mapped_window_request (GripRegistrationRequest *req)
 {
-  guint i;
-
-  for (i = 0; i < devices->len; ++i)
+  g_return_if_fail (GRIP_IS_GESTURE_MANAGER (req->manager));
+  g_return_if_fail (GTK_IS_WIDGET (req->widget));
+
+  GtkWidget *toplevel = gtk_widget_get_toplevel (req->widget);
+  g_return_if_fail (GTK_IS_WINDOW (toplevel));
+
+  GripGestureManagerPrivate *priv = req->manager->priv;
+
+  guint window_id = GDK_WINDOW_XID (gtk_widget_get_window(req->widget));
+
+  /* XXX - check for duplicates in reg->bindings first */
+  GripGestureBinding *binding = g_new0 (GripGestureBinding, 1);
+  binding->type     = req->gesture_type;
+  binding->widget   = req->widget;
+  binding->touches  = req->touch_points;
+  binding->callback = req->callback;
+  binding->data     = req->user_data;
+  binding->destroy  = req->destroy;
+
+  char sub_name[48];
+  snprintf(sub_name, 48, "sub-%x-%x-%x", window_id,  req->gesture_type, req->touch_points);
+  binding->subscription = geis_subscription_new (priv->geis, sub_name, GEIS_SUBSCRIPTION_CONT);
+  g_return_if_fail (binding->subscription);
+
+  char  filter_id[20];
+  snprintf(filter_id, 20, "grip-%x", window_id);
+  GeisFilter window_filter = geis_filter_new(priv->geis, filter_id);
+  geis_filter_add_term(window_filter, GEIS_FILTER_REGION,
+                       GEIS_REGION_ATTRIBUTE_WINDOWID, GEIS_FILTER_OP_EQ, window_id,
+                       NULL);
+
+  switch (req->gesture_type)
   {
-    GripInputDevice *input_device = g_ptr_array_index (devices, i);
-    GeisInputDeviceId id = grip_input_device_get_id (input_device);
-    GripDeviceType device_type= grip_get_device_type(input_device);
-
-    if ((type & GRIP_DEVICE_TOUCHSCREEN) && device_type == GRIP_DEVICE_TOUCHSCREEN)
-    {
-      g_array_append_val (selection, id);
-    }
-    if ((type & GRIP_DEVICE_TOUCHPAD) && device_type == GRIP_DEVICE_TOUCHPAD)
-    {
-      g_array_append_val (selection, id);
-    }
-    if ((type & GRIP_DEVICE_INDEPENDENT) && device_type == GRIP_DEVICE_INDEPENDENT)
-    {
-      g_array_append_val (selection, id);
-    }
+    case GRIP_GESTURE_DRAG:
+      geis_filter_add_term(window_filter, GEIS_FILTER_CLASS,
+                           GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, GEIS_GESTURE_DRAG,
+                           GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, req->touch_points,
+                           NULL);
+      break;
+    case GRIP_GESTURE_PINCH:
+      geis_filter_add_term(window_filter, GEIS_FILTER_CLASS,
+                           GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, GEIS_GESTURE_PINCH,
+                           GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, req->touch_points,
+                           NULL);
+      break;
+    case GRIP_GESTURE_ROTATE:
+      geis_filter_add_term(window_filter, GEIS_FILTER_CLASS,
+                           GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, GEIS_GESTURE_ROTATE,
+                           GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, req->touch_points,
+                           NULL);
+      break;
+    case GRIP_GESTURE_TAP:
+      geis_filter_add_term(window_filter, GEIS_FILTER_CLASS,
+                           GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_EQ, GEIS_GESTURE_TAP,
+                           GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_EQ, req->touch_points,
+                           NULL);
+      break;
   }
-}
-
-/*
- * new_window_registration:
- * @manager: a GripGestureManager
- * @toplevel: a toplevel #GtkWindow
- *
- * Constructs a new #GripGestureRegistration for a #GtkWidget.
- */
-static GripGestureRegistration *
-new_window_registration(GripGestureManager *manager,
-                        GtkWidget          *toplevel)
-{
-  GripGestureRegistration *reg;
-  GeisInstance  instance;
-  gint fd = -1;
-  GeisXcbWinInfo xcb_win_info = {
-    .display_name = NULL,
-    .screenp      = NULL,
-    .window_id    = GDK_WINDOW_XID (gtk_widget_get_window(toplevel))
-  };
-  GeisWinInfo win_info = {
-    GEIS_XCB_FULL_WINDOW,
-    &xcb_win_info
-  };
-
-  if (geis_init (&win_info, &instance) != GEIS_STATUS_SUCCESS)
-    {
-      g_warning ("Failed to initialize gesture manager.");
-      return NULL;
-    }
-
-  if (geis_configuration_supported (instance,
-                                    GEIS_CONFIG_UNIX_FD) != GEIS_STATUS_SUCCESS)
-    {
-      g_warning ("Gesture manager does not support UNIX fd.");
-      return NULL;
-    }
-
-  if (geis_configuration_get_value (instance,
-                                    GEIS_CONFIG_UNIX_FD,
-                                    &fd) != GEIS_STATUS_SUCCESS)
-    {
-      g_error ("Gesture manager failed to obtain UNIX fd.");
-      return NULL;
-    }
-
-  reg = g_new0 (GripGestureRegistration, 1);
-
-  reg->window   = GTK_WINDOW (toplevel);
-  reg->instance = instance;
+
+  if (req->device_type & GRIP_DEVICE_TOUCHSCREEN)
+    {
+      char filter_name[32];
+      snprintf(filter_name, 32, "%s/touchscreen", filter_id);
+      GeisFilter touchscreen_filter = geis_filter_clone (window_filter, filter_name);
+      geis_filter_add_term(touchscreen_filter, GEIS_FILTER_DEVICE,
+                           GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH, GEIS_FILTER_OP_EQ, GEIS_TRUE,
+                           NULL);
+      GeisStatus status = geis_subscription_add_filter(binding->subscription, touchscreen_filter);
+      g_return_if_fail (status == GEIS_STATUS_SUCCESS);
+    }
+  if (req->device_type & GRIP_DEVICE_TOUCHPAD)
+    {
+      char filter_name[32];
+      snprintf(filter_name, 32, "%s/touchpad", filter_id);
+      GeisFilter touchpad_filter = geis_filter_clone (window_filter, filter_name);
+      geis_filter_add_term(touchpad_filter, GEIS_FILTER_DEVICE,
+                           GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH, GEIS_FILTER_OP_EQ, GEIS_FALSE,
+                           NULL);
+      GeisStatus status = geis_subscription_add_filter(binding->subscription, touchpad_filter);
+      g_return_if_fail (status == GEIS_STATUS_SUCCESS);
+    }
+  if (req->device_type & GRIP_DEVICE_INDEPENDENT)
+    {
+      char filter_name[32];
+      snprintf(filter_name, 32, "%s/indep", filter_id);
+      GeisFilter indep_filter = geis_filter_clone (window_filter, filter_name);
+      geis_filter_add_term(indep_filter, GEIS_FILTER_DEVICE,
+                           GEIS_DEVICE_ATTRIBUTE_INDEPENDENT_TOUCH, GEIS_FILTER_OP_EQ, GEIS_TRUE,
+                           NULL);
+      GeisStatus status = geis_subscription_add_filter(binding->subscription, indep_filter);
+      g_return_if_fail (status == GEIS_STATUS_SUCCESS);
+    }
+
+  /*
+   * If any device types were specified, the window_filter was cloned and needs
+   * to be disposed of, otehrwise it's _the_ filter.
+   */
+  if (req->device_type)
+    {
+      geis_filter_delete(window_filter);
+    }
+  else
+    {
+      GeisStatus status = geis_subscription_add_filter(binding->subscription, window_filter);
+      g_return_if_fail (status == GEIS_STATUS_SUCCESS);
+    }
+
+
+  GeisStatus status = geis_subscription_activate (binding->subscription);
+  g_return_if_fail (status == GEIS_STATUS_SUCCESS);
+
+  priv->bindings = g_list_append (priv->bindings, binding);
 
   g_signal_connect (toplevel,
                     "destroy",
                     G_CALLBACK (window_destroyed_cb),
-                    manager);
-
-  reg->iochannel = g_io_channel_unix_new (fd);
-  reg->iochannel_id = g_io_add_watch (reg->iochannel,
-                                      G_IO_IN,
-                                      io_callback,
-                                      reg);
-  reg->gesture_list = g_ptr_array_new ();
-
-  return reg;
-}
-
-static void
-bind_registration(GripGestureManager *manager,
-    GripGestureRegistration *reg,
-    GtkWidget               *widget,
-    GripGestureType         gesture_type,
-    GripDeviceType          device_type,
-    gint                    touch_points,
-    GripGestureCallback     callback,
-    gpointer                user_data,
-    GDestroyNotify          destroy)
-{
-  GripGestureManagerPrivate *priv;
-  GripGestureBinding *binding;
-  GArray *devices;
-
-  priv = manager->priv;
-
-  if (reg->gesture_list->len)
-    g_ptr_array_remove_index (reg->gesture_list,
-                              reg->gesture_list->len - 1);
-
-  devices = g_array_new (TRUE, FALSE, sizeof(GeisInputDeviceId));
-  grip_devices_for_type(device_type, devices, priv->devices);
-  if (devices->len == 0) {
-      g_array_free(devices, TRUE);
-      return;
-  }
-
-  g_ptr_array_add (reg->gesture_list,
-                   (gchar *)grip_type_to_geis_type (gesture_type, touch_points));
-  g_ptr_array_add (reg->gesture_list,
-                   NULL);
-
-  geis_subscribe (reg->instance,
-                  (GeisInputDeviceId *)(void *)devices->data,
-                  (const char**)reg->gesture_list->pdata,
-                  &gesture_funcs,
-                  manager);
-
-  g_array_unref (devices);
-
-  /* XXX - check for duplicates in reg->bindings first */
-  binding = g_new0 (GripGestureBinding, 1);
-
-  binding->type     = gesture_type;
-  binding->widget   = widget;
-  binding->touches  = touch_points;
-  binding->callback = callback;
-  binding->data     = user_data;
-  binding->destroy  = destroy;
-
-  reg->bindings = g_list_append (reg->bindings, binding);
-}
-
-/*
- * register_internal:
- * @manager: the @GripGestureManager
- * @widget: the GtkWidget to be bound
- * @gesture_type: the type of gesture to subscribe for
- * @device_type: the type of input device to subscribe for
- * @touch_points: 
- * @callback: the callback to be invoked on gesture events
- * @user_data: the callbackl context to be passed back on gesture events
- * @destroy:
- *
- * Binds or rebinds a gesture subscription for a widget.
- */
-static void
-register_internal (GripGestureManager *manager,
-                   GtkWidget          *widget,
-                   GripGestureType     gesture_type,
-                   GripDeviceType      device_type,
-                   gint                touch_points,
-                   GripGestureCallback callback,
-                   gpointer            user_data,
-                   GDestroyNotify      destroy)
-{
-  GripGestureManagerPrivate *priv;
-  GtkWidget *toplevel;
-  struct Registrations *registrations;
-
-  g_return_if_fail (GRIP_IS_GESTURE_MANAGER (manager));
-  g_return_if_fail (GTK_IS_WIDGET (widget));
-
-  toplevel = gtk_widget_get_toplevel (widget);
-
-  g_return_if_fail (GTK_IS_WINDOW (toplevel));
-
-  priv = manager->priv;
-
-  if (!(registrations = g_hash_table_lookup (priv->registered_windows, toplevel)))
-    {
-      registrations = g_new(struct Registrations, 1);
-      registrations->touchscreen = new_window_registration(manager, toplevel);
-      registrations->touchpad = new_window_registration(manager, toplevel);
-      registrations->independent = new_window_registration(manager, toplevel);
-
-      if (registrations->touchscreen == NULL ||
-          registrations->touchpad == NULL ||
-          registrations->independent == NULL)
-        return;
+                    req->manager);
+
+  /* remove the request from the watch list */
+  g_free (req);
+  priv->requests = g_list_remove (priv->requests, req);
+}
+
+
+/*
+ * register_mapped_window:
+ * @manager: a Grip gesture manager object
+ * @toplevel: a top-level widget
+ *
+ * Processes all subscriptions requests for a newly-mapped window.
+ */
+static void
+register_mapped_window (GripGestureManager *manager, GtkWidget *toplevel)
+{
+  g_return_if_fail (gtk_widget_is_toplevel (toplevel));
+
+  GList *pending_request = manager->priv->requests;
+  while (pending_request)
+    {
+      GList *next = pending_request->next;
+      GripRegistrationRequest *req = pending_request->data;
+
+      if (gtk_widget_get_toplevel (req->widget) == toplevel)
+        {
+              processed_mapped_window_request (req);
+        }
+      pending_request = next;
+    }
+}
+
+
+/*
+ * register_toplevel_widget:
+ * @manager: a Grip gesture manager object
+ * @toplevel: a top-level widget
+ *
+ * Handles the registration of a widget that has just become a top-level widget.
+ *
+ * If the top-level widget is mapped to a window, it;s handled right away.
+ * Otherwise, a callback is queued for when it does become mapped to a window.
+ */
+static void
+register_toplevel_widget (GripGestureManager *manager, GtkWidget *toplevel)
+{
+  g_return_if_fail (gtk_widget_is_toplevel (toplevel));
+
+  if (gtk_widget_get_mapped (GTK_WIDGET (toplevel)))
+    {
+      register_mapped_window (manager, toplevel);
     }
   else
     {
-      if (device_type & GRIP_DEVICE_TOUCHSCREEN)
-        geis_unsubscribe (registrations->touchscreen->instance,
-            (GeisGestureType*)registrations->touchscreen->gesture_list->pdata);
-      if (device_type & GRIP_DEVICE_TOUCHPAD)
-        geis_unsubscribe (registrations->touchpad->instance,
-            (GeisGestureType*)registrations->touchpad->gesture_list->pdata);
-      if (device_type & GRIP_DEVICE_INDEPENDENT)
-        geis_unsubscribe (registrations->independent->instance,
-            (GeisGestureType*)registrations->independent->gesture_list->pdata);
+      g_signal_connect (toplevel,
+                        "map-event",
+                        G_CALLBACK (toplevel_mapped_cb),
+                        manager);
     }
-
-  if (device_type & GRIP_DEVICE_TOUCHSCREEN)
-    bind_registration(manager,
-        registrations->touchscreen, widget, gesture_type, GRIP_DEVICE_TOUCHSCREEN, touch_points,
-        callback, user_data, destroy);
-
-  if (device_type & GRIP_DEVICE_TOUCHPAD)
-    bind_registration(manager,
-        registrations->touchpad, widget, gesture_type, GRIP_DEVICE_TOUCHPAD, touch_points,
-        callback, user_data, destroy);
-
-  if (device_type & GRIP_DEVICE_INDEPENDENT)
-    bind_registration(manager,
-        registrations->independent, widget, gesture_type, GRIP_DEVICE_INDEPENDENT, touch_points,
-        callback, user_data, destroy);
-  g_hash_table_insert (priv->registered_windows,
-                       toplevel,
-                       registrations);
 }
 
+
+/*
+ * toplevel_notify_cb:
+ *
+ * Called when a widget property has changed.
+ *
+ * The only widget property we're interested in here is the "parent" property.
+ * We can't subscribe to gestures on a window until the widget is mapped to a
+ * window.  Only top-level widgets can be mapped to a window:  we just keep
+ * queueing this callback on successive parent widgets until one is a top-level
+ * widget, then process that one.
+ */
 static void
 toplevel_notify_cb (GtkWidget    *widget,
                     GParamSpec   *pspec,
@@ -1251,7 +914,7 @@
   if (pspec->name == g_intern_static_string ("parent"))
     {
       GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
-      GripRegistrationRequest *req = (GripRegistrationRequest *)user_data;
+      GripGestureManager *manager = (GripGestureManager *)user_data;
 
       g_signal_handlers_disconnect_by_func (widget,
                                             G_CALLBACK (toplevel_notify_cb),
@@ -1259,30 +922,7 @@
 
       if (gtk_widget_is_toplevel (toplevel))
         {
-          if (gtk_widget_get_mapped (GTK_WIDGET (toplevel)))
-            {
-              register_internal (req->manager,
-                                 req->widget,
-                                 req->gesture_type,
-                                 req->device_type,
-                                 req->touch_points,
-                                 req->callback,
-                                 req->user_data,
-                                 req->destroy);
-
-              g_free (req);
-            }
-          else
-            {
-              GripGestureManagerPrivate *priv = req->manager->priv;
-
-              priv->requests = g_list_append (priv->requests, req);
-
-              g_signal_connect (toplevel,
-                                "map-event",
-                                G_CALLBACK (toplevel_mapped_cb),
-                                req->manager);
-            }
+          register_toplevel_widget (manager, toplevel);
         }
       else
         {
@@ -1294,96 +934,29 @@
     }
 }
 
+
 /*
- * register_widget:
- *
- * Registers a specific widget for a specific gesture made by a specific input
- * device type.
- *
- * If the widget's containing window is a valid window, the widget is registered
- * right away, otherwise the registration is deferred until the widget actually
- * has a top-level window.
+ * toplevel_mapped_cb:
+ *
+ * A callback invoked when a toplevel widget with one or more pending gesture
+ * registration requests has been mapped to a window.
+ *
+ * This callback will in fact process all pending registration requests for the
+ * newly-mapped window.
  */
 static void
-register_widget (GripGestureManager *manager,
-                 GtkWidget          *widget,
-                 GripGestureType     gesture_type,
-                 GripDeviceType      device_type,
-                 gint                touch_points,
-                 GripGestureCallback callback,
-                 gpointer            user_data,
-                 GDestroyNotify      destroy)
-{
-  GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
-
-  if (gtk_widget_is_toplevel (toplevel))
-    {
-      register_internal (manager,
-                         widget,
-                         gesture_type,
-                         device_type,
-                         touch_points,
-                         callback,
-                         user_data,
-                         destroy);
-    }
-  else
-    {
-      GripRegistrationRequest *req = g_new0 (GripRegistrationRequest, 1);
-
-      req->manager      = manager;
-      req->widget       = widget;
-      req->gesture_type = gesture_type;
-      req->device_type  = device_type;
-      req->touch_points = touch_points;
-      req->callback     = callback;
-      req->user_data    = user_data;
-      req->destroy      = destroy;
-
-      g_signal_connect (toplevel,
-                        "notify",
-                        G_CALLBACK (toplevel_notify_cb),
-                        req);
-    }
-}
-
-static void
 toplevel_mapped_cb (GtkWidget   *toplevel,
                     GdkEvent    *event G_GNUC_UNUSED,
                     gpointer     user_data)
 {
   GripGestureManager *manager = (GripGestureManager *)user_data;
-  GripGestureManagerPrivate *priv = manager->priv;
-  GList *request = priv->requests;
-
-  while (request)
-    {
-      GList *next = request->next;
-      GripRegistrationRequest *req = request->data;
-
-      if (gtk_widget_get_toplevel (req->widget) == toplevel)
-        {
-	  register_widget (req->manager,
-                           req->widget,
-                           req->gesture_type,
-                           req->device_type,
-                           req->touch_points,
-                           req->callback,
-                           req->user_data,
-                           req->destroy);
-
-          priv->requests = g_list_remove_link (priv->requests, request);
-          g_free (req);
-          g_list_free_1 (request);
-        }
-      request = next;
-    }
-
+  register_mapped_window (manager, toplevel);
   g_signal_handlers_disconnect_by_func (toplevel,
                                         toplevel_mapped_cb,
                                         user_data);
 }
 
+
 /**
  * grip_gesture_manager_register_window:
  * @manager: A #GripGestureManager instance.
@@ -1411,102 +984,47 @@
                                       gpointer             user_data,
                                       GDestroyNotify       destroy)
 {
-  GtkWidget *toplevel;
-
   g_return_if_fail (GRIP_IS_GESTURE_MANAGER (manager));
   g_return_if_fail (GTK_IS_WIDGET (widget));
 
-  toplevel = gtk_widget_get_toplevel (widget);
+  GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+
+  GripRegistrationRequest *req = g_new0 (GripRegistrationRequest, 1);
+  req->manager      = manager;
+  req->widget       = widget;
+  req->gesture_type = gesture_type;
+  req->device_type  = device_type;
+  req->touch_points = touch_points;
+  req->callback     = callback;
+  req->user_data    = user_data;
+  req->destroy      = destroy;
+  manager->priv->requests = g_list_append (manager->priv->requests, req);
 
   if (GTK_IS_WINDOW (toplevel))
     {
-      if (gtk_widget_get_mapped (GTK_WIDGET (toplevel)))
-        {
-          register_internal (manager,
-                             widget,
-                             gesture_type,
-                             device_type,
-                             touch_points,
-                             callback,
-                             user_data,
-                             destroy);
-        }
-      else
-        {
-          GripRegistrationRequest *req = g_new0 (GripRegistrationRequest, 1);
-          GripGestureManagerPrivate *priv = manager->priv;
-
-          req->manager      = manager;
-          req->widget       = widget;
-          req->gesture_type = gesture_type;
-          req->device_type  = device_type;
-          req->touch_points = touch_points;
-          req->callback     = callback;
-          req->user_data    = user_data;
-          req->destroy      = destroy;
-
-          priv->requests = g_list_append (priv->requests, req);
-
-          g_signal_connect (toplevel,
-                            "map-event",
-                            G_CALLBACK (toplevel_mapped_cb),
-                            manager);
-        }
+      register_toplevel_widget (manager, toplevel);
     }
   else
     {
-      GripRegistrationRequest *req = g_new0 (GripRegistrationRequest, 1);
-
-      req->manager      = manager;
-      req->widget       = widget;
-      req->gesture_type = gesture_type;
-      req->device_type  = device_type;
-      req->touch_points = touch_points;
-      req->callback     = callback;
-      req->user_data    = user_data;
-      req->destroy      = destroy;
-
       g_signal_connect (toplevel,
                         "notify",
                         G_CALLBACK (toplevel_notify_cb),
-                        req);
+                        manager);
     }
 }
 
-static void
-shutdown_registration(GripGestureRegistration *reg)
-{
-  free_registration(reg);
-  geis_finish(reg->instance);
-  reg->instance = NULL;
-  g_free(reg);
-}
 
 void
-grip_gesture_manager_unregister_window (GripGestureManager  *manager,
-                                        GtkWidget           *toplevel)
+grip_gesture_manager_unregister_window (GripGestureManager  *manager G_GNUC_UNUSED,
+                                        GtkWidget           *toplevel G_GNUC_UNUSED)
 {
-  GripGestureManagerPrivate *priv = manager->priv;
-  struct Registrations *registrations;
-
   g_return_if_fail (GRIP_IS_GESTURE_MANAGER (manager));
   g_return_if_fail (GTK_IS_WINDOW (toplevel));
 
-  /* Currently only allow unsubscribing after the window has been shown. */
-  g_return_if_fail (gtk_widget_get_mapped (GTK_WIDGET (toplevel)));
-  registrations = g_hash_table_lookup (priv->registered_windows, toplevel);
-  if (!registrations) {
-      return;
-  }
-
-  shutdown_registration(registrations->touchscreen);
-  shutdown_registration(registrations->touchpad);
-  shutdown_registration(registrations->independent);
-  g_free(registrations);
-  g_hash_table_remove(priv->registered_windows, toplevel);
-
+  window_destroyed_cb (toplevel, manager);
 }
 
+
 GType
 grip_gesture_event_get_type (void)
 {
 
=== modified file 'src/gripinputdevice.c'
--- src/gripinputdevice.c	2011-10-19 14:05:35 +0000
+++ src/gripinputdevice.c	2013-04-17 15:02:24 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 Canonical, Ltd.
+ * Copyright 2011, 2013 Canonical Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of either or both of the following licenses:
@@ -79,53 +79,61 @@
 	for (a = attrs; a->name; a++)
 	{
 	  if (0 == g_strcmp0 (a->name, GEIS_DEVICE_ATTRIBUTE_NAME))
-	  {
 	    input_device->priv->name = g_strdup (a->string_val);
-	  }
 	  else if (0 == g_strcmp0 (a->name, GEIS_DEVICE_ATTRIBUTE_ID))
-	  {
 	    input_device->priv->device_id = a->integer_val;
-	  }
 	  else if (0 == g_strcmp0 (a->name, GEIS_DEVICE_ATTRIBUTE_TOUCHES))
-	  {
 	    input_device->priv->touches = a->integer_val;
-	  }
 	  else if (0 == g_strcmp0 (a->name, GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH))
-	  {
 	    input_device->priv->is_direct = a->boolean_val;
-	  }
 	  else if (0 == g_strcmp0 (a->name, GEIS_DEVICE_ATTRIBUTE_INDEPENDENT_TOUCH))
-	  {
 	    input_device->priv->is_independent = a->boolean_val;
-	  }
 	  else if (0 == g_strcmp0 (a->name, GEIS_DEVICE_ATTRIBUTE_MIN_X))
-	  {
 	    input_device->priv->x_extents.minimum = a->float_val;
-	  }
 	  else if (0 == g_strcmp0 (a->name, GEIS_DEVICE_ATTRIBUTE_MAX_X))
-	  {
 	    input_device->priv->x_extents.maximum = a->float_val;
-	  }
 	  else if (0 == g_strcmp0 (a->name, GEIS_DEVICE_ATTRIBUTE_RES_X))
-	  {
 	    input_device->priv->x_extents.resolution = a->float_val;
-	  }
 	  else if (0 == g_strcmp0 (a->name, GEIS_DEVICE_ATTRIBUTE_MIN_Y))
-	  {
 	    input_device->priv->y_extents.minimum = a->float_val;
-	  }
 	  else if (0 == g_strcmp0 (a->name, GEIS_DEVICE_ATTRIBUTE_MAX_Y))
-	  {
 	    input_device->priv->y_extents.maximum = a->float_val;
-	  }
 	  else if (0 == g_strcmp0 (a->name, GEIS_DEVICE_ATTRIBUTE_RES_Y))
-	  {
 	    input_device->priv->y_extents.resolution = a->float_val;
-	  }
 	}
       }
     }
   }
+  else
+  {
+    guint num_attrs = geis_device_attr_count(input_device->priv->geis_device);
+    for (i = 0; i < num_attrs; ++i)
+    {
+       GeisAttr attr = geis_device_attr(input_device->priv->geis_device, i);
+        if (0 == g_strcmp0 (geis_attr_name(attr), GEIS_DEVICE_ATTRIBUTE_NAME))
+          input_device->priv->name = g_strdup (geis_attr_value_to_string(attr));
+        else if (0 == g_strcmp0 (geis_attr_name(attr), GEIS_DEVICE_ATTRIBUTE_ID))
+          input_device->priv->device_id = geis_attr_value_to_integer(attr);
+        else if (0 == g_strcmp0 (geis_attr_name(attr), GEIS_DEVICE_ATTRIBUTE_TOUCHES))
+          input_device->priv->touches = geis_attr_value_to_integer(attr);
+        else if (0 == g_strcmp0 (geis_attr_name(attr), GEIS_DEVICE_ATTRIBUTE_DIRECT_TOUCH))
+          input_device->priv->is_direct = geis_attr_value_to_boolean(attr);
+        else if (0 == g_strcmp0 (geis_attr_name(attr), GEIS_DEVICE_ATTRIBUTE_INDEPENDENT_TOUCH))
+          input_device->priv->is_independent = geis_attr_value_to_boolean(attr);
+        else if (0 == g_strcmp0 (geis_attr_name(attr), GEIS_DEVICE_ATTRIBUTE_MIN_X))
+          input_device->priv->x_extents.minimum = geis_attr_value_to_float(attr);
+        else if (0 == g_strcmp0 (geis_attr_name(attr), GEIS_DEVICE_ATTRIBUTE_MAX_X))
+          input_device->priv->x_extents.maximum = geis_attr_value_to_float(attr);
+        else if (0 == g_strcmp0 (geis_attr_name(attr), GEIS_DEVICE_ATTRIBUTE_RES_X))
+          input_device->priv->x_extents.resolution = geis_attr_value_to_float(attr);
+        else if (0 == g_strcmp0 (geis_attr_name(attr), GEIS_DEVICE_ATTRIBUTE_MIN_Y))
+          input_device->priv->y_extents.minimum = geis_attr_value_to_float(attr);
+        else if (0 == g_strcmp0 (geis_attr_name(attr), GEIS_DEVICE_ATTRIBUTE_MAX_Y))
+          input_device->priv->y_extents.maximum = geis_attr_value_to_float(attr);
+        else if (0 == g_strcmp0 (geis_attr_name(attr), GEIS_DEVICE_ATTRIBUTE_RES_Y))
+          input_device->priv->y_extents.resolution = geis_attr_value_to_float(attr);
+    }
+  }
 
   return object;
 }