Merge lp:~oif-team/geis/geis2-add-gesture-class into lp:geis

[Stephen M. Webb]

Adds the GEIS v2.0 gesture class module.

[Chase Douglas (chasedouglas)]

Overall looks fine.

review: Approve

=== modified file 'ChangeLog'
--- ChangeLog	2011-01-06 00:56:16 +0000
+++ ChangeLog	2011-01-13 16:20:11 +0000
@@ -1,3 +1,73 @@
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Added Geis v2.0 gesture class implementation (part 2, utouch internals)
+
+  * testsuite/libutouch-geis/check_class.c: new test suite
+  * include/geis/geis.h: fixed GEIS_FILTER_CLASS
+  * libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c
+    (_create_test_classes): new function
+  * libutouch-geis/backend/test_fixture/geis_backend_test_fixture.h
+    (geis_backend_new_test_fixture): added track_classes parameter
+  * libutouch-geis/geis.c (struct _Geis): added new fields
+    (_class_event_handler): implemented event handling
+    (geis_new_empty): initialized new fields
+    (_set_valist): handled GEIS_INIT_TRACK_GESTURE_CLASSES
+    (geis_get_class_attr_type): new function
+  * libutouch-geis/geis_class.h (GeisGestureClassBag): new data structure
+    (geis_gesture_class_bag_new): new function
+    (geis_gesture_class_bag_delete): new function
+    (geis_gesture_class_bag_count): new function
+    (geis_gesture_class_bag_gesture_class): new function
+    (geis_gesture_class_bag_insert): new function
+    (geis_gesture_class_bag_remove): new function
+  * libutouch-geis/geis_class.c: implemented above new functions
+  * libutouch-geis/geis_filter.c (_facility_is_valid): fixed facility name
+  * libutouch-geis/geis_private.h (geis_get_class_attr_type): new function
+  * testsuite/geis2/check_filter.c: fixed facility name
+  * testsuite/geis2/check_subscription.c: added check for class subscription
+  * testsuite/libutouch-geis/Makefile.am: added new test suite file
+  * testsuite/libutouch-geis/check_geis2_internals.c: called new test suite
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Added Geis v2.0 gesture class implementation (part 1, basic API)
+
+  * libutouch-geis/geis_class.c: new file
+  * libutouch-geis/geis_class.h: new file
+  * libutouch-geis/Makefile.am: added new source files
+  * libutouch-geis/geis.c (struct _Geis): added new class callback fields
+    (_class_event_handler): new function
+    (_input_event_handler): added case for gesture class events
+    (geis_register_class_callback): implemented function
+  * include/geis/geis.h (geis_gesture_class_ref): adjusted return type
+    (geis_gesture_class_unref): same
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Added GEIS v2.0 gesture class API
+
+  * testsuite/geis2/check_class.c: new test suite
+  * include/geis/geis.h (GEIS_INIT_TRACK_GESTURE_CLASSES): new init ath
+    (GEIS_EVENT_CLASS_AVAILABLE): new event type
+    (GEIS_EVENT_CLASS_CHANGED): new event type
+    (GEIS_EVENT_CLASS_UNAVAILABLE): new event type
+    (GeisGestureClass): new opaque type
+    (GEIS_CLASS_ATTRIBUTE_NAME): new attribute name
+    (GEIS_CLASS_ATTRIBUTE_ID): new attribute name
+    (GEIS_EVENT_ATTRIBUTE_CLASS): new attribute name
+    (geis_register_class_callback): new function
+    (geis_gesture_class_ref): new function
+    (geis_gesture_class_unref): new function
+    (geis_gesture_class_name): new function
+    (geis_gesture_class_id): new function
+    (geis_gesture_class_attr_count): new function
+    (geis_gesture_class_attr): new function
+  * libutouch-geis/libutouch-geis.ver: added new exported symbols
+  * testsuite/geis2/Makefile.am: build new test suite
+  * testsuite/geis2/check_event.c: changed event type names
+  * testsuite/geis2/check_geis2_api.c: used new test suite
+  * testsuite/geis2/check_geis_new.c: changed init constant names
+
 2011-01-05  Stephen M. Webb  <[e-mail]>
 
   Minor tweaks.

=== modified file 'include/geis/geis.h'
--- include/geis/geis.h	2011-01-06 00:56:16 +0000
+++ include/geis/geis.h	2011-01-13 16:20:11 +0000
@@ -1,7 +1,8 @@
 /**
- * geis.h
+ * @file geis/geis.h
+ * This is the public interface for the GEIS gesture API.
  *
- * Copyright 2010 Canonical Ltd.
+ * Copyright 2010, 2011 Canonical Ltd.
  *
  * This library is free software; you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License as published by the Free
@@ -223,11 +224,11 @@
 #define GEIS_INIT_TRACK_DEVICES        "org.libgeis.init.track-devices"
 
 /**
- * Tells GEIS to send gesture type events.
+ * Tells GEIS to send gesture class events.
  *
  * This initialization argument takes no parameters.
  */
-#define GEIS_INIT_TRACK_GESTURE_TYPES  "org.libgeis.init.track-gesture-types"
+#define GEIS_INIT_TRACK_GESTURE_CLASSES  "org.libgeis.init.track-gesture-classes"
 
 /* @} */
 
