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

[Stephen M. Webb]

GEIS v2.0 filter API

This series provides the public API layer of the GEIS v2.0 filter module. The implementation layer is still to come, it depends on additional back end work.

[Henrik Rydberg (rydberg)]

At geis.h:132, there is a "teh".

In geis_filter_term_bag_new(), there is an error path that returns non-null.

That's about what I could find. Perhaps also adding _get_attr_for_factility() before respinning this patch would be good.

review: Needs Fixing

[Chase Douglas (chasedouglas)]

Seems reasonable to me from a high-level perspective. I'm not going to go into a line-level code review, so I'm approving.

We still need to figure out continuations in this filter framework, but we'll do so next week at the rally.

review: Approve

[lp:~oif-team/geis/geis2-add-filters]

104. By Stephen M. Webb on 2011-01-05

Added missing geis_attr_value_to_pointer function.

105. By Stephen M. Webb on 2011-01-05

Fixed failure-mode return value in geis_filter_term_bag_new().

106. By Stephen M. Webb on 2011-01-05

Added device cacheing.

107. By Stephen M. Webb on 2011-01-05

Moved back end test fixture into a subproject.

108. By Stephen M. Webb on 2011-01-05

Marked missing geis_event_* symbols as exported.

109. By Stephen M. Webb on 2011-01-05

Added group test for back end device creation.

110. By Stephen M. Webb on 2011-01-06

Added GEIS v2.0 filter implementation (part 4, device subscription).

111. By Stephen M. Webb on 2011-01-06

Minor tweaks.

Unmerged revisions

=== modified file '.bzrignore'
--- .bzrignore	2010-12-09 16:14:15 +0000
+++ .bzrignore	2011-01-06 00:59:08 +0000
@@ -1,9 +1,9 @@
+**.la
+**.lo
 **.pdf
 **/Makefile
 *.deps
 *.libs
-*/*.la
-*/*.lo
 *Makefile.in
 aclocal.m4
 autom4te.cache

=== modified file 'ChangeLog'
--- ChangeLog	2010-12-29 20:35:48 +0000
+++ ChangeLog	2011-01-06 00:59:08 +0000
@@ -1,3 +1,153 @@
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Minor tweaks.
+
+  * include/geis/geis.h: fixed typos in comments
+    (GEIS_DEVICE_ATTRIBUTE_NAME): new constant
+  * libutouch-geis/geis_device.c: used new constant instead of hard-coded string
+  * testsuite/geis2/check_subscription.c: same
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Added GEIS v2.0 filter implementation (part 4, device subscription)
+
+  * libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c
+    (_subscription): add debug output to the test fixture
+  * libutouch-geis/geis_device.c: made name an attr for filtering on
+  * libutouch-geis/geis_filter.h
+    (geis_filter_term_by_facility_count): new function
+    (geis_filter_term_by_facility): new function
+  * libutouch-geis/geis_filter.c: implemented the above new functions
+  * libutouch-geis/geis_subscription.h
+    (geis_subscription_filter_count): new function
+    (geis_subscription_filter): new function
+  * libutouch-geis/geis_subscription.c: implemented the above new functions
+  * testsuite/geis2/check_subscription.c (device_filter): new test case
+ 
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Added group test for back end device creation.
+
+  * libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c
+    (_create_test_devices): new function
+    (geis_backend_new_test_fixture): used it
+  * libutouch-geis/backend/test_fixture/geis_backend_test_fixture.h
+    (geis_backend_new_test_fixture): added track_devices parameter
+  * libutouch-geis/geis.c (_set_valist): refactored to propagate init args
+  * testsuite/geis2/check_device.c: new test case
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Marked missing geis_event_* symbols as exported.
+
+  * libutouch-geis/libutouch-geis.ver (geis_event_attr): exported
+    (geis_event_attr_by_name): exported
+    (geis_event_attr_count): exported
+    (geis_event_delete): exported
+    (geis_event_type): exported
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Moved back end test fixture into a subproject.
+
+  * libutouch-geis/backend/test_fixture: new subproject
+  * libutouch-geis/backend/test_fixture/Makefile.am: new file
+  * libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c: renamed
+    from libutouch-geis/geis_backend_test_fixture.c
+  * libutouch-geis/backend/test_fixture/geis_backend_test_fixture.h: renamed
+    from  libutouch-geis/geis_backend_test_fixture.h 
+  * configure.ac (AC_OUTPUT): added libutouch-geis/backend/test_fixture/Makefile
+  * libutouch-geis/Makefile.am: linked in new subproject
+  * libutouch-geis/backend/Makefile.am: added new subproject
+  * libutouch-geis/geis.c: changed header qualification
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Added device cacheing.
+
+  * libutouch-geis/geis_private.h (geis_get_device_attr_type): new function
+  * libutouch-geis/geis.c (struct _Geis): added devices field
+    (_device_event_handler): new function
+    (_input_event_handler): dispatched BE device events
+    (geis_new_empty): initialized devices field
+    (geis_new_delete): destroyed devices field
+  * libutouch-geis/geis_filter.c (_get_attr_type_for_facility): implemented for
+    the device facility
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Fixed failure-mode return value from geis_filter_term_bag_new
+
+  * libutouch-geis/geis_filter_term.c (geis_filter_term_bag_new): returned
+    NULL on failure
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Added missing geis_attr_value_to_pointer.
+
+  * libutouch-geis/geis_attr.c (geis_attr_value_to_pointer): new function
+    (geis_attr_value_to_string): added case to handle GEIS_ATTR_TYPE_POINTER
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Added GEIS v2.0 filter implementation (part 3, filter terms)
+
+  * libutouch-geis/geis_filter_term.c: new file
+  * libutouch-geis/geis_filter_term.h: new file
+  * include/geis/geis.h (GeisFilterOperation): fixed typo
+  * libutouch-geis/Makefile.am: added new files
+  * libutouch-geis/geis_filter.c (geis_filter_add_term): implemented function
+    (_facility_is_valid): new function
+    (_operation_is_valid): new function
+    (_get_attr_for_facility): new function
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Added GEIS v2.0 filter implementation (part 2)
+
+  * libutouch-geis/geis_filter.c: fixed refcounting on bag insertion
+  * libutouch-geis/geis_subscription.c
+    (geis_subscription_add_filter): implemented stubbed-out function
+    (geis_subscription_remove_filter): implemented stubbed-out function
+  * testsuite/geis2/check_subscription.c: new test case
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Added GEIS v2.0 filter implementation (part 1)
+
+  * testsuite/libutouch-geis/check_filter.c: new test suite
+  * libutouch-geis/geis_filter.h (GeisFilterBag): new data structure
+    (geis_filter_bag_new): new function
+    (geis_filter_bag_delete): new function
+    (geis_filter_bag_count): new function
+    (geis_filter_bag_filter): new function
+    (geis_filter_bag_insert): new function
+    (geis_filter_bag_remove): new function
+    (geis_filter_ref): new function
+    (geis_filter_unref): new function
+  * libutouch-geis/geis_filter.c: implemented new functions
+  * testsuite/libutouch-geis/Makefile.am: added new test suite
+  * testsuite/libutouch-geis/check_geis2_internals.c: added new test suite
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Added GEIS v2.0 filter API
+
+  * libutouch-geis/geis_filter.c: new file
+  * libutouch-geis/geis_filter.h: new file
+  * testsuite/geis2/check_filter.c: new test suite
+  * include/geis/geis.h (GeisFilter): new type
+    (GeisFilterFacility): new enumeration
+    (GeisFilterOperation): new enumeration
+    (gei_filter_new): new function
+    (geis_filter_delete): new function
+    (geis_filter_name): new function
+    (geis_filter_add_term): new function
+  * libutouch-geis/Makefile.am: added new files
+  * libutouch-geis/libutouch-geis.ver: added new symbols
+  * testsuite/geis2/Makefile.am: added new test suite
+  * testsuite/geis2/check_geis2_api.c: added new test suite
+
 2010-12-29  Stephen M. Webb  <[e-mail]>
 
   Added backend subdirectory to libutouch-geis.

=== modified file 'configure.ac'
--- configure.ac	2010-12-29 20:35:48 +0000
+++ configure.ac	2011-01-06 00:59:08 +0000
@@ -88,6 +88,7 @@
                  libutouch-geis-xcb/xcb_gesture.xml
                  libutouch-geis/Makefile
                  libutouch-geis/backend/Makefile
+                 libutouch-geis/backend/test_fixture/Makefile
                  testsuite/Makefile
                  testsuite/libutouch-geis/Makefile
                  testsuite/geis1/Makefile

=== modified file 'include/geis/geis.h'
--- include/geis/geis.h	2010-12-21 01:47:05 +0000
+++ include/geis/geis.h	2011-01-06 00:59:08 +0000
@@ -100,6 +100,7 @@
 #define GEIS_GESTURE_ATTRIBUTE_TOUCH_4_X        "touch 4 x"
 #define GEIS_GESTURE_ATTRIBUTE_TOUCH_4_Y        "touch 4 y"
 
+#define GEIS_DEVICE_ATTRIBUTE_NAME              "device name"
 
 #define GEIS_FALSE 0
 #define GEIS_TRUE  1
@@ -856,7 +857,7 @@
 GEIS_API void geis_device_unref(GeisDevice device);
 
 /**
- * Gets the name of teh input device.
+ * Gets the name of the input device.
  *
  * @param[in] device The device.
  */
@@ -947,11 +948,77 @@
 /* @} */
 
 /**
+ * @defgroup geis2_filter Gesture Filter (GEIS v2.0)
+ * @{
+ */
+
+typedef struct _GeisFilter *GeisFilter;
+
+typedef enum _GeisFilterFacility
+{
+  GEIS_FILTER_DEVICE       = 1000,
+  GEIS_FILTER_GESTURE_TYPE = 2000,
+  GEIS_FILTER_REGION       = 3000
+} GeisFilterFacility;
+
+typedef enum _GeisFilterOperation
+{
+  GEIS_FILTER_OP_EQ,
+  GEIS_FILTER_OP_NE,
+  GEIS_FILTER_OP_GT,
+  GEIS_FILTER_OP_GE,
+  GEIS_FILTER_OP_LT,
+  GEIS_FILTER_OP_LE,
+} GeisFilterOperation;
+
+
+/**
+ * Creates a new filter.
+ *
+ * @param[in] geis  The GEIS API instance.
+ * @param[in] name  A name.
+ *
+ * @returns a GeisFilter object or NULL on failure.
+ */
+GEIS_API GeisFilter geis_filter_new(Geis geis, GeisString name);
+
+/**
+ * Destroys a GEIS v2.0 filter object.
+ *
+ * @param[in] filter  The filter.
+ */
+GEIS_API GeisStatus geis_filter_delete(GeisFilter filter);
+
+/**
+ * Gets the name given to the filter when it was created.
+ *
+ * @param[in] filter  The filter.
+ */
+GEIS_API GeisString geis_filter_name(GeisFilter filter);
+
+/**
+ * Adds a term to a filter.
+ *
+ * @param[in] filter   The filter.
+ * @param[in] facility The term facility.
+ * @param[in] ...      A list of zero or more term descriptions.
+ *
+ * A term description is generally a (attr-name, filter-op, value) triple in
+ * which the meaning of the filter-op and value depend on the type of the attr.
+ *
+ * The term description list must be terminated by a NULL.
+ */
+GEIS_API GeisStatus geis_filter_add_term(GeisFilter         filter,
+                                         GeisFilterFacility facility,
+                                         ...);
+
+/* @} */
+
+/**
  * @defgroup geis2_subscription Gesture Subscription (GEIS v2.0)
  * @{
  */
 
-typedef struct _GeisFilter *GeisFilter;
 typedef struct _GeisSubscription *GeisSubscription;
 
 /**

=== modified file 'libutouch-geis/Makefile.am'
--- libutouch-geis/Makefile.am	2010-12-29 20:35:48 +0000
+++ libutouch-geis/Makefile.am	2011-01-06 00:59:08 +0000
@@ -31,11 +31,12 @@
 	geis_backend.h              geis_backend.c \
 	geis_backend_protected.h \
 	geis_backend_multiplexor.h  geis_backend_multiplexor.c \
-	geis_backend_test_fixture.h geis_backend_test_fixture.c \
 	geis_device.h               geis_device.c \
 	geis_error.h                geis_error.c \
 	geis_event.h                geis_event.c \
 	geis_event_queue.h          geis_event_queue.c \
+	geis_filter.h               geis_filter.c \
+	geis_filter_term.h          geis_filter_term.c \
 	geis_logging.h              geis_logging.c \
 	geis_region.h               geis_region.c \
 	geis_subscription.h         geis_subscription.c \
@@ -57,6 +58,7 @@
 	-lm
 
 libutouch_geis_la_LIBADD = \
+	${builddir}/backend/test_fixture/libutouch-geis-test-fixture.la \
 	$(top_builddir)/libutouch-geis-xcb/libutouch-geis.la 
 
 EXTRA_DIST = $(version_script)

=== modified file 'libutouch-geis/backend/Makefile.am'
--- libutouch-geis/backend/Makefile.am	2010-12-29 20:35:48 +0000
+++ libutouch-geis/backend/Makefile.am	2011-01-06 00:59:08 +0000
@@ -19,5 +19,5 @@
 # 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 #
 
-SUBDIRS = 
+SUBDIRS = test_fixture
 

=== added directory 'libutouch-geis/backend/test_fixture'
=== added file 'libutouch-geis/backend/test_fixture/Makefile.am'
--- libutouch-geis/backend/test_fixture/Makefile.am	1970-01-01 00:00:00 +0000
+++ libutouch-geis/backend/test_fixture/Makefile.am	2011-01-06 00:59:08 +0000
@@ -0,0 +1,22 @@
+#
+# @file libutouch-geis/backend/test_fixture/Makefile.am
+#
+# Build recipes for the test fixture back end.
+#
+
+noinst_LTLIBRARIES = libutouch-geis-test-fixture.la
+
+libutouch_geis_test_fixture_la_SOURCES = \
+	geis_backend_test_fixture.h  geis_backend_test_fixture.c
+
+libutouch_geis_test_fixture_la_CPPFLAGS = \
+	-Wall -Wextra \
+	-fvisibility=hidden \
+	-I$(top_srcdir) \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/libutouch-geis 
+
+libutouch_geis_test_fixture_la_LDFLAGS = 
+
+libutouch_geis_test_fixture_la_LIBADD = 
+

=== renamed file 'libutouch-geis/geis_backend_test_fixture.c' => 'libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c'
--- libutouch-geis/geis_backend_test_fixture.c	2010-12-15 01:48:35 +0000
+++ libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c	2011-01-06 00:59:08 +0000
@@ -21,13 +21,21 @@
 #include "geis_backend.h"
 #include "geis_backend_protected.h"
 
+#include "geis_attr.h"
+#include "geis_device.h"
+#include "geis_event.h"
+#include "geis_filter.h"
+#include "geis_filter_term.h"
 #include "geis_logging.h"
+#include "geis_private.h"
+#include "geis_subscription.h"
 #include <stdlib.h>
 
 
 typedef struct _GeisBackendTestFixture
 {
   struct _GeisBackend  tf_base;
+  Geis                 tf_geis;
 } *GeisBackendTestFixture;
 
 
@@ -39,11 +47,29 @@
 
 
 static GeisStatus 
-_subscribe(GeisBackend      be  __attribute__((unused)),
-           GeisSubscription sub __attribute__((unused)))
+_subscribe(GeisBackend      be,
+           GeisSubscription sub)
 {
   geis_debug("begins");
   GeisStatus status = GEIS_STATUS_SUCCESS;
+  GeisSize   i, j;
+  for (i = 0; i < geis_subscription_filter_count(sub); ++i)
+  {
+    GeisFilter filter = geis_subscription_filter(sub, i);
+    geis_debug("processing filter '%s'", geis_filter_name(filter));
+    for (j = 0;
+         j < geis_filter_term_by_facility_count(filter, GEIS_FILTER_DEVICE);
+         ++j)
+    {
+      GeisFilterTerm term = geis_filter_term_by_facility(filter,
+                                                         GEIS_FILTER_DEVICE,
+                                                         j);
+      geis_debug("  DEVICE \"%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;
 }
@@ -66,8 +92,18 @@
 };
 
 
+static void _create_test_devices(GeisBackendTestFixture tf)
+{
+  GeisDevice device = geis_device_new("abs-test-device", 0);
+  GeisEvent  event = geis_event_new(GEIS_EVENT_DEVICE_AVAILABLE);
+  GeisAttr   attr = geis_attr_new("geis-device", GEIS_ATTR_TYPE_POINTER, device);
+  geis_event_add_attr(event, attr);
+  geis_post_event(tf->tf_geis, event);
+}
+
+
 GeisBackend
-geis_backend_new_test_fixture(Geis geis __attribute__((unused)))
+geis_backend_new_test_fixture(Geis geis, GeisBoolean track_devices)
 {
   GeisBackendTestFixture tf = calloc(1, sizeof(struct _GeisBackendTestFixture));
   if (!tf)
@@ -77,6 +113,12 @@
   }
 
   geis_backend_init_base(&tf->tf_base, &tf_vtbl, "GEIS2 test fixture");
+  tf->tf_geis = geis;
+
+  if (track_devices)
+  {
+    _create_test_devices(tf);
+  }
 
   geis_debug("%s back end created", geis_backend_name(&tf->tf_base));
 

=== renamed file 'libutouch-geis/geis_backend_test_fixture.h' => 'libutouch-geis/backend/test_fixture/geis_backend_test_fixture.h'
--- libutouch-geis/geis_backend_test_fixture.h	2010-12-02 19:09:57 +0000
+++ libutouch-geis/backend/test_fixture/geis_backend_test_fixture.h	2011-01-06 00:59:08 +0000
@@ -2,7 +2,7 @@
  * @file geis_backend_test_fixture.h
  * @brief internal GEIS test fixture back end class
  *
- * 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
@@ -26,10 +26,12 @@
 /**
  * Constructs a new GEIS Test Fuixture back end.
  *
- * @param[in] geis The API instance the back end will run in.
+ * @param[in] geis          The API instance the back end will run in.
+ * @param[in] track_devices Indicates devices should be tracked.
  *
  * The Test Fixture back end is used in unit tests.
  */