@@ -677,8 +678,9 @@
 { 
   GEIS_EVENT_DEVICE_AVAILABLE         = 1000,
   GEIS_EVENT_DEVICE_UNAVAILABLE       = 1010,
-  GEIS_EVENT_GESTURE_TYPE_AVAILABLE   = 2000,
-  GEIS_EVENT_GESTURE_TYPE_UNAVAILABLE = 2010,
+  GEIS_EVENT_CLASS_AVAILABLE          = 2000,
+  GEIS_EVENT_CLASS_CHANGED            = 2005,
+  GEIS_EVENT_CLASS_UNAVAILABLE        = 2010,
   GEIS_EVENT_GESTURE_BEGIN            = 3000,
   GEIS_EVENT_GESTURE_UPDATE           = 3010,
   GEIS_EVENT_GESTURE_END              = 3020,
@@ -890,6 +892,97 @@
 /* @} */
 
 /**
+ * @defgroup geis2_class Gesture Classes (GEIS v2.0)
+ * @{
+ */
+
+/**
+ * An opaque pointer type representing a gesture-capable input device.
+ *
+ * GeisDevice objects are created by the GEIS API and are reference counted.  An
+ * application needs to increment and decrement the reference count of a gesture
+ * class object to control its persistence.
+ */
+typedef struct _GeisGestureClass *GeisGestureClass;
+
+#define GEIS_CLASS_ATTRIBUTE_NAME   "class name"
+#define GEIS_CLASS_ATTRIBUTE_ID     "class id"
+
+#define GEIS_EVENT_ATTRIBUTE_CLASS  "gesture class"
+
+/**
+ * Registers a callback to receive gesture class change notifications.
+ *
+ * @param[in] geis            The API instance.
+ * @param[in] event_callback  The callback function.
+ * @param[in] context         Contextual data to be passed through to the
+ *                            callback.
+ *
+ * This function is used to register a function to be executed when a change to
+ * the available gesture class definitions has occurred.  If no function is
+ * registered, the default action is to deliver gesture class events through the
+ * main event mechanism.
+ *
+ * Passing a value of GEIS_DEFAULT_EVENT_CALLBACK as the @p event-callback will
+ * reset the callback function to the default action.
+ *
+ * The @p event_callback function will be executed in the same thread context as
+ * geis_dispatch_events().
+ */
+GEIS_API void geis_register_class_callback(Geis               geis,
+                                           GeisEventCallback  event_callback,
+                                           void              *context);
+
+/**
+ * Increments the reference count of a gesture class object.
+ *
+ * @param[in] gesture_class  The gesture class object.
+ */
+GEIS_API void geis_gesture_class_ref(GeisGestureClass gesture_class);
+
+/**
+ * Decrements the reference count of a gesture class object.
+ *
+ * @param[in] gesture_class  The gesture class object.
+ *
+ * The reference count of teh object is decremented and, if it reaches zero, the
+ * object is destroyed.
+ */
+GEIS_API void geis_gesture_class_unref(GeisGestureClass gesture_class);
+
+/**
+ * Gets the name of the gesture class.
+ *
+ * @param[in] gesture_class  The gesture class object.
+ */
+GEIS_API GeisString geis_gesture_class_name(GeisGestureClass gesture_class);
+
+/**
+ * Gets the numeric identifier of the gesture class.
+ *
+ * @param[in] gesture_class  The gesture class object.
+ */
+GEIS_API GeisInteger geis_gesture_class_id(GeisGestureClass gesture_class);
+
+/**
+ * Gets the number of attributes of the gesture class.
+ *
+ * @param[in] gesture_class  The gesture class object.
+ */
+GEIS_API GeisSize geis_gesture_class_attr_count(GeisGestureClass gesture_class);
+
+/**
+ * Gets the indicated attribute of teh gesture class.
+ *
+ * @param[in] gesture_class  The gesture class object.
+ * @param[in] index          The index of the attribute to retrieve.
+ */
+GEIS_API GeisAttr geis_gesture_class_attr(GeisGestureClass gesture_class,
+                                          int              index);
+
+/* @} */
+
+/**
  * @defgroup geis2_region Gesture Regions (GEIS v2.0)
  * @{
  */
@@ -956,9 +1049,9 @@
 
 typedef enum _GeisFilterFacility
 {
-  GEIS_FILTER_DEVICE       = 1000,
-  GEIS_FILTER_GESTURE_TYPE = 2000,
-  GEIS_FILTER_REGION       = 3000
+  GEIS_FILTER_DEVICE   = 1000,
+  GEIS_FILTER_CLASS    = 2000,
+  GEIS_FILTER_REGION   = 3000
 } GeisFilterFacility;
 
 typedef enum _GeisFilterOperation

=== modified file 'libutouch-geis/Makefile.am'
--- libutouch-geis/Makefile.am	2011-01-05 18:23:20 +0000
+++ libutouch-geis/Makefile.am	2011-01-13 16:20:11 +0000
@@ -31,6 +31,7 @@
 	geis_backend.h              geis_backend.c \
 	geis_backend_protected.h \
 	geis_backend_multiplexor.h  geis_backend_multiplexor.c \
+	geis_class.h                geis_class.c \
 	geis_device.h               geis_device.c \
 	geis_error.h                geis_error.c \
 	geis_event.h                geis_event.c \

=== modified file 'libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c'
--- libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c	2011-01-06 00:47:03 +0000
+++ libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c	2011-01-13 16:20:11 +0000
@@ -22,6 +22,7 @@
 #include "geis_backend_protected.h"
 
 #include "geis_attr.h"
+#include "geis_class.h"
 #include "geis_device.h"
 #include "geis_event.h"
 #include "geis_filter.h"
@@ -69,6 +70,18 @@
                  geis_filter_term_operation(term),
                  geis_attr_value_to_string(geis_filter_term_attr(term)));
     }
+    for (j = 0;
+         j < geis_filter_term_by_facility_count(filter, GEIS_FILTER_CLASS);
+         ++j)
+    {
+      GeisFilterTerm term = geis_filter_term_by_facility(filter,
+                                                         GEIS_FILTER_CLASS,
+                                                         j);
+      geis_debug("  CLASS \"%s\" (%d) \"%s\"",
+                 geis_attr_name(geis_filter_term_attr(term)),
+                 geis_filter_term_operation(term),
+                 geis_attr_value_to_string(geis_filter_term_attr(term)));
+    }
   }
   geis_debug("ends");
   return status;
@@ -102,8 +115,22 @@
 }
 
 
+static void _create_test_classes(GeisBackendTestFixture tf)
+{
+  GeisGestureClass gesture_class = geis_gesture_class_new("poke", 0);
+  GeisEvent  event = geis_event_new(GEIS_EVENT_CLASS_AVAILABLE);
+  GeisAttr   attr = geis_attr_new(GEIS_EVENT_ATTRIBUTE_CLASS,
+                                  GEIS_ATTR_TYPE_POINTER,
+                                  gesture_class);
+  geis_event_add_attr(event, attr);
+  geis_post_event(tf->tf_geis, event);
+}
+
+
 GeisBackend
-geis_backend_new_test_fixture(Geis geis, GeisBoolean track_devices)
+geis_backend_new_test_fixture(Geis geis,
+                              GeisBoolean track_devices,
+                              GeisBoolean track_classes)
 {
   GeisBackendTestFixture tf = calloc(1, sizeof(struct _GeisBackendTestFixture));
   if (!tf)
@@ -120,6 +147,11 @@
     _create_test_devices(tf);
   }
 