-GeisBackend geis_backend_new_test_fixture(Geis geis);
+GeisBackend geis_backend_new_test_fixture(Geis geis,
+                                          GeisBoolean track_devices);
 
 #endif /* GEIS_BACKEND_TEST_FIXTURE_H_ */

=== modified file 'libutouch-geis/geis.c'
--- libutouch-geis/geis.c	2010-12-15 01:48:35 +0000
+++ libutouch-geis/geis.c	2011-01-06 00:59:08 +0000
@@ -2,7 +2,7 @@
  * @file libutouch-geis/geis.c
  * @brief implementation of the uTouch GEIS v2.0 API instance
  *
- * 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
@@ -22,11 +22,14 @@
 #include "geis_private.h"
 
 #include <errno.h>
+#include "geis_attr.h"
 #include "geis_backend.h"
-#include "geis_backend_test_fixture.h"
+#include "test_fixture/geis_backend_test_fixture.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>
@@ -44,6 +47,7 @@
   GeisEventQueue          output_event_queue;
   GeisEventCallback       output_event_callback;
   void                   *output_event_callback_context;
+  GeisDeviceBag           devices;
 };
 
 
@@ -59,6 +63,39 @@
   geis_event_queue_enqueue(geis->output_event_queue, event);
 }
 
+
+/*
+ * Handles device events coming in from the back end.
+ */
+static GeisBoolean
+_device_event_handler(Geis geis, GeisEvent event)
+{
+  GeisBoolean handled = GEIS_FALSE;
+  GeisAttr attr = geis_event_attr_by_name(event, "geis-device");
+  if (!attr)
+  {
+    geis_warning("invalid device event received from back end.");
+    handled = GEIS_TRUE;
+    goto final_exit;
+  }
+  
+  GeisDevice device = geis_attr_value_to_pointer(attr);
+
+  GeisEventType event_type = geis_event_type(event);
+  if (event_type == GEIS_EVENT_DEVICE_AVAILABLE)
+  {
+    geis_device_bag_insert(geis->devices, device);
+  }
+  else if (event_type == GEIS_EVENT_DEVICE_UNAVAILABLE)
+  {
+    geis_device_bag_remove(geis->devices, device);
+  }
+
+final_exit:
+  return handled;
+}
+
+
 /*
  * Filters and transforms raw gesture events into cooked gesture events.
  *
@@ -84,9 +121,24 @@
     event = geis_event_queue_dequeue(geis->input_event_queue);
     if (event)
     {
-      geis->output_event_callback(geis,
-                                  event,
-                                  geis->output_event_callback_context);
+      GeisBoolean handled = 0;
+      switch (geis_event_type(event))
+      {
+	case GEIS_EVENT_DEVICE_AVAILABLE:
+	case GEIS_EVENT_DEVICE_UNAVAILABLE:
+	  handled = _device_event_handler(geis, event);
+	  break;
+
+	default:
+	  break;
+      }
+
+      if (!handled)
+      {
+	geis->output_event_callback(geis,
+	                            event,
+	                            geis->output_event_callback_context);
+      }
     }
   }
 }
@@ -152,8 +204,18 @@
   }
   geis->output_event_callback = _default_output_event_callback;
 
+  geis->devices = geis_device_bag_new();
+  if (!geis->output_event_queue)
+  {
+    geis_error_push(NULL, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("creation of geis device bag failed");
+    goto unwind_output_queue;
+  }
+
   goto final_exit;
 
+unwind_output_queue:
+  geis_event_queue_delete(geis->output_event_queue);
 unwind_input_signal_pipe:
   close(geis->input_event_signal_pipe[0]);
   close(geis->input_event_signal_pipe[1]);
@@ -172,39 +234,55 @@
 }
 
 
+typedef enum _BackendType
+{
+  BACK_END_TYPE_NONE,
+  BACK_END_TYPE_MOCK_ENGINE
+} BackendType;
+
 /**
  * Sets optional parts of a Geis API instance from a variable argument list.
  */
-static void
-geis_set_valist(Geis geis, GeisString init_arg_name, va_list varargs)
+static GeisBoolean
+_set_valist(Geis geis, GeisString init_arg_name, va_list varargs)
 {
+  GeisBoolean status = GEIS_TRUE;
+  BackendType back_end_type = BACK_END_TYPE_NONE;
+  GeisBoolean track_devices = GEIS_FALSE;
+
   while (init_arg_name)
   {
     if (0 == strcmp(init_arg_name, GEIS_INIT_SERVICE_PROVIDER))
     {
       geis_debug("initializing GEIS server");
     }
+    else if (0 == strcmp(init_arg_name, GEIS_INIT_TRACK_DEVICES))
+    {
+      track_devices = GEIS_TRUE;
+    }
     else if (0 == strcmp(init_arg_name, GEIS_INIT_UTOUCH_MOCK_ENGINE))
     {
-      if (NULL != geis->backend)
-      {
-	geis_error("multiple back ends requested, only using %s",\
-	           geis_backend_name(geis->backend));
-      }
-      else
-      {
-	geis_debug("initializing GEIS test fixture");
-	geis->backend = geis_backend_new_test_fixture(geis);
-      }
+      if (back_end_type != BACK_END_TYPE_NONE)
+      {
+	geis_error("multiple back ends requested, only using last request");
+      }
+      back_end_type = BACK_END_TYPE_MOCK_ENGINE;
     }
 
     init_arg_name = va_arg(varargs, GeisString);
   }
 
-  if (NULL == geis->backend)
-  {
-    geis_debug("initializing default GEIS back end");
-  }
+  if (back_end_type ==BACK_END_TYPE_MOCK_ENGINE)
+  {
+    geis->backend = geis_backend_new_test_fixture(geis, track_devices);
+  }
+  else
+  {
+    geis_error_push(NULL, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("back end required but not specified");
+    status = GEIS_FALSE;
+  }
+  return status;
 }
 
 
@@ -214,15 +292,23 @@
 Geis
 geis_new(GeisString init_arg_name, ...)
 {
+  GeisBoolean success = GEIS_FALSE;
   Geis geis = geis_new_empty();
   if (geis)
   {
     va_list varargs;
     va_start(varargs, init_arg_name);
-    geis_set_valist(geis, init_arg_name, varargs);
+    success = _set_valist(geis, init_arg_name, varargs);
     va_end(varargs);
   }
 
+  if (!success)
+  {
+    geis_error_push(NULL, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("can not initialize GEIS API");
+    geis_delete(geis);
+    geis = NULL;
+  }
   return geis;
 }
 
@@ -238,6 +324,11 @@
     return GEIS_STATUS_BAD_ARGUMENT;
   }
 
+  geis_device_bag_delete(geis->devices);
+  geis_event_queue_delete(geis->output_event_queue);
+  close(geis->input_event_signal_pipe[0]);
+  close(geis->input_event_signal_pipe[1]);
+  geis_event_queue_delete(geis->input_event_queue);
   if (geis->backend)
     geis_backend_delete(geis->backend);
   geis_backend_multiplexor_delete(geis->backend_multiplexor);
@@ -420,3 +511,23 @@
 }
 
 
+GeisAttrType
+geis_get_device_attr_type(Geis geis, GeisString attr_name)
+{
+  GeisSize i = 0;
+  for (; i < geis_device_bag_count(geis->devices); ++i)
+  {
+    GeisDevice device = geis_device_bag_device(geis->devices, i);
+    GeisSize j = 0;
+    for (; j < geis_device_attr_count(device); ++j)
+    {
+      GeisAttr attr = geis_device_attr(device, j);
+      if (0 == strcmp(geis_attr_name(attr), attr_name))
+      {
+	return geis_attr_type(attr);
+      }
+    }
+  }
+  return GEIS_ATTR_TYPE_UNKNOWN;
+}
+

=== modified file 'libutouch-geis/geis_attr.c'
--- libutouch-geis/geis_attr.c	2010-12-14 15:24:58 +0000
+++ libutouch-geis/geis_attr.c	2011-01-06 00:59:08 +0000
@@ -2,7 +2,7 @@
  * @file geis_attr.c
  * @brief internal uTouch GeisAttr facilities
  *
- * 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
@@ -304,6 +304,23 @@
 }
 
 
+GeisPointer
+geis_attr_value_to_pointer(GeisAttr attr)
+{
+  GeisPointer p_value = NULL;
+  switch (attr->attr_type)
+  {
+    case GEIS_ATTR_TYPE_POINTER:
+      p_value = attr->v_value;
+      break;
+
+    default:
+      break;
+  }
+  return p_value;
+}
+
+
 GeisString
 geis_attr_value_to_string(GeisAttr attr)
 {
@@ -326,6 +343,11 @@
       s_value = buf;
       break;
 
+    case GEIS_ATTR_TYPE_POINTER:
+      sprintf(buf, "%p", attr->v_value);
+      s_value = buf;
+      break;
+
     case GEIS_ATTR_TYPE_STRING:
       s_value = attr->s_value;
       break;

=== modified file 'libutouch-geis/geis_device.c'
--- libutouch-geis/geis_device.c	2010-12-21 13:59:31 +0000
+++ libutouch-geis/geis_device.c	2011-01-06 00:59:08 +0000
@@ -2,7 +2,7 @@
  * @file libutouch-geis/geis_region.c
  * @brief implementation of the uTouch GEIS v2.0 API Input Device module
  *
- * Copyright 2010 Canonical Ltd.
+ * Copyright 2010, 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
@@ -30,7 +30,6 @@
 struct _GeisDevice
 {
   GeisSize    ref_count;
-  GeisString  name;
   GeisInteger id;
   GeisAttrBag attr_bag;
 };
@@ -177,12 +176,15 @@
     goto unwind_device;
   }
 
-  device->name = strdup(name);
-  if (!device->name)
+  GeisAttr name_attr = geis_attr_new(GEIS_DEVICE_ATTRIBUTE_NAME,
+                                     GEIS_ATTR_TYPE_STRING,
+                                     (void *)name);
+  if (!name_attr)
   {
     geis_debug("error allocating device name");
     goto unwind_attrs;
   }
+  geis_attr_bag_insert(device->attr_bag, name_attr);
 
   device->id = id;
   geis_device_ref(device);
@@ -204,7 +206,7 @@
 static void
 _device_delete(GeisDevice device)
 {
-  free((char *)device->name);
+  geis_attr_bag_delete(device->attr_bag);
   free(device);
 }
 
@@ -233,12 +235,19 @@
 
 
 /*
- * Gets the name of teh input device.
+ * Gets the name of the input device.
  */
 GeisString
 geis_device_name(GeisDevice device)
 {
-  return device->name;
+  GeisString device_name = NULL;
+  GeisAttr name_attr = geis_attr_bag_find(device->attr_bag,
+                                          GEIS_DEVICE_ATTRIBUTE_NAME);
+  if (name_attr)
+  {
+    device_name = geis_attr_value_to_string(name_attr);
+  }
+  return device_name;
 }
 
 