+  if (track_classes)
+  {
+    _create_test_classes(tf);
+  }
+
   geis_debug("%s back end created", geis_backend_name(&tf->tf_base));
 
 nomem:

=== modified file 'libutouch-geis/backend/test_fixture/geis_backend_test_fixture.h'
--- libutouch-geis/backend/test_fixture/geis_backend_test_fixture.h	2011-01-05 22:00:54 +0000
+++ libutouch-geis/backend/test_fixture/geis_backend_test_fixture.h	2011-01-13 16:20:11 +0000
@@ -28,10 +28,12 @@
  *
  * @param[in] geis          The API instance the back end will run in.
  * @param[in] track_devices Indicates devices should be tracked.
+ * @param[in] track_classes Indicates classes should be tracked.
  *
  * The Test Fixture back end is used in unit tests.
  */
 GeisBackend geis_backend_new_test_fixture(Geis geis,
-                                          GeisBoolean track_devices);
+                                          GeisBoolean track_devices,
+                                          GeisBoolean track_classes);
 
 #endif /* GEIS_BACKEND_TEST_FIXTURE_H_ */

=== modified file 'libutouch-geis/geis.c'
--- libutouch-geis/geis.c	2011-01-05 22:00:54 +0000
+++ libutouch-geis/geis.c	2011-01-13 16:20:11 +0000
@@ -24,15 +24,16 @@
 #include <errno.h>
 #include "geis_attr.h"
 #include "geis_backend.h"
-#include "test_fixture/geis_backend_test_fixture.h"
+#include "geis_class.h"
+#include "geis_device.h"
 #include "geis_backend_multiplexor.h"
 #include "geis_error.h"
 #include "geis_event.h"
 #include "geis_event_queue.h"
-#include "geis_device.h"
 #include "geis_logging.h"
 #include <stdarg.h>
 #include <string.h>
+#include "test_fixture/geis_backend_test_fixture.h"
 #include <unistd.h>
 
 
@@ -48,6 +49,11 @@
   GeisEventCallback       output_event_callback;
   void                   *output_event_callback_context;
   GeisDeviceBag           devices;
+  GeisEventCallback       device_event_callback;
+  void                   *device_event_callback_context;
+  GeisGestureClassBag     gesture_classes;
+  GeisEventCallback       class_event_callback;
+  void                   *class_event_callback_context;
 };
 
 
@@ -91,6 +97,55 @@
     geis_device_bag_remove(geis->devices, device);
   }
 
+  if (geis->device_event_callback != GEIS_DEFAULT_EVENT_CALLBACK)
+  {
+    geis->device_event_callback(geis, event, geis->device_event_callback_context);
+    handled = GEIS_TRUE;
+  }
+
+final_exit:
+  return handled;
+}
+
+
+/*
+ * Handles class events coming in from the back end.
+ */
+static GeisBoolean
+_class_event_handler(Geis geis, GeisEvent event)
+{
+  GeisBoolean handled = GEIS_FALSE;
+
+  GeisAttr attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_CLASS);
+  if (!attr)
+  {
+    geis_warning("invalid class event received from back end.");
+    handled = GEIS_TRUE;
+    goto final_exit;
+  }
+  
+  GeisGestureClass gesture_class = geis_attr_value_to_pointer(attr);
+
+  GeisEventType event_type = geis_event_type(event);
+  if (event_type == GEIS_EVENT_CLASS_AVAILABLE)
+  {
+    geis_gesture_class_bag_insert(geis->gesture_classes, gesture_class);
+  }
+  else if (event_type == GEIS_EVENT_CLASS_CHANGED)
+  {
+    /** @todo implement GEIS_EVENT_CLASS_CHANGED */
+  }
+  else if (event_type == GEIS_EVENT_CLASS_UNAVAILABLE)
+  {
+    geis_gesture_class_bag_remove(geis->gesture_classes, gesture_class);
+  }
+
+  if (geis->class_event_callback != GEIS_DEFAULT_EVENT_CALLBACK)
+  {
+    geis->class_event_callback(geis, event, geis->class_event_callback_context);
+    handled = GEIS_TRUE;
+  }
+
 final_exit:
   return handled;
 }
@@ -129,6 +184,12 @@
 	  handled = _device_event_handler(geis, event);
 	  break;
 
+	case GEIS_EVENT_CLASS_AVAILABLE:
+	case GEIS_EVENT_CLASS_CHANGED:
+	case GEIS_EVENT_CLASS_UNAVAILABLE:
+	  handled = _class_event_handler(geis, event);
+	  break;
+
 	default:
 	  break;
       }
@@ -205,15 +266,27 @@
   geis->output_event_callback = _default_output_event_callback;
 
   geis->devices = geis_device_bag_new();
-  if (!geis->output_event_queue)
+  if (!geis->devices)
   {
     geis_error_push(NULL, GEIS_STATUS_UNKNOWN_ERROR);
     geis_error("creation of geis device bag failed");
     goto unwind_output_queue;
   }
+  geis->device_event_callback = _default_output_event_callback;
+
+  geis->gesture_classes = geis_gesture_class_bag_new();
+  if (!geis->gesture_classes)
+  {
+    geis_error_push(NULL, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("creation of geis gesture class bag failed");
+    goto unwind_device_bag;
+  }
+  geis->class_event_callback = _default_output_event_callback;
 
   goto final_exit;
 
+unwind_device_bag:
+  geis_device_bag_delete(geis->devices);
 unwind_output_queue:
   geis_event_queue_delete(geis->output_event_queue);
 unwind_input_signal_pipe:
@@ -249,6 +322,7 @@
   GeisBoolean status = GEIS_TRUE;
   BackendType back_end_type = BACK_END_TYPE_NONE;
   GeisBoolean track_devices = GEIS_FALSE;
+  GeisBoolean track_classes = GEIS_FALSE;
 
   while (init_arg_name)
   {
@@ -260,6 +334,10 @@
     {
       track_devices = GEIS_TRUE;
     }
+    else if (0 == strcmp(init_arg_name, GEIS_INIT_TRACK_GESTURE_CLASSES))
+    {
+      track_classes = GEIS_TRUE;
+    }
     else if (0 == strcmp(init_arg_name, GEIS_INIT_UTOUCH_MOCK_ENGINE))
     {
       if (back_end_type != BACK_END_TYPE_NONE)
@@ -274,7 +352,9 @@
 
   if (back_end_type ==BACK_END_TYPE_MOCK_ENGINE)
   {
-    geis->backend = geis_backend_new_test_fixture(geis, track_devices);
+    geis->backend = geis_backend_new_test_fixture(geis,
+                                                  track_devices,
+                                                  track_classes);
   }
   else
   {
@@ -387,6 +467,19 @@
 
 
 /*
+ * Registers a callback to receive gesture class change notifications.
+ */
+void
+geis_register_class_callback(Geis               geis,
+                             GeisEventCallback  event_callback,
+                             void              *context)
+{
+  geis->class_event_callback = event_callback;
+  geis->class_event_callback_context = context;
+}
+
+
+/*
  * Registers an application-supplied event callback.
  */
 void 
@@ -531,3 +624,25 @@
   return GEIS_ATTR_TYPE_UNKNOWN;
 }
 
+
+GeisAttrType
+geis_get_class_attr_type(Geis geis, GeisString attr_name)
+{
+  GeisSize i = 0;
+  for (; i < geis_gesture_class_bag_count(geis->gesture_classes); ++i)
+  {
+    GeisGestureClass gesture_class = geis_gesture_class_bag_gesture_class(geis->gesture_classes, i);
+    GeisSize j = 0;
+    for (; j < geis_gesture_class_attr_count(gesture_class); ++j)
+    {
+      GeisAttr attr = geis_gesture_class_attr(gesture_class, j);
+      if (0 == strcmp(geis_attr_name(attr), attr_name))
+      {
+	return geis_attr_type(attr);
+      }
+    }
+  }
+  return GEIS_ATTR_TYPE_UNKNOWN;
+}
+
+

=== added file 'libutouch-geis/geis_class.c'
--- libutouch-geis/geis_class.c	1970-01-01 00:00:00 +0000
+++ libutouch-geis/geis_class.c	2011-01-13 16:20:11 +0000
@@ -0,0 +1,327 @@
+/**
+ * @file libutouch-geis/geis_class.c
+ * @brief implementation of the uTouch GEIS v2.0 API Gesture Class module
+ *
+ * Copyright 2011 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * This library 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 Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+#include "geis_config.h"
+#include "geis_class.h"
+
+#include "geis_attr.h"
+#include "geis_logging.h"
+#include <stdlib.h>
+
+
+struct _GeisGestureClass
+{
+  GeisSize    ref_count;
+  GeisAttrBag attrs;
+};
+
+struct _GeisGestureClassBag
+{
+  GeisGestureClass *store;
+  GeisSize          store_size;
+  GeisSize          count;
+};
+
+static const int gesture_class_bag_growth_constant = 2;
+
+
+/*
+ * Creates a new class bag,
+ */
+GeisGestureClassBag
+geis_gesture_class_bag_new()
+{
+  GeisGestureClassBag bag = calloc(1, sizeof(struct _GeisGestureClassBag));
+  if (!bag)
+  {
+    geis_error("error allocating gesture class bag");
+    goto final_exit;
+  }
+
+  bag->store = calloc(1, sizeof(struct _GeisGestureClass));
+  if (!bag->store)
+  {
+    geis_error("error allocating gesture class bag store");
+    goto unwind_bag;
+  }
+
+  bag->store_size = 1;
+  bag->count = 0;
+  goto final_exit;
+
+unwind_bag:
+  free(bag);
+  bag = NULL;
+final_exit:
+  return bag;
+}
+
+
+/*
+ * Destroys a gesture class bag.
+ */
+void
+geis_gesture_class_bag_delete(GeisGestureClassBag bag)
+{
+  GeisSize i;
+  for (i = bag->count; i > 0; --i)
+  {
+    geis_gesture_class_unref(bag->store[i-1]);
+  }
+  free(bag->store);
+  free(bag);
+}
+
+
+/*
+ * Gets the number of gesture classs in the bag.
+ */
+GeisSize
+geis_gesture_class_bag_count(GeisGestureClassBag bag)
+{
+  return bag->count;
+}
+
+
+/*
+ * Gets an indicated gesture class from a bag.
+ */
+GeisGestureClass
+geis_gesture_class_bag_gesture_class(GeisGestureClassBag bag,
+                                     GeisSize            index)
+{
+  GeisGestureClass gesture_class = NULL;
+  if (index >= bag->count)
+  {
+    geis_warning("class bag index out of range");
+  }
+  else
+  {
+    gesture_class = bag->store[index];
+  }
+  return gesture_class;
+}
+
+
+/*
+ * Inserts a gesture class in teh bag.
+ */
+GeisStatus
+geis_gesture_class_bag_insert(GeisGestureClassBag bag,
+                              GeisGestureClass    gesture_class)
+{
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  if (bag->count >= bag->store_size)
+  {
+    GeisSize new_store_size = bag->store_size * gesture_class_bag_growth_constant;
+    GeisGestureClass *new_store = realloc(bag->store,
+             new_store_size * sizeof(struct _GeisGestureClass));
+    if (!new_store)
+    {
+      geis_error("failed to reallocate class bag");
+      goto error_exit;
+    }
+    bag->store = new_store;
+    bag->store_size = new_store_size;
+  }
+  bag->store[bag->count++] = gesture_class;
+  status = GEIS_STATUS_SUCCESS;
+
+error_exit:
+  return status;
+}
+
+
+/*
+ * Remoes a gesture class from the bag.
+ */
+GeisStatus
+geis_gesture_class_bag_remove(GeisGestureClassBag bag,
+                              GeisGestureClass    gesture_class)
+{
+  GeisSize i;
+  GeisStatus status = GEIS_STATUS_SUCCESS;
+  for (i = 0; i < bag->count; ++i)
+  {
+    if (bag->store[i] == gesture_class)
+    {
+      GeisSize j;
+      geis_gesture_class_unref(bag->store[i]);
+      --bag->count;
+      for (j = i; j < bag->count; ++j)
+      {
+	bag->store[j] = bag->store[j+1];
+      }
+      break;
+    }
+  }
+  return status;
+}
+
+
+/*
+ * Creates a new, empty gesture_class.
+ */
+GeisGestureClass
+geis_gesture_class_new(GeisString name, GeisInteger id)
+{
+  GeisAttr attr;
+
+  GeisGestureClass gesture_class = calloc(1, sizeof(struct _GeisGestureClass));
+  if (!gesture_class)
+  {
+    geis_error("error allocating gesture class");
+    goto final_exit;
+  }
+
+  gesture_class->attrs = geis_attr_bag_new(3);
+  if (!gesture_class->attrs)
+  {
+    geis_debug("error allocating attr bag");
+    goto unwind_gesture_class;
+  }
+
+  attr = geis_attr_new(GEIS_CLASS_ATTRIBUTE_NAME, GEIS_ATTR_TYPE_STRING, (void *)name);
+  if (!attr)
+  {
+    geis_debug("error creating gesture class name attr");
+    goto unwind_attrs;
+  }
+  geis_attr_bag_insert(gesture_class->attrs, attr);
+
+  attr = geis_attr_new(GEIS_CLASS_ATTRIBUTE_ID, GEIS_ATTR_TYPE_INTEGER, &id);
+  if (!attr)
+  {
+    geis_debug("error creating gesture class id attr");
+    goto unwind_attrs;
+  }
+  geis_attr_bag_insert(gesture_class->attrs, attr);
+
+  geis_gesture_class_ref(gesture_class);
+  goto final_exit;
+
+unwind_attrs:
+  geis_attr_bag_delete(gesture_class->attrs);
+unwind_gesture_class:
+  free(gesture_class);
+  gesture_class = NULL;
+final_exit:
+  return gesture_class;
+}
+
+
+/*
+ * Destroys a gesture class.
+ */
+static void
+_gesture_class_delete(GeisGestureClass gesture_class)
+{
+  geis_attr_bag_delete(gesture_class->attrs);
+  free(gesture_class);
+}
+
+
+/*
+ * Increments the reference count of a gesture class object.
+ */
+void
+geis_gesture_class_ref(GeisGestureClass gesture_class)
+{
+  __sync_add_and_fetch(&gesture_class->ref_count, 1);
+}
+
+
+/*
+ * Decrements the reference count of a gesture class object.
+ */
+void
+geis_gesture_class_unref(GeisGestureClass gesture_class)
+{
+  if (0 == __sync_sub_and_fetch(&gesture_class->ref_count, 1))
+  {
+    _gesture_class_delete(gesture_class);
+  }
+}
+
+
+/*
+ * Gets the name of the gesture class.
+ */
+GeisString
+geis_gesture_class_name(GeisGestureClass gesture_class)
+{
+  GeisString name = NULL;
+  GeisAttr attr = geis_attr_bag_find(gesture_class->attrs,
+                                     GEIS_CLASS_ATTRIBUTE_NAME);
+  if (attr)
+  {
+    name = geis_attr_value_to_string(attr);
+  }
+  return name;
+}
+
+
+/**
+ * Gets the numeric identifier of the gesture class.
+ */
+GeisInteger
+geis_gesture_class_id(GeisGestureClass gesture_class)
+{
+  GeisInteger id = -1;
+  GeisAttr attr = geis_attr_bag_find(gesture_class->attrs,
+                                     GEIS_CLASS_ATTRIBUTE_ID);
+  if (attr)
+  {
+    id = geis_attr_value_to_integer(attr);
+  }
+  return id;
+}
+
+
+/*
+ * Gets the number of attributes of the gesture class.
+ */
+GeisSize
+geis_gesture_class_attr_count(GeisGestureClass gesture_class)
+{
+  return geis_attr_bag_count(gesture_class->attrs);
+}
+
+
+/*
+ * Gets the indicated attribute of teh gesture class.
+ */
+GeisAttr
+geis_gesture_class_attr(GeisGestureClass gesture_class,
+                        int              index)
+{
+  return geis_attr_bag_attr(gesture_class->attrs, index);
+}
+
+
+/*
+ * Inserts an attr into a gesture class.
+ */
+GeisStatus
+geis_gesture_class_add_attr(GeisGestureClass gesture_class, GeisAttr attr)
+{
+  return geis_attr_bag_insert(gesture_class->attrs, attr);
+}
+

=== added file 'libutouch-geis/geis_class.h'
--- libutouch-geis/geis_class.h	1970-01-01 00:00:00 +0000
+++ libutouch-geis/geis_class.h	2011-01-13 16:20:11 +0000
@@ -0,0 +1,108 @@
+/**
+ * @file geis_class.h
+ * @brief internal uTouch Geis Gesture Class module private interface
+ *
+ * Copyright 2010 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * This library 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 Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+#ifndef GEIS_CLASS_H_
+#define GEIS_CLASS_H_
+
+#include "geis/geis.h"
+
+/**
+ * @defgroup utouch_geis_gesture_class_container A Gesture Class Container
+ * @{
+ */
+
+/**
+ * An unsorted container for holding classs.
+ */
+typedef struct _GeisGestureClassBag *GeisGestureClassBag;
+
+/**
+ * Creates a new class bag,
+ */
+GeisGestureClassBag geis_gesture_class_bag_new();
+
+/**
+ * Destroys a gesture class bag.
+ *
+ * @param[in] bag The gesture class bag,
+ */
+void geis_gesture_class_bag_delete(GeisGestureClassBag bag);
+
+/**
+ * Gets the number of gesture classs in the bag.
+ *
+ * @param[in] bag The gesture class bag,
+ */
+GeisSize geis_gesture_class_bag_count(GeisGestureClassBag bag);
+
+/**
+ * Gets an indicated gesture class from a bag.
+ *
+ * @param[in] bag   The gesture class bag.
+ * @param[in] index The index.
+ */
+GeisGestureClass geis_gesture_class_bag_gesture_class(GeisGestureClassBag bag,
+                                                      GeisSize            index);
+
+/**
+ * Inserts a gesture class in teh bag.
+ *
+ * @param[in] bag           The gesture class bag.
+ * @param[in] gesture_class The gesture class to insert.
+ */
+GeisStatus geis_gesture_class_bag_insert(GeisGestureClassBag bag,
+                                         GeisGestureClass    gesture_class);
+
+/**
+ * Remoes a gesture class from the bag.
+ *
+ * @param[in] bag           The gesture class bag.
+ * @param[in] gesture_class The gesture class to remove.
+ */
+GeisStatus geis_gesture_class_bag_remove(GeisGestureClassBag bag,
+                                         GeisGestureClass    gesture_class);
+
+/** @} */
+
+/**
+ * @defgroup utouch_geis_gesture_class Internal Gesture Class Functions
+ * @{
+ */
+
+/**
+ * Creates a new gesture class.
+ *
+ * @param[in] name A system-specific gesture class name.
+ * @param[in] id   A system-specific gesture class identifier.
+ */
+GeisGestureClass geis_gesture_class_new(GeisString name, GeisInteger id);
+
+/**
+ * Inserts an attr into a gesture class.
+ *
+ * @param[in] gesture_class  A gesture class.
+ * @param[in] attr           An attr.
+ */
+GeisStatus geis_gesture_class_add_attr(GeisGestureClass gesture_class,
+                                       GeisAttr         attr);
+
+/** @} */
+
+#endif /* GEIS_CLASS_H_ */

=== modified file 'libutouch-geis/geis_filter.c'
--- libutouch-geis/geis_filter.c	2011-01-06 00:47:03 +0000
+++ libutouch-geis/geis_filter.c	2011-01-13 16:20:11 +0000
@@ -262,7 +262,7 @@
 _facility_is_valid(GeisFilterFacility facility)
 {
   return facility == GEIS_FILTER_DEVICE
-    ||   facility == GEIS_FILTER_GESTURE_TYPE
+    ||   facility == GEIS_FILTER_CLASS
     ||   facility == GEIS_FILTER_REGION;
 }
 
@@ -297,6 +297,9 @@
     case GEIS_FILTER_DEVICE:
       type = geis_get_device_attr_type(geis, attr_name);
       break;
+    case GEIS_FILTER_CLASS:
+      type = geis_get_class_attr_type(geis, attr_name);
+      break;
     default:
       break;
   }

=== modified file 'libutouch-geis/geis_private.h'
--- libutouch-geis/geis_private.h	2011-01-05 16:59:42 +0000
+++ libutouch-geis/geis_private.h	2011-01-13 16:20:11 +0000
@@ -105,4 +105,19 @@
  */
 GeisAttrType geis_get_device_attr_type(Geis geis, GeisString attr_name);
 
+/**
+ * Gets the type of a named class attr.
+ *
+ * @param[in]  geis      The API instance.
+ * @param[in]  attr_name The name of the class attr.
+ *
+ * Gets the type of a class attr by name, assuming the attr is known.
+ *
+ * There is a basic assumption that all class attrs of the same name are of the
+ * same type.
+ *
+ * @returns the type of the attr, GEIS_ATTR_TYPE_UNKNOWN if the attr is unknown.
+ */
+GeisAttrType geis_get_class_attr_type(Geis geis, GeisString attr_name);
+
 #endif /* GEIS_PRIVATE_H_ */

=== modified file 'libutouch-geis/libutouch-geis.ver'
--- libutouch-geis/libutouch-geis.ver	2011-01-05 21:54:10 +0000
+++ libutouch-geis/libutouch-geis.ver	2011-01-13 16:20:11 +0000
@@ -40,12 +40,19 @@
     geis_filter_delete;
     geis_filter_name;
     geis_filter_new;
+    geis_gesture_class_attr;
+    geis_gesture_class_attr_count;
+    geis_gesture_class_id;
+    geis_gesture_class_name;
+    geis_gesture_class_ref;
+    geis_gesture_class_unref;
     geis_get_configuration;
     geis_new;
     geis_next_event;
     geis_region_delete;
     geis_region_name;
     geis_region_new;
+    geis_register_class_callback;
     geis_register_device_callback;
     geis_register_event_callback;
     geis_set_configuration;

=== modified file 'testsuite/geis2/Makefile.am'
--- testsuite/geis2/Makefile.am	2010-12-31 00:30:21 +0000
+++ testsuite/geis2/Makefile.am	2011-01-13 16:20:11 +0000
@@ -15,6 +15,7 @@
 
 check_geis2_api_SOURCES = \
 	check_attr.c \
+	check_class.c \
 	check_config.c \
 	check_device.c \
 	check_error_codes.c \

=== added file 'testsuite/geis2/check_class.c'
--- testsuite/geis2/check_class.c	1970-01-01 00:00:00 +0000
+++ testsuite/geis2/check_class.c	2011-01-13 16:20:11 +0000
@@ -0,0 +1,98 @@
+/**
+ * Unit tests for GEIS v2.0 Input Gesture Class Module.
+ */
+#include <check.h>
+
+#include <geis/geis.h>
+
+/* fixtures */
+static Geis g_geis;
+
+/* fixture setup */
+static void
+construct_geis()
+{
+  g_geis = geis_new(GEIS_INIT_UTOUCH_MOCK_ENGINE,
+                    GEIS_INIT_TRACK_GESTURE_CLASSES,
+                    NULL);
+}
+
+/* fixture teardown */
+static void
+destroy_geis()
+{
+  geis_delete(g_geis);
+}
+
+
+/* Compile-time test to ensure types are defined */
+START_TEST(geis_gesture_class_types)
+{
+  GeisGestureClass gesture_class;
+}
+END_TEST
+
+/* Compile-time test to ensure constants are defined */
+START_TEST(geis_gesture_class_constants)
+{
+  GeisString attr_name;
+  attr_name = GEIS_CLASS_ATTRIBUTE_NAME;
+  attr_name = GEIS_CLASS_ATTRIBUTE_ID;
+  attr_name = GEIS_EVENT_ATTRIBUTE_CLASS;
+}
+END_TEST
+
+/* Compile-and-link-time test to verify required functions exist */
+START_TEST(geis_gesture_class_functions)
+{
+  Geis geis;
+  GeisEventCallback callback;
+  GeisGestureClass gesture_class;
+  geis_register_class_callback(geis, callback, NULL);
+
+  geis_gesture_class_ref(gesture_class);
+  geis_gesture_class_unref(gesture_class);
+  GeisString n = geis_gesture_class_name(gesture_class);
+  GeisInteger i = geis_gesture_class_id(gesture_class);
+  GeisSize s = geis_gesture_class_attr_count(gesture_class);
+  GeisAttr a = geis_gesture_class_attr(gesture_class, 0);
+}
+END_TEST
+
+START_TEST(receive_events)
+{
+  GeisStatus status;
+  GeisEvent event_out;
+
+  status = geis_dispatch_events(g_geis);
+  fail_unless(status == GEIS_STATUS_SUCCESS,
+              "unexpected status from geis_dispatch_events");
+  status = geis_next_event(g_geis, &event_out);
+  fail_unless(status == GEIS_STATUS_SUCCESS,
+              "unexpected status from geis_dispatch_events");
+  fail_unless(geis_event_type(event_out) == GEIS_EVENT_CLASS_AVAILABLE,
+              "unexpected event type received");
+
+}
+END_TEST
+
+
+/* boilerplate */
+Suite *
+geis2_gesture_class_suite_new()
+{
+  Suite *s = suite_create("geis2_gesture_class");
+
+  TCase *gesture_class = tcase_create("gesture-class-api");
+  tcase_add_test(gesture_class, geis_gesture_class_types);
+  tcase_add_test(gesture_class, geis_gesture_class_constants);
+  suite_add_tcase(s, gesture_class);
+
+  TCase *usage = tcase_create("gesture-class-usage");
+  tcase_add_checked_fixture(usage, construct_geis, destroy_geis);
+  tcase_add_test(usage, receive_events);
+  suite_add_tcase(s, usage);
+
+  return s;
+}
+

=== modified file 'testsuite/geis2/check_event.c'
--- testsuite/geis2/check_event.c	2010-12-20 18:06:36 +0000
+++ testsuite/geis2/check_event.c	2011-01-13 16:20:11 +0000
@@ -11,8 +11,9 @@
   GeisEventType type;
   type = GEIS_EVENT_DEVICE_AVAILABLE;
   type = GEIS_EVENT_DEVICE_UNAVAILABLE;
-  type = GEIS_EVENT_GESTURE_TYPE_AVAILABLE;
-  type = GEIS_EVENT_GESTURE_TYPE_UNAVAILABLE;
+  type = GEIS_EVENT_CLASS_AVAILABLE;
+  type = GEIS_EVENT_CLASS_CHANGED;
+  type = GEIS_EVENT_CLASS_UNAVAILABLE;
   type = GEIS_EVENT_GESTURE_BEGIN;
   type = GEIS_EVENT_GESTURE_UPDATE;
   type = GEIS_EVENT_GESTURE_END;

=== modified file 'testsuite/geis2/check_filter.c'
--- testsuite/geis2/check_filter.c	2010-12-31 00:30:21 +0000
+++ testsuite/geis2/check_filter.c	2011-01-13 16:20:11 +0000
@@ -18,7 +18,7 @@
   Geis geis;
   GeisFilter filter = geis_filter_new(geis, "filter");
   GeisString name   = geis_filter_name(filter);
-  GeisStatus status = geis_filter_add_term(filter, GEIS_FILTER_GESTURE_TYPE,
+  GeisStatus status = geis_filter_add_term(filter, GEIS_FILTER_CLASS,
 			 GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_GT, 1,
 			 NULL);
   geis_filter_delete(filter);

=== modified file 'testsuite/geis2/check_geis2_api.c'
--- testsuite/geis2/check_geis2_api.c	2010-12-31 00:30:21 +0000
+++ testsuite/geis2/check_geis2_api.c	2011-01-13 16:20:11 +0000
@@ -8,6 +8,7 @@
 extern Suite *geis2_general_types_suite_new();
 extern Suite *geis2_error_codes_suite_new();
 extern Suite *geis2_device_suite_new();
+extern Suite *geis2_gesture_class_suite_new();
 extern Suite *geis2_geis_new_suite_new();
 extern Suite *geis2_config_suite_new();
 extern Suite *geis2_attr_suite_new();
@@ -30,8 +31,9 @@
   srunner_add_suite(sr, geis2_geis_new_suite_new());
   srunner_add_suite(sr, geis2_config_suite_new());
   srunner_add_suite(sr, geis2_attr_suite_new()); 
+  srunner_add_suite(sr, geis2_device_suite_new()); 
+  srunner_add_suite(sr, geis2_gesture_class_suite_new()); 
   srunner_add_suite(sr, geis2_region_suite_new()); 
-  srunner_add_suite(sr, geis2_device_suite_new()); 
   srunner_add_suite(sr, geis2_filter_suite_new()); 
   srunner_add_suite(sr, geis2_subscription_suite_new()); 
   srunner_add_suite(sr, geis2_event_suite_new()); 

=== modified file 'testsuite/geis2/check_geis_new.c'
--- testsuite/geis2/check_geis_new.c	2010-12-20 18:06:36 +0000
+++ testsuite/geis2/check_geis_new.c	2011-01-13 16:20:11 +0000
@@ -11,7 +11,7 @@
   GeisString init_arg;
   init_arg = GEIS_INIT_SERVICE_PROVIDER;
   init_arg = GEIS_INIT_TRACK_DEVICES;
-  init_arg = GEIS_INIT_TRACK_GESTURE_TYPES;
+  init_arg = GEIS_INIT_TRACK_GESTURE_CLASSES;
 }
 END_TEST
 

=== modified file 'testsuite/geis2/check_subscription.c'
--- testsuite/geis2/check_subscription.c	2011-01-06 00:56:16 +0000
+++ testsuite/geis2/check_subscription.c	2011-01-13 16:20:11 +0000
@@ -14,7 +14,10 @@
 static void
 construct_geis()
 {
-  g_geis = geis_new(GEIS_INIT_UTOUCH_MOCK_ENGINE, GEIS_INIT_TRACK_DEVICES, NULL);
+  g_geis = geis_new(GEIS_INIT_UTOUCH_MOCK_ENGINE,
+                    GEIS_INIT_TRACK_DEVICES,
+                    GEIS_INIT_TRACK_GESTURE_CLASSES,
+                    NULL);
 }
 
 /* fixture teardown */
@@ -96,15 +99,34 @@
 
       fs = geis_subscription_add_filter(sub, filter);
       fail_if(fs != GEIS_STATUS_SUCCESS, "can not subscribe filter");
-
-      if (status == GEIS_STATUS_CONTINUE)
-      {
-	status = geis_next_event(g_geis, &event);
-      }
-      else
-      {
-	break;
-      }
+    }
+    else if (geis_event_type(event) == GEIS_EVENT_CLASS_AVAILABLE)
+    {
+      GeisAttr attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_CLASS);
+      fail_if (!attr, "attr not found in class event");
+
+      GeisGestureClass device = geis_attr_value_to_pointer(attr);
+      fail_if (!device, "geis class not found in class event");
+
+      GeisFilter filter = geis_filter_new(g_geis, "class filter");
+      fail_if(!filter, "can not create filter");
+
+      GeisStatus fs = geis_filter_add_term(filter, GEIS_FILTER_CLASS,
+          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_NE, geis_gesture_class_name(device),
+          NULL);
+      fail_if(fs != GEIS_STATUS_SUCCESS, "can not add class to filter");
+
+      fs = geis_subscription_add_filter(sub, filter);
+      fail_if(fs != GEIS_STATUS_SUCCESS, "can not subscribe filter");
+    }
+
+    if (status == GEIS_STATUS_CONTINUE)
+    {
+      status = geis_next_event(g_geis, &event);
+    }
+    else
+    {
+      break;
     }
   }
 