=== added file 'libutouch-geis/geis_filter.c'
--- libutouch-geis/geis_filter.c	1970-01-01 00:00:00 +0000
+++ libutouch-geis/geis_filter.c	2011-01-06 00:59:08 +0000
@@ -0,0 +1,456 @@
+/**
+ * @file libutouch-geis/geis_filter.c
+ * @brief implementation of the uTouch GEIS v2.0 API filter module
+ *
+ * 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
+ * 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_filter.h"
+
+#include "geis_attr.h"
+#include "geis_error.h"
+#include "geis_filter_term.h"
+#include "geis_logging.h"
+#include "geis_private.h"
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+struct _GeisFilter
+{
+  GeisSize          ref_count;
+  GeisString        name;
+  Geis              geis;
+  GeisFilterTermBag terms;
+};
+
+struct _GeisFilterBag
+{
+  GeisFilter *filter_store;
+  GeisSize    filter_store_size;
+  GeisSize    filter_count;
+};
+
+static const int filter_bag_growth_constant = 2;
+
+
+/*
+ * Creates a new filter bag,
+ */
+GeisFilterBag
+geis_filter_bag_new()
+{
+  GeisFilterBag bag = calloc(1, sizeof(struct _GeisFilterBag));
+  if (!bag)
+  {
+    geis_error("failed to allocate filter bag");
+    goto final_exit;
+  }
+
+  bag->filter_store_size = 3;
+  bag->filter_count = 0;
+  bag->filter_store = calloc(bag->filter_store_size, sizeof(GeisFilter));
+  if (!bag->filter_store)
+  {
+    geis_error("failed to allocate filter bag store");
+    goto unwind_bag;
+  }
+  goto final_exit;
+
+unwind_bag:
+  free(bag);
+final_exit:
+  return bag;
+}
+
+
+/*
+ * Destroys a filter bag.
+ */
+void
+geis_filter_bag_delete(GeisFilterBag bag)
+{
+  GeisSize i;
+  for (i = bag->filter_count; i > 0; --i)
+  {
+    geis_filter_delete(bag->filter_store[i-1]);
+  }
+  free(bag);
+}
+
+
+/*
+ * Gets the number of filters in the bag.
+ */
+GeisSize
+geis_filter_bag_count(GeisFilterBag bag)
+{
+  return bag->filter_count;
+}
+
+
+/*
+ * Gets an indicated filter from a bag.
+ */
+GeisFilter
+geis_filter_bag_filter(GeisFilterBag bag, GeisSize index)
+{
+  GeisFilter filter = NULL;
+  if (index < bag->filter_count)
+  {
+    filter = bag->filter_store[index];
+  }
+  return filter;
+}
+
+
+/*
+ * Inserts a filter in the bag.
+ */
+GeisStatus
+geis_filter_bag_insert(GeisFilterBag bag, GeisFilter filter)
+{
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  geis_filter_ref(filter);
+  if (bag->filter_count >= bag->filter_store_size)
+  {
+    GeisSize new_store_size = bag->filter_store_size * filter_bag_growth_constant;
+    GeisFilter *new_store = realloc(bag->filter_store,
+             new_store_size * sizeof(struct _GeisFilter));
+    if (!new_store)
+    {
+      geis_error("failed to reallocate filter bag");
+      goto error_exit;
+    }
+    bag->filter_store = new_store;
+    bag->filter_store_size = new_store_size;
+  }
+  bag->filter_store[bag->filter_count++] = filter;
+  status = GEIS_STATUS_SUCCESS;
+  goto final_exit;
+
+error_exit:
+  geis_filter_unref(filter);
+final_exit:
+  return status;
+}
+
+
+/*
+ * Remoes a filter from the bag.
+ */
+GeisStatus
+geis_filter_bag_remove(GeisFilterBag bag, GeisFilter filter)
+{
+  GeisSize i;
+  GeisStatus status = GEIS_STATUS_SUCCESS;
+  for (i = 0; i < bag->filter_count; ++i)
+  {
+    if (bag->filter_store[i] == filter)
+    {
+      GeisSize j;
+      geis_filter_delete(bag->filter_store[i]);
+      --bag->filter_count;
+      for (j = i; j < bag->filter_count; ++j)
+      {
+	bag->filter_store[j] = bag->filter_store[j+1];
+      }
+      break;
+    }
+  }
+  return status;
+} 
+
+
+/*
+ * Creates a GEIS v2.0 filter object.
+ */
+GeisFilter
+geis_filter_new(Geis geis, GeisString name)
+{
+  GeisFilter filter = calloc(1, sizeof(struct _GeisFilter));
+  if (!filter)
+  {
+    geis_error_push(geis, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("error allocating filter");
+    goto final_exit;
+  }
+
+  if (name)
+  {
+    filter->name = strdup(name);
+  }
+  else
+  {
+    filter->name = strdup("");
+  }
+  if (!filter->name)
+  {
+    geis_error_push(geis, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("error allocating filter name");
+    goto unwind_filter;
+  }
+
+  filter->terms = geis_filter_term_bag_new();
+  if (!filter->terms)
+  {
+    geis_error_push(geis, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("error allocating filter terms");
+    goto unwind_name;
+  }
+
+  filter->geis = geis;
+  geis_filter_ref(filter);
+  goto final_exit;
+
+unwind_name:
+  free((char *)filter->name);
+unwind_filter:
+  free(filter);
+  filter = NULL;
+final_exit:
+  return filter;
+}
+
+
+/*
+ * Destroys a GEIS v2.0 filter object.
+ */
+GeisStatus
+geis_filter_delete(GeisFilter filter)
+{
+  GeisStatus status = GEIS_STATUS_SUCCESS;
+  if (geis_filter_unref(filter) == 0)
+  {
+    geis_filter_term_bag_delete(filter->terms);
+    free((char *)filter->name);
+    free(filter);
+  }
+  return status;
+}
+
+
+/*
+ * Gets the name given to the filter when it was created.
+ */
+GeisString
+geis_filter_name(GeisFilter filter)
+{
+  return filter->name;
+}
+
+
+/*
+ * Indicates if the facility is valid.
+ */
+static GeisBoolean
+_facility_is_valid(GeisFilterFacility facility)
+{
+  return facility == GEIS_FILTER_DEVICE
+    ||   facility == GEIS_FILTER_GESTURE_TYPE
+    ||   facility == GEIS_FILTER_REGION;
+}
+
+
+/*
+ * Indicates if the operation is valid.
+ */
+static GeisBoolean
+_operation_is_valid(GeisFilterOperation op)
+{
+  return op == GEIS_FILTER_OP_EQ
+    ||   op == GEIS_FILTER_OP_NE
+    ||   op == GEIS_FILTER_OP_GT
+    ||   op == GEIS_FILTER_OP_GE
+    ||   op == GEIS_FILTER_OP_LT
+    ||   op == GEIS_FILTER_OP_LE;
+}
+
+
+/*
+ * Gets the attr description by name.
+ * @todo implement this function
+ */
+static GeisAttrType
+_get_attr_type_for_facility(Geis               geis,
+                            GeisFilterFacility facility,
+                            GeisString         attr_name)
+{
+  GeisAttrType type = GEIS_ATTR_TYPE_UNKNOWN;
+  switch (facility)
+  {
+    case GEIS_FILTER_DEVICE:
+      type = geis_get_device_attr_type(geis, attr_name);
+      break;
+    default:
+      break;
+  }
+  return type;
+}
+
+
+/*
+ * Adds a term to a filter.
+ */
+GeisStatus
+geis_filter_add_term(GeisFilter         filter,
+                     GeisFilterFacility facility,
+                                        ...)
+{
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  va_list    varargs;
+  GeisString attr_name;
+
+  if (!_facility_is_valid(facility))
+  {
+    status = GEIS_STATUS_BAD_ARGUMENT;
+    geis_error_push(filter->geis, status);
+    geis_error("invalid filter facility");
+    goto final_exit;
+  }
+
+  va_start(varargs, facility);
+  for (attr_name = va_arg(varargs, GeisString);
+       attr_name;
+       attr_name = va_arg(varargs, GeisString))
+  {
+    GeisAttrType attr_type = _get_attr_type_for_facility(filter->geis,
+                                                         facility,
+                                                         attr_name);
+    if (attr_type == GEIS_ATTR_TYPE_UNKNOWN)
+    {
+      status = GEIS_STATUS_BAD_ARGUMENT;
+      geis_error_push(filter->geis, status);
+      geis_error("invalid attr name for facility");
+      goto final_exit;
+    }
+
+    GeisFilterOperation op = va_arg(varargs, GeisFilterOperation);
+    if (!_operation_is_valid(op))
+    {
+      status = GEIS_STATUS_BAD_ARGUMENT;
+      geis_error_push(filter->geis, status);
+      geis_error("invalid filter operation");
+      goto final_exit;
+    }
+
+    switch (attr_type)
+    {
+      case GEIS_ATTR_TYPE_BOOLEAN:
+	{
+	  GeisBoolean value = va_arg(varargs, GeisBoolean);
+	  GeisAttr attr = geis_attr_new(attr_name, GEIS_ATTR_TYPE_BOOLEAN, &value);
+	  GeisFilterTerm term = geis_filter_term_new(facility, op, attr);
+	  geis_filter_term_bag_insert(filter->terms, term);
+	}
+	break;
+
+      case GEIS_ATTR_TYPE_FLOAT:
+	{
+	  GeisFloat value = va_arg(varargs, double);
+	  GeisAttr attr = geis_attr_new(attr_name, GEIS_ATTR_TYPE_FLOAT, &value);
+	  GeisFilterTerm term = geis_filter_term_new(facility, op, attr);
+	  geis_filter_term_bag_insert(filter->terms, term);
+	}
+	break;
+
+      case GEIS_ATTR_TYPE_INTEGER:
+	{
+	  GeisInteger value = va_arg(varargs, GeisInteger);
+	  GeisAttr attr = geis_attr_new(attr_name, GEIS_ATTR_TYPE_INTEGER, &value);
+	  GeisFilterTerm term = geis_filter_term_new(facility, op, attr);
+	  geis_filter_term_bag_insert(filter->terms, term);
+	}
+	break;
+
+      case GEIS_ATTR_TYPE_POINTER:
+	{
+	  GeisPointer value = va_arg(varargs, GeisPointer);
+	  GeisAttr attr = geis_attr_new(attr_name, GEIS_ATTR_TYPE_POINTER, value);
+	  GeisFilterTerm term = geis_filter_term_new(facility, op, attr);
+	  geis_filter_term_bag_insert(filter->terms, term);
+	}
+	break;
+
+      case GEIS_ATTR_TYPE_STRING:
+	{
+	  GeisString value = va_arg(varargs, GeisString);
+	  GeisAttr attr = geis_attr_new(attr_name, GEIS_ATTR_TYPE_STRING, (void *)value);
+	  GeisFilterTerm term = geis_filter_term_new(facility, op, attr);
+	  geis_filter_term_bag_insert(filter->terms, term);
+	}
+	break;
+
+      default:
+	status = GEIS_STATUS_BAD_ARGUMENT;
+	geis_error_push(filter->geis, status);
+	geis_error("invalid filter argument");
+	goto final_exit;
+	break;
+    }
+  }
+  va_end(varargs);
+  status = GEIS_STATUS_SUCCESS;
+
+final_exit:
+  return status;
+}
+
+
+/*
+ * Atomically increments filter refcount.
+ */
+void
+geis_filter_ref(GeisFilter filter)
+{
+  __sync_add_and_fetch(&filter->ref_count, 1);
+}
+
+
+/*
+ * Atomically decrements and returns filter refcount.
+ */
+GeisSize
+geis_filter_unref(GeisFilter filter)
+{
+  return __sync_sub_and_fetch(&filter->ref_count, 1);
+}
+
+/*
+ * Gets the number of terms in the filter grouped by facility.
+ */
+GeisSize
+geis_filter_term_by_facility_count(GeisFilter         filter,
+                                   GeisFilterFacility facility)
+{
+  return geis_filter_term_bag_count(filter->terms, facility);
+}
+
+
+/*
+ * Gets the indicated term in the filter by facility.
+ */
+GeisFilterTerm
+geis_filter_term_by_facility(GeisFilter         filter,
+                             GeisFilterFacility facility,
+                             GeisSize           index)
+{
+  return geis_filter_term_bag_filter(filter->terms, facility, index);
+}
+
+

=== added file 'libutouch-geis/geis_filter.h'
--- libutouch-geis/geis_filter.h	1970-01-01 00:00:00 +0000
+++ libutouch-geis/geis_filter.h	2011-01-06 00:59:08 +0000
@@ -0,0 +1,123 @@
+/**
+ * @file geis_filter.h
+ * @brief internal uTouch Geis filter 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_FILTER_H_
+#define GEIS_FILTER_H_
+
+#include "geis/geis.h"
+#include "geis_filter_term.h"
+
+/**
+ * @defgroup utouch_geis_filter_container A Filter Container
+ * @{
+ */
+
+/**
+ * An unsorted container for holding filters.
+ */
+typedef struct _GeisFilterBag *GeisFilterBag;
+
+/**
+ * Creates a new filter bag,
+ */
+GeisFilterBag geis_filter_bag_new();
+
+/**
+ * Destroys a filter bag.
+ *
+ * @param[in] bag The filter bag,
+ */
+void geis_filter_bag_delete(GeisFilterBag bag);
+
+/**
+ * Gets the number of filters in the bag.
+ *
+ * @param[in] bag The filter bag,
+ */
+GeisSize geis_filter_bag_count(GeisFilterBag bag);
+
+/**t
+ * Gets an indicated filter from a bag.
+ *
+ * @param[in] bag   The filter bag.
+ * @param[in] index The index.
+ */
+GeisFilter geis_filter_bag_filter(GeisFilterBag bag, GeisSize index);
+
+/**
+ * Inserts a filter in the bag.
+ *
+ * @param[in] bag    The filter bag.
+ * @param[in] filter The filter to insert.
+ */
+GeisStatus geis_filter_bag_insert(GeisFilterBag bag, GeisFilter filter);
+
+/**
+ * Remoes a filter from the bag.
+ *
+ * @param[in] bag    The filter bag.
+ * @param[in] filter The filter to remove.
+ */
+GeisStatus geis_filter_bag_remove(GeisFilterBag bag, GeisFilter filter);
+
+/** @} */
+
+/**
+ * @defgroup utouch_geis_filter_internals Filter Internals
+ * @{
+ */
+
+/**
+ * Increments the reference count on a filter.
+ *
+ * @param[in] filter The filter.
+ */
+void geis_filter_ref(GeisFilter filter);
+
+/**
+ * Decrements and returns the referemce count on a filter.
+ *
+ * @param[in] filter The filter.
+ */
+GeisSize geis_filter_unref(GeisFilter filter);
+
+/**
+ * Gets the number of terms in the filter grouped by facility.
+ *
+ * @param[in] filter   The filter.
+ * @param[in] facility The facility.
+ */
+GeisSize geis_filter_term_by_facility_count(GeisFilter         filter,
+                                            GeisFilterFacility facility);
+
+/**
+ * Gets the indicated term in the filter by facility.
+ *
+ * @param[in] filter   The filter.
+ * @param[in] facility The facility.
+ * @param[in] index    Indicates which term.
+ */
+GeisFilterTerm geis_filter_term_by_facility(GeisFilter         filter,
+                                            GeisFilterFacility facility,
+                                            GeisSize           index);
+
+/** @} */
+
+#endif /* GEIS_FILTER_H_ */

=== added file 'libutouch-geis/geis_filter_term.c'
--- libutouch-geis/geis_filter_term.c	1970-01-01 00:00:00 +0000
+++ libutouch-geis/geis_filter_term.c	2011-01-06 00:59:08 +0000
@@ -0,0 +1,206 @@
+/**
+ * @file libutouch-geis/geis_filter_term.c
+ * @brief implementation of the uTouch GEIS v2.0 API filter term 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_filter_term.h"
+
+#include "geis_attr.h"
+#include "geis_error.h"
+#include "geis_logging.h"
+#include <stdlib.h>
+
+
+/*
+ * One of the terms of a filter. 
+ */
+struct _GeisFilterTerm
+{
+  GeisFilterFacility  facility;
+  GeisFilterOperation op;
+  GeisAttr            attr;
+};
+
+
+/*
+ * All of the terms of a filter.
+ */
+struct _GeisFilterTermBag
+{
+  GeisFilterTerm *store;
+  GeisSize        store_size;
+  GeisSize        count;
+};
+
+static const GeisSize term_bag_growth_constant = 2;
+
+
+GeisFilterTermBag
+geis_filter_term_bag_new()
+{
+  GeisFilterTermBag bag = calloc(1, sizeof(struct _GeisFilterTermBag));
+  if (!bag)
+  {
+    geis_error("failed to allocate filter termbag");
+    goto final_exit;
+  }
+
+  bag->store_size = 3;
+  bag->count = 0;
+  bag->store = calloc(bag->store_size, sizeof(GeisFilterTerm));
+  if (!bag->store)
+  {
+    geis_error("failed to allocate filter bag store");
+    goto unwind_bag;
+  }
+  goto final_exit;
+
+unwind_bag:
+  free(bag);
+  bag = NULL;
+final_exit:
+  return bag;
+}
+
+
+void
+geis_filter_term_bag_delete(GeisFilterTermBag bag)
+{
+  free(bag);
+}
+
+
+GeisSize
+geis_filter_term_bag_count(GeisFilterTermBag bag, GeisFilterFacility facility)
+{
+  GeisSize count = 0;
+  GeisSize i = 0;
+  while (i < bag->count)
+  {
+    if (bag->store[i]->facility == facility)
+      ++count;
+    ++i;
+  }
+  return count;
+}
+
+
+GeisFilterTerm
+geis_filter_term_bag_filter(GeisFilterTermBag  bag,
+                            GeisFilterFacility facility,
+                            GeisSize           index)
+{
+  GeisFilterTerm term = NULL;
+  GeisSize count = 0;
+  GeisSize i = 0;
+  while (i < bag->count)
+  {
+    if (bag->store[i]->facility == facility)
+    {
+      if (count == index)
+      {
+	term = bag->store[i];
+	break;
+      }
+      ++count;
+    }
+    ++i;
+  }
+  return term;
+}
+
+
+GeisStatus
+geis_filter_term_bag_insert(GeisFilterTermBag bag,
+                            GeisFilterTerm    term)
+{
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  if (bag->count >= bag->store_size)
+  {
+    GeisSize new_store_size = bag->store_size * term_bag_growth_constant;
+    GeisFilterTerm *new_store = realloc(bag->store,
+             new_store_size * sizeof(struct _GeisFilterTerm));
+    if (!new_store)
+    {
+      geis_error("failed to reallocate filter term bag");
+      goto error_exit;
+    }
+    bag->store = new_store;
+    bag->store_size = new_store_size;
+  }
+  bag->store[bag->count++] = term;
+  status = GEIS_STATUS_SUCCESS;
+  goto final_exit;
+
+error_exit:
+final_exit:
+  return status;
+}
+
+
+GeisFilterTerm
+geis_filter_term_new(GeisFilterFacility  facility,
+                     GeisFilterOperation operation,
+                     GeisAttr            attr)
+{
+  GeisFilterTerm term = calloc(1, sizeof(struct _GeisFilterTerm));
+  if (!term)
+  {
+    geis_error("failed to allocate filter termbag");
+    goto final_exit;
+  }
+  term->facility = facility;
+  term->op       = operation;
+  term->attr     = attr;
+
+final_exit:
+  return term;
+}
+
+
+void
+geis_filter_term_delete(GeisFilterTerm term)
+{
+  geis_attr_delete(term->attr);
+  free(term);
+}
+
+
+GeisFilterFacility
+geis_filter_term_facility(GeisFilterTerm term)
+{
+  return term->facility;
+}
+
+
+GeisFilterOperation
+geis_filter_term_operation(GeisFilterTerm term)
+{
+  return term->op;
+}
+
+
+GeisAttr
+geis_filter_term_attr(GeisFilterTerm term)
+{
+  return term->attr;
+}
+
+
+

=== added file 'libutouch-geis/geis_filter_term.h'
--- libutouch-geis/geis_filter_term.h	1970-01-01 00:00:00 +0000
+++ libutouch-geis/geis_filter_term.h	2011-01-06 00:59:08 +0000
@@ -0,0 +1,139 @@
+/**
+ * @file geis_filter_term.h
+ * @brief internal uTouch Geis filter term module private interface
+ *
+ * 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
+ */
+#ifndef GEIS_FILTER_TERM_H_
+#define GEIS_FILTER_TERM_H_
+
+#include "geis/geis.h"
+
+/**
+ * @defgroup utouch_geis_filter_term Filter Terms.
+ * @{
+ */
+
+/**
+ * One of the terms of a filter.
+ *
+ * A term belong to a facility (eg. device, gesture type, region) and is used to
+ * compare (using an operation) a named attribute with a given value.
+ */
+typedef struct _GeisFilterTerm *GeisFilterTerm;
+
+/**
+ * Creates a new filter term.
+ *
+ * @param[in] facility  The term's facility.
+ * @param[in] operation The term's operation.
+ * @param[in] attr      The term's attr name, type, and value
+ */
+GeisFilterTerm geis_filter_term_new(GeisFilterFacility  facility,
+                                    GeisFilterOperation operation,
+                                    GeisAttr            attr);
+
+/**
+ * Destroys a filter term.
+ *
+ * @param[in] term  The filter term.
+ */
+void geis_filter_term_delete(GeisFilterTerm term);
+
+/**
+ * Gets a filter term's facility.
+ *
+ * @param[in] term  The filter term.
+ */
+GeisFilterFacility geis_filter_term_facility(GeisFilterTerm term);
+
+/**
+ * Gets a filter term's operation.
+ *
+ * @param[in] term  The filter term.
+ */
+GeisFilterOperation geis_filter_term_operation(GeisFilterTerm term);
+
+/**
+ * Gets a filter term's attributes.
+ *
+ * @param[in] term  The filter term.
+ */
+GeisAttr geis_filter_term_attr(GeisFilterTerm term);
+
+/** @} */
+
+/**
+ * @defgroup utouch_geis_filter_term_container A Filter Term Container
+ * @{
+ */
+
+/**
+ * An unsorted container for holding filter terms.
+ *
+ * This implementation is physically unsorted, but terms are logically grouped
+ * by facility.
+ *
+ * This is a purely internal structure, as is the filter term.  The bag "owns"
+ * the term.
+ */
+typedef struct _GeisFilterTermBag *GeisFilterTermBag;
+
+/**
+ * Creates a new filter term bag,
+ */
+GeisFilterTermBag geis_filter_term_bag_new();
+
+/**
+ * Destroys a filter term bag.
+ *
+ * @param[in] bag The filter term bag.
+ */
+void geis_filter_term_bag_delete(GeisFilterTermBag bag);
+
+/**
+ * Gets the number of filter terms in the bag for a given facility.
+ *
+ * @param[in] bag      The filter term bag.
+ * @param[in] facility The facility.
+ */
+GeisSize geis_filter_term_bag_count(GeisFilterTermBag  bag,
+                                    GeisFilterFacility facility);
+
+/**
+ * Gets an indicated filter term from a bag.
+ *
+ * @param[in] bag      The filter bag.
+ * @param[in] facility The facility.
+ * @param[in] index    The index.
+ */
+GeisFilterTerm geis_filter_term_bag_filter(GeisFilterTermBag  bag,
+                                           GeisFilterFacility facility,
+                                           GeisSize           index);
+
+/**
+ * Inserts a filter in the bag.
+ *
+ * @param[in] bag    The filter bag.
+ * @param[in] term   The filter to insert.
+ */
+GeisStatus geis_filter_term_bag_insert(GeisFilterTermBag bag,
+                                       GeisFilterTerm    term);
+
+/** @} */
+
+#endif /* GEIS_FILTER_TERM_H_ */

=== modified file 'libutouch-geis/geis_private.h'
--- libutouch-geis/geis_private.h	2010-12-15 01:48:35 +0000
+++ libutouch-geis/geis_private.h	2011-01-06 00:59:08 +0000
@@ -5,7 +5,7 @@
  * This file is the internal interface to the GEIS API object.  It provides the
  * implementation hooks for back ends to pass information through the 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
@@ -90,4 +90,19 @@
  */
 GeisStatus geis_deactivate_subscription(Geis geis, GeisSubscription sub);
 
+/**
+ * Gets the type of a named device attr.
+ *
+ * @param[in]  geis      The API instance.
+ * @param[in]  attr_name The name of the device attr.
+ *
+ * Gets the type of a device attr by name, assuming the attr is known.
+ *
+ * There is a basic assumption that all device 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_device_attr_type(Geis geis, GeisString attr_name);
+
 #endif /* GEIS_PRIVATE_H_ */

=== modified file 'libutouch-geis/geis_subscription.c'
--- libutouch-geis/geis_subscription.c	2010-12-15 01:48:35 +0000
+++ libutouch-geis/geis_subscription.c	2011-01-06 00:59:08 +0000
@@ -2,7 +2,7 @@
  * @file libutouch-geis/geis_subscription.c
  * @brief implementation of the uTouch GEIS v2.0 API subscription module
  *
- * 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
@@ -22,8 +22,9 @@
 #include "geis_subscription.h"
 
 #include "geis/geis.h"
+#include "geis_filter.h"
+#include "geis_logging.h"
 #include "geis_private.h"
-#include "geis_logging.h"
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
@@ -35,6 +36,7 @@
   GeisInteger           sub_id;
   GeisString            sub_name;
   GeisSubscriptionFlags sub_flags;
+  GeisFilterBag         sub_filters;
 };
 
 struct _GeisSubBag
@@ -126,12 +128,12 @@
   }
 
   GeisSize new_store_size = ceilf(bag->sub_store_size * sub_bag_growth_constant);
-  geis_debug(". new_store_size=%ld", new_store_size);
   GeisSubscription *new_store = realloc(bag->sub_store,
            new_store_size * sizeof(struct _GeisSubBag));
   if (!new_store)
   {
     geis_error("failed to reallocate sub bag");
+    index = -1;
     goto final_exit;
   }
   index = bag->sub_store_size;
@@ -208,26 +210,54 @@
   if (!sub)
   {
     geis_error_push(geis, GEIS_STATUS_UNKNOWN_ERROR);
-    geis_error("calloc failed");
-    goto error_exit;
+    geis_error("error allocating subscription");
+    goto final_exit;
+  }
+
+  if (sub_name)
+  {
+    sub->sub_name = strdup(sub_name);
   }
   else
   {
-    if (sub_name)
-    {
-      sub->sub_name = strdup(sub_name);
-    }
-    else
-    {
-      sub->sub_name = strdup("");
-    }
-    sub->sub_geis = geis;
-    sub->sub_id = geis_subscription_bag_insert(geis_subscription_bag(geis), sub);
-    sub->sub_flags = sub_flags;
-    geis_debug("created subscription \"%s\" id %d", sub->sub_name, sub->sub_id);
-  }
-
-error_exit:
+    sub->sub_name = strdup("");
+  }
+  if (!sub->sub_name)
+  {
+    geis_error_push(geis, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("error allocating subscription name");
+    goto unwind_sub;
+  }
+
+  sub->sub_filters = geis_filter_bag_new();
+  if (!sub->sub_filters)
+  {
+    geis_error_push(geis, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("error allocating subscription filters");
+    goto unwind_name;
+  }
+
+  sub->sub_id = geis_subscription_bag_insert(geis_subscription_bag(geis), sub);
+  if (sub->sub_id < 0)
+  {
+    geis_error_push(geis, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("error storing subscription");
+    goto unwind_filters;
+  }
+
+  sub->sub_geis = geis;
+  sub->sub_flags = sub_flags;
+  geis_debug("created subscription \"%s\" id %d", sub->sub_name, sub->sub_id);
+  goto final_exit;
+
+unwind_filters:
+  geis_filter_bag_delete(sub->sub_filters);
+unwind_name:
+  free((char *)sub->sub_name);
+unwind_sub:
+  free(sub);
+  sub = NULL;
+final_exit:
   return sub;
 }
 
@@ -289,7 +319,7 @@
  */
 GeisStatus
 geis_subscription_add_filter(GeisSubscription sub,
-                             GeisFilter       filter __attribute__((unused)))
+                             GeisFilter       filter)
 {
   GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
   if (!sub)
@@ -298,6 +328,14 @@
     goto error_exit;
   }
 
+  status = geis_filter_bag_insert(sub->sub_filters, filter);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    geis_error_push(sub->sub_geis, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("error adding filter to subscription");
+    goto error_exit;
+  }
+
 error_exit:
   return status;
 }
@@ -310,7 +348,7 @@
  */
 GeisStatus
 geis_subscription_remove_filter(GeisSubscription sub,
-                                GeisFilter       filter __attribute__((unused)))
+                                GeisFilter       filter)
 {
   GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
   if (!sub)
@@ -319,8 +357,36 @@
     goto error_exit;
   }
 
+  status = geis_filter_bag_remove(sub->sub_filters, filter);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    geis_error_push(sub->sub_geis, GEIS_STATUS_UNKNOWN_ERROR);
+    geis_error("error removing filter from subscription");
+    goto error_exit;
+  }
+
 error_exit:
   return status;
 }
 
 
+/*
+ * Gets the numvber of filters in a subscirption.
+ */
+GeisSize
+geis_subscription_filter_count(GeisSubscription sub)
+{
+  return geis_filter_bag_count(sub->sub_filters);
+}
+
+
+/*
+ * Gets an indicated filter from a subscription.
+ */
+GeisFilter
+geis_subscription_filter(GeisSubscription sub, GeisSize index)
+{
+  return geis_filter_bag_filter(sub->sub_filters, index);
+}
+
+

=== modified file 'libutouch-geis/geis_subscription.h'
--- libutouch-geis/geis_subscription.h	2010-12-15 01:48:35 +0000
+++ libutouch-geis/geis_subscription.h	2011-01-06 00:59:08 +0000
@@ -2,7 +2,7 @@
  * @file geis_subscription.h
  * @brief internal uTouch Geis subscription modul private interface
  *