=== modified file 'testsuite/libutouch-geis/Makefile.am'
--- testsuite/libutouch-geis/Makefile.am	2010-12-31 21:36:34 +0000
+++ testsuite/libutouch-geis/Makefile.am	2011-01-13 16:20:11 +0000
@@ -33,6 +33,7 @@
 check_geis2_internals_SOURCES = \
 	check_attr.c \
 	check_backend_multiplexor.c \
+	check_class.c \
 	check_device.c \
 	check_error_reporting.c \
 	check_event_queue.c \

=== added file 'testsuite/libutouch-geis/check_class.c'
--- testsuite/libutouch-geis/check_class.c	1970-01-01 00:00:00 +0000
+++ testsuite/libutouch-geis/check_class.c	2011-01-13 16:20:11 +0000
@@ -0,0 +1,99 @@
+/**
+ * unit tests for the geis gesture class module
+ */
+#include <check.h>
+
+#include "libutouch-geis/geis_class.h"
+
+
+/* fixtures */
+static GeisGestureClassBag g_gesture_class_bag;
+static GeisString          g_gesture_class_name = "gesture_class";
+static GeisInteger         g_gesture_class_id   = 12;
+
+/* fixture setup */
+static void
+construct_bag()
+{
+  g_gesture_class_bag = geis_gesture_class_bag_new();
+}
+
+/* fixture teardown */
+static void
+destroy_bag()
+{
+  geis_gesture_class_bag_delete(g_gesture_class_bag);
+}
+
+/* verify bag construction/destruction */
+START_TEST(construct)
+{
+  GeisGestureClassBag bag = geis_gesture_class_bag_new();
+  fail_unless(bag != NULL, "failed to create gesture class bag");
+  geis_gesture_class_bag_delete(bag);
+}
+END_TEST
+
+/* verify bag insertion */
+START_TEST(insert)
+{
+  GeisGestureClass gesture_class = geis_gesture_class_new(g_gesture_class_name, g_gesture_class_id);
+  geis_gesture_class_bag_insert(g_gesture_class_bag, gesture_class);
+  fail_unless(geis_gesture_class_bag_count(g_gesture_class_bag) == 1,
+              "unexpected bag size after insertion");
+}
+END_TEST
+
+/* verify bag removal */
+START_TEST(remove)
+{
+  GeisGestureClass gesture_class = geis_gesture_class_new(g_gesture_class_name, g_gesture_class_id);
+  geis_gesture_class_bag_insert(g_gesture_class_bag, gesture_class);
+  fail_unless(geis_gesture_class_bag_count(g_gesture_class_bag) == 1,
+              "unexpected bag size after insertion");
+  geis_gesture_class_bag_remove(g_gesture_class_bag, gesture_class);
+  fail_unless(geis_gesture_class_bag_count(g_gesture_class_bag) == 0,
+              "unexpected bag size after removal");
+}
+END_TEST
+
+START_TEST(expand)
+{
+  int i;
+  for (i = 0; i < 24; ++i)
+  {
+    GeisSize count;
+    char name[32];
+    sprintf(name, "%04d", i);
+    GeisGestureClass gesture_class = geis_gesture_class_new(name, i);
+    geis_gesture_class_bag_insert(g_gesture_class_bag, gesture_class);
+    count = geis_gesture_class_bag_count(g_gesture_class_bag);
+    fail_unless(count == (i+1),
+                "unexpected bag size %ld after insertion, expected %d",
+                count, i+1);
+  }
+}
+END_TEST
+
+
+
+/* boilerplate */
+Suite *
+make_gesture_class_suite()
+{
+  Suite *s = suite_create("utouch-geis2-gesture_class");
+
+  TCase *create = tcase_create("gesture-class-bag-creation");
+  tcase_add_test(create, construct);
+  suite_add_tcase(s, create);
+
+  TCase *usage = tcase_create("gesture-class-bag-usage");
+  tcase_add_checked_fixture(usage, construct_bag, destroy_bag);
+  tcase_add_test(usage, insert);
+  tcase_add_test(usage, remove);
+  tcase_add_test(usage, expand);
+  suite_add_tcase(s, usage);
+
+  return s;
+}
+

=== modified file 'testsuite/libutouch-geis/check_geis2_internals.c'
--- testsuite/libutouch-geis/check_geis2_internals.c	2010-12-31 21:36:34 +0000
+++ testsuite/libutouch-geis/check_geis2_internals.c	2011-01-13 16:20:11 +0000
@@ -12,6 +12,7 @@
 extern Suite *make_error_reporting_suite();
 extern Suite *make_event_queue_suite();
 extern Suite *make_filter_suite();
+extern Suite *make_gesture_class_suite();
 extern Suite *make_region_suite();
 extern Suite *make_subscription_suite();
 
@@ -30,6 +31,7 @@
   srunner_add_suite(sr, make_backend_multiplexor_suite());
   srunner_add_suite(sr, make_backend_event_posting_suite());
   srunner_add_suite(sr, make_device_suite());
+  srunner_add_suite(sr, make_gesture_class_suite());
   srunner_add_suite(sr, make_region_suite());
   srunner_add_suite(sr, make_filter_suite());
   srunner_add_suite(sr, make_subscription_suite());