- * 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
@@ -25,6 +25,11 @@
 
 
 /**
+ * @defgroup utouch_geis_sub_container A Subscription Container
+ * @{
+ */
+
+/**
  * A container for subscriptions.
  */
 typedef struct _GeisSubBag *GeisSubBag;
@@ -79,5 +84,21 @@
  */
 GeisSubscription geis_subscription_bag_find(GeisSubBag bag, GeisInteger sub_id);
 
+/* @} */
+
+/**
+ * Gets the numvber of filters in a subscirption.
+ *
+ * @param[in] sub  The subscription.
+ */
+GeisSize geis_subscription_filter_count(GeisSubscription sub);
+
+/**
+ * Gets an indicated filter from a subscription.
+ *
+ * @param[in] sub   The subscription.
+ * @param[in] index Indicates which filter to retrieve.
+ */
+GeisFilter geis_subscription_filter(GeisSubscription sub, GeisSize index);
 
 #endif /* GEIS_SUBSCRIPTION_H_ */

=== modified file 'libutouch-geis/libutouch-geis.ver'
--- libutouch-geis/libutouch-geis.ver	2010-12-21 01:47:05 +0000
+++ libutouch-geis/libutouch-geis.ver	2011-01-06 00:59:08 +0000
@@ -31,6 +31,15 @@
     geis_error_code;
     geis_error_count;
     geis_error_message;
+    geis_event_attr;
+    geis_event_attr_by_name;
+    geis_event_attr_count;
+    geis_event_delete;
+    geis_event_type;
+    geis_filter_add_term;
+    geis_filter_delete;
+    geis_filter_name;
+    geis_filter_new;
     geis_get_configuration;
     geis_new;
     geis_next_event;

=== modified file 'testsuite/geis2/Makefile.am'
--- testsuite/geis2/Makefile.am	2010-12-29 20:23:01 +0000
+++ testsuite/geis2/Makefile.am	2011-01-06 00:59:08 +0000
@@ -19,6 +19,7 @@
 	check_device.c \
 	check_error_codes.c \
 	check_event.c \
+	check_filter.c \
 	check_geis_new.c \
 	check_general_types.c \
 	check_region.c \

=== modified file 'testsuite/geis2/check_device.c'
--- testsuite/geis2/check_device.c	2010-12-21 01:47:05 +0000
+++ testsuite/geis2/check_device.c	2011-01-06 00:59:08 +0000
@@ -5,6 +5,24 @@
 
 #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_DEVICES, NULL);
+}
+
+/* fixture teardown */
+static void
+destroy_geis()
+{
+  geis_delete(g_geis);
+}
+
+
 /* Compile-time test to ensure types are defined */
 START_TEST(geis_device_types)
 {
@@ -29,6 +47,23 @@
 }
 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_DEVICE_AVAILABLE,
+              "unexpected event type received");
+
+}
+END_TEST
+
 
 /* boilerplate */
 Suite *
@@ -36,10 +71,15 @@
 {
   Suite *s = suite_create("geis2_device");
 
-  TCase *device = tcase_create("geis2_device");
+  TCase *device = tcase_create("device-api");
   tcase_add_test(device, geis_device_types);
   suite_add_tcase(s, device);
 
+  TCase *usage = tcase_create("device-usage");
+  tcase_add_checked_fixture(usage, construct_geis, destroy_geis);
+  tcase_add_test(usage, receive_events);
+  suite_add_tcase(s, usage);
+
   return s;
 }
 

=== added file 'testsuite/geis2/check_filter.c'
--- testsuite/geis2/check_filter.c	1970-01-01 00:00:00 +0000
+++ testsuite/geis2/check_filter.c	2011-01-06 00:59:08 +0000
@@ -0,0 +1,41 @@
+/**
+ * Unit tests for GEIS v2.0 Filter Module.
+ */
+#include <check.h>
+
+#include <geis/geis.h>
+
+/* Compile-time test to ensure types are defined */
+START_TEST(geis_filter_types)
+{
+  GeisFilter      type;
+}
+END_TEST
+
+/* Compile-and-link-time test to verify required functions exist */
+START_TEST(geis_filter_functions)
+{
+  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,
+			 GEIS_GESTURE_ATTRIBUTE_TOUCHES, GEIS_FILTER_OP_GT, 1,
+			 NULL);
+  geis_filter_delete(filter);
+}
+END_TEST
+
+
+/* boilerplate */
+Suite *
+geis2_filter_suite_new()
+{
+  Suite *s = suite_create("geis2_filter");
+
+  TCase *filter = tcase_create("geis2_filter");
+  tcase_add_test(filter, geis_filter_types);
+  suite_add_tcase(s, filter);
+
+  return s;
+}
+

=== modified file 'testsuite/geis2/check_geis2_api.c'
--- testsuite/geis2/check_geis2_api.c	2010-12-21 01:47:05 +0000
+++ testsuite/geis2/check_geis2_api.c	2011-01-06 00:59:08 +0000
@@ -12,6 +12,7 @@
 extern Suite *geis2_config_suite_new();
 extern Suite *geis2_attr_suite_new();
 extern Suite *geis2_region_suite_new();
+extern Suite *geis2_filter_suite_new();
 extern Suite *geis2_subscription_suite_new();
 extern Suite *geis2_event_suite_new();
 
@@ -31,6 +32,7 @@
   srunner_add_suite(sr, geis2_attr_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_subscription.c'
--- testsuite/geis2/check_subscription.c	2010-12-15 01:48:35 +0000
+++ testsuite/geis2/check_subscription.c	2011-01-06 00:59:08 +0000
@@ -14,7 +14,7 @@
 static void
 construct_geis()
 {
-  g_geis = geis_new(GEIS_INIT_UTOUCH_MOCK_ENGINE, NULL);
+  g_geis = geis_new(GEIS_INIT_UTOUCH_MOCK_ENGINE, GEIS_INIT_TRACK_DEVICES, NULL);
 }
 
 /* fixture teardown */
@@ -51,6 +51,69 @@
 }
 END_TEST
 
+
+START_TEST(filter)
+{
+  GeisFilter filter = geis_filter_new(g_geis, "filter");
+  GeisSubscription sub = geis_subscription_new(g_geis,
+                                               "name",
+                                               GEIS_SUBSCRIPTION_NONE);
+  fail_unless(GEIS_STATUS_SUCCESS == geis_subscription_add_filter(sub, filter));
+  fail_unless(GEIS_STATUS_SUCCESS == geis_subscription_remove_filter(sub, filter));
+}
+END_TEST
+
+
+START_TEST(device_filter)
+{
+  GeisStatus status;
+  GeisEvent event;
+
+  GeisSubscription sub = geis_subscription_new(g_geis,
+                                               "devices",
+                                               GEIS_SUBSCRIPTION_NONE);
+
+  while (geis_dispatch_events(g_geis) == GEIS_STATUS_CONTINUE)
+    ;
+  status = geis_next_event(g_geis, &event);
+  while (status == GEIS_STATUS_SUCCESS || status == GEIS_STATUS_CONTINUE)
+  {
+    if (geis_event_type(event) == GEIS_EVENT_DEVICE_AVAILABLE)
+    {
+      GeisAttr attr = geis_event_attr_by_name(event, "geis-device");
+      fail_if (!attr, "geis-device attr not found in device event");
+
+      GeisDevice device = geis_attr_value_to_pointer(attr);
+      fail_if (!device, "geis device not found in device event");
+
+      GeisFilter filter = geis_filter_new(g_geis, "device filter");
+      fail_if(!filter, "can not create filter");
+
+      GeisStatus fs = geis_filter_add_term(filter, GEIS_FILTER_DEVICE,
+          GEIS_DEVICE_ATTRIBUTE_NAME, GEIS_FILTER_OP_NE, geis_device_name(device),
+          NULL);
+      fail_if(fs != GEIS_STATUS_SUCCESS, "can not add device 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;
+      }
+    }
+  }
+
+  fail_unless(GEIS_STATUS_SUCCESS == geis_subscription_activate(sub),
+              "unable to activate subscription");
+}
+END_TEST
+
+
 /* boilerplate */
 Suite *
 geis2_subscription_suite_new()
@@ -64,6 +127,8 @@
   TCase *usage = tcase_create("subscription-usage");
   tcase_add_checked_fixture(usage, construct_geis, destroy_geis);
   tcase_add_test(usage, construction);
+  tcase_add_test(usage, filter);
+  tcase_add_test(usage, device_filter);
   suite_add_tcase(s, usage);
 
   return s;

=== modified file 'testsuite/libutouch-geis/Makefile.am'
--- testsuite/libutouch-geis/Makefile.am	2010-12-29 20:23:01 +0000
+++ testsuite/libutouch-geis/Makefile.am	2011-01-06 00:59:08 +0000
@@ -36,6 +36,7 @@
 	check_device.c \
 	check_error_reporting.c \
 	check_event_queue.c \
+	check_filter.c \
 	check_geis_private.c \
 	check_region.c \
 	check_subscription.c \

=== added file 'testsuite/libutouch-geis/check_filter.c'
--- testsuite/libutouch-geis/check_filter.c	1970-01-01 00:00:00 +0000
+++ testsuite/libutouch-geis/check_filter.c	2011-01-06 00:59:08 +0000
@@ -0,0 +1,101 @@
+/**
+ * unit tests for the geis filter module
+ */
+#include <check.h>
+
+#include "libutouch-geis/geis_filter.h"
+
+
+/* fixtures */
+static Geis          g_geis;
+static GeisFilterBag g_filter_bag;
+static GeisString    g_filter_name = "filter";
+
+/* fixture setup */
+static void
+construct_bag()
+{
+  g_geis = geis_new(GEIS_INIT_UTOUCH_MOCK_ENGINE, NULL);
+  g_filter_bag = geis_filter_bag_new();
+}
+
+/* fixture teardown */
+static void
+destroy_bag()
+{
+  geis_filter_bag_delete(g_filter_bag);
+  geis_delete(g_geis);
+}
+
+/* verify bag construction/destruction */
+START_TEST(construct)
+{
+  GeisFilterBag bag = geis_filter_bag_new();
+  fail_unless(bag != NULL, "failed to create filter bag");
+  geis_filter_bag_delete(bag);
+}
+END_TEST
+
+/* verify bag insertion */
+START_TEST(insert)
+{
+  GeisFilter filter = geis_filter_new(g_geis, g_filter_name);
+  geis_filter_bag_insert(g_filter_bag, filter);
+  fail_unless(geis_filter_bag_count(g_filter_bag) == 1,
+              "unexpected bag size after insertion");
+}
+END_TEST
+
+/* verify bag removal */
+START_TEST(remove)
+{
+  GeisFilter filter = geis_filter_new(g_geis, g_filter_name);
+  geis_filter_bag_insert(g_filter_bag, filter);
+  fail_unless(geis_filter_bag_count(g_filter_bag) == 1,
+              "unexpected bag size after insertion");
+  geis_filter_bag_remove(g_filter_bag, filter);
+  fail_unless(geis_filter_bag_count(g_filter_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);
+    GeisFilter filter = geis_filter_new(g_geis, name);
+    geis_filter_bag_insert(g_filter_bag, filter);
+    count = geis_filter_bag_count(g_filter_bag);
+    fail_unless(count == (i+1),
+                "unexpected bag size %ld after insertion, expected %d",
+                count, i+1);
+  }
+}
+END_TEST
+
+
+
+/* boilerplate */
+Suite *
+make_filter_suite()
+{
+  Suite *s = suite_create("utouch-geis2-filter");
+
+  TCase *create = tcase_create("filter-bag-creation");
+  tcase_add_test(create, construct);
+  suite_add_tcase(s, create);
+
+  TCase *usage = tcase_create("filter-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-21 13:59:31 +0000
+++ testsuite/libutouch-geis/check_geis2_internals.c	2011-01-06 00:59:08 +0000
@@ -11,6 +11,7 @@
 extern Suite *make_device_suite();
 extern Suite *make_error_reporting_suite();
 extern Suite *make_event_queue_suite();
+extern Suite *make_filter_suite();
 extern Suite *make_region_suite();
 extern Suite *make_subscription_suite();
 
@@ -30,6 +31,7 @@
   srunner_add_suite(sr, make_backend_event_posting_suite());
   srunner_add_suite(sr, make_device_suite());
   srunner_add_suite(sr, make_region_suite());
+  srunner_add_suite(sr, make_filter_suite());
   srunner_add_suite(sr, make_subscription_suite());
 
   srunner_set_log(sr, LOGFILE_PREFIX".log");