Merge lp:geis/client-arch into lp:geis

[Stephen M. Webb]

Adds selectable client-server architecture using a private DBus.

Sets the default back end to DBus and automatically falls back to XCB if the GEIS DBus server is not available.

Handles server disconnects and reconnects gracefully.

A command-line switch can be used with the geisview tool to explicitly select a back end.

Only a simple server test tool supplied, an actual utouchd GEIS server daemon will be developed separately.

[Stephen M. Webb (bregma)]

Added a trunk synch to resolve some merge conflicts.

[Chase Douglas (chasedouglas)]

A ton of code that looks very clean. I really like the changes from an aesthetic point of view. It's obvious that you put a lot of thought into how things should be structured!

Here's what I'm looking for in reviewing this code:

1. Are there any "black box" changes?
2. Does the code look clean? Does it appear to do what is stated in the merge request?
3. Does it work?
4. Are there any issues highlighted by the merge proposal description?

Note that I'm not doing a line by line review. There's too much code to review for that level of detail, and you're a trusted member of the development team.

For item 1, there are no changes in include/. Since there are no api changes, and it's assumed there are no abi changes, this criteria is fulfilled.

For item 2, the code is definitely clean. It does appear to do what is stated in the merge request in whole.

However, I don't see any change in the default backend choice, and I don't see any change in geisview that would cause it to use the new client-server backend. Am I missing something, or was this lost in a merge or rebase? I would prefer to see the default backend change to the client-server backend with a fallback to the xcb backend.

The geis server is under tools/. Is this implementation merely an example, or is it the defacto server that should be used? If it's the latter, I would prefer to move it to the top level. I feel putting it in tools/ gives the wrong impression that it is not an essential part of the project.

For item 3, I'm not ready to give an answer yet since I don't know that geisview is using the new architecture. (On IRC, Stephen explained how to test: tools/geis-server/geis-server and then tools/geisview/geisview).

For item 4, I would like to know what is left out by the statement in the merge proposal: "I think at this point (most) functionality is there." Please detail which functionality is missing?

Overall, I'm extremely happy with the changes, assuming the testing shows it works :). I look forward to merging the branch once these issues are resolved!

review: Needs Information

[Stephen M. Webb (bregma)]

On 10/13/2011 04:53 PM, Chase Douglas wrote:
> For item 1, there are no changes in include/. Since there are no api changes, and it's assumed there are no abi changes, this criteria is fulfilled.

There is a backwards-compatible API change in include/geis/geis.h with
the addition of the GEIS_INIT_UTOUCH_DBUS_BACKEND defined constant.

> For item 2, the code is definitely clean. It does appear to do what is stated in the merge request in whole.
>
> However, I don't see any change in the default backend choice, and I don't see any change in geisview that would cause it to use the new client-server backend. Am I missing something, or was this lost in a merge or rebase? I would prefer to see the default backend change to the client-server backend with a fallback to the xcb backend.

This was apparently clobbered by a last-minute merge from trunk with
manual conflict resolution. I will re-add the back end selection to the
geisview tool and make it command-line configurable, and resubmit.

Changing the default back end to the dbus-client is a little premature
until a proper daemon is set up complete with launch scripts (dbus
service?). This should wait until after the round of plugin
refactoring. Changing the default back-end is a one-line change.

> The geis server is under tools/. Is this implementation merely an example, or is it the defacto server that should be used? If it's the latter, I would prefer to move it to the top level. I feel putting it in tools/ gives the wrong impression that it is not an essential part of the project.

The program under tools is a test driver tool. Writing a proper daemon
application with attendant start and stop scripts, logging, and control
options should be a separate task not a part of the internal library
changes designed to enable that task.

All of the changes made under this merge request were made under the
original assumption that the geis server would run as a compiz plugin.
None of them are incompatible with running a standalone server and
neither do they require it.

We should consider making a "utouchd" daemon a separate project from the
utouch-geis library.

> For item 3, I'm not ready to give an answer yet since I don't know that geisview is using the new architecture. (On IRC, Stephen explained how to test: tools/geis-server/geis-server and then tools/geisview/geisview).

I will provide better instructions with the above-mentioned changes to
geisview.

> For item 4, I would like to know what is left out by the statement in the merge proposal: "I think at this point (most) functionality is there." Please detail which functionality is missing?

Yes, quite. The only known functional deficit is proper reconnection
from the client when the server has disconnected and then reconnected
again. After verbal discussions we decided to defer this functionality
to later in the interest of getting the client-server merge completed.

[Chase Douglas (chasedouglas)]

> On 10/13/2011 04:53 PM, Chase Douglas wrote:
> > For item 1, there are no changes in include/. Since there are no api
> changes, and it's assumed there are no abi changes, this criteria is
> fulfilled.
>
> There is a backwards-compatible API change in include/geis/geis.h with
> the addition of the GEIS_INIT_UTOUCH_DBUS_BACKEND defined constant.

Argh... I see now that although the unmerged revisions list below starts at commit 187, the client-arch commits really start at commit 159. I will need to re-review to include those commits as well.

> > For item 2, the code is definitely clean. It does appear to do what is
> stated in the merge request in whole.
> >
> > However, I don't see any change in the default backend choice, and I don't
> see any change in geisview that would cause it to use the new client-server
> backend. Am I missing something, or was this lost in a merge or rebase? I
> would prefer to see the default backend change to the client-server backend
> with a fallback to the xcb backend.
>
> This was apparently clobbered by a last-minute merge from trunk with
> manual conflict resolution. I will re-add the back end selection to the
> geisview tool and make it command-line configurable, and resubmit.
>
> Changing the default back end to the dbus-client is a little premature
> until a proper daemon is set up complete with launch scripts (dbus
> service?). This should wait until after the round of plugin
> refactoring. Changing the default back-end is a one-line change.

I'm not sure it's premature. The client-arch won't be used unless you have a server running, in which case we can probably assume the user knows what they are doing. The main reason I would like to switch the default is so we can test current clients of geis without having to recompile them. And, it would be switchable merely by running or killing the geis server. I will probably run the tools/ server by default in my installs just so we have some good testing.

> > The geis server is under tools/. Is this implementation merely an example,
> or is it the defacto server that should be used? If it's the latter, I would
> prefer to move it to the top level. I feel putting it in tools/ gives the
> wrong impression that it is not an essential part of the project.
>
> The program under tools is a test driver tool. Writing a proper daemon
> application with attendant start and stop scripts, logging, and control
> options should be a separate task not a part of the internal library
> changes designed to enable that task.
>
> All of the changes made under this merge request were made under the
> original assumption that the geis server would run as a compiz plugin.
> None of them are incompatible with running a standalone server and
> neither do they require it.
>
> We should consider making a "utouchd" daemon a separate project from the
> utouch-geis library.

Ok, that sounds reasonable.

> > For item 4, I would like to know what is left out by the statement in the
> merge proposal: "I think at this point (most) functionality is there." Please
> detail which functionality is missing?
>
> Yes, quite. The only known functional deficit is proper reconnection
> fr...

[Stephen M. Webb (bregma)]

On 10/13/2011 09:03 PM, Chase Douglas wrote:
>
> Argh... I see now that although the unmerged revisions list below starts at commit 187, the client-arch commits really start at commit 159. I will need to re-review to include those commits as well.

Yeah, it was a big set of changes with a number of synchs with trunk
along the way.

> I'm not sure it's premature. The client-arch won't be used unless you have a server running, in which case we can probably assume the user knows what they are doing. The main reason I would like to switch the default is so we can test current clients of geis without having to recompile them. And, it would be switchable merely by running or killing the geis server. I will probably run the tools/ server by default in my installs just so we have some good testing.

So you're suggesting autodiscovery with fallback. OK, I can do that.
Would like that as part of this merge or should we open a bug to track
that work?

Note that clients would not need any kind of recompile regardless.

>> The only known functional deficit is proper reconnection
>> from the client when the server has disconnected and then reconnected
>> again. After verbal discussions we decided to defer this functionality
>> to later in the interest of getting the client-server merge completed.
>
> Ok, that's reasonable for now. If we merge the branch like this, we should open a bug to track this missing functionality.

Absolutely.

[Chase Douglas (chasedouglas)]

I've reviewed all the changes at a high level, and I believe my original criteria 1 and 2 are satisfied. For 1, the only change is the naming of the backend macro definitions. In one sense, it's probably a good thing since it will force anyone specifying the XCB backend to rethink their decision. I'm ok with this.

Criteria 4 has been satisfied by commit 198, which resolves the only previously mentioned issue with the implementation.

The only implementation concern I have now is that if you specify the DBus backend, it will fall back to XCB. I think if the backend is specified, it should only succeed or fail. If the backend is left unspecified, we can do defaulting and failovers. After chatting with Stephen on irc, he agreed with the idea, but felt it wasn't worth the hassle for now. Our solution is to ensure documentation matches what it *should* do, and file a bug to resolve this issue for the DBus backend.

I then tried to test it out. geisview worked great with and without a server, and it reconnected to a server that went away and came back anew. Very cool. Unfortunately, geis causes the turbine.qml example in utouch-qml to crash. We need to figure out what is going on there before we merge it.

Stephen, do you know how we can test out the server with unity? Will running unity --replace after starting the server work?

[Chase Douglas (chasedouglas)]

The crash in utouch-qml was a bug in utouch-qml itself. XCB fallback works properly now.

However, utouch-qml fails to see the gesture events. I see subscriptions and gesture event generation in the server when run with GEIS_DEBUG=3, but the client doesn't see anything. Nothing is output from the client at GEIS_DEBUG=3 when the gestures are performed. This also happens when restarting unity while the server is running.

[lp:geis/client-arch]

199. By Stephen M. Webb on 2011-10-18

Added full support for filtering by gesture class name with DBus server back end.

[Stephen M. Webb (bregma)]

Pushed in an additional commit that adds full support for filtering by gesture class name when using the DBus server back end.

[Chase Douglas (chasedouglas)]

Unity and utouch-qml now work. The only bug I see left to deal with is a client segfault when the client is closed. This only occurs when the dbus server is used. The xcb interface doesn't crash.

[lp:geis/client-arch]

200. By Stephen M. Webb on 2011-10-18

Fixed a couple of invalid deallocations on exit.

[Stephen M. Webb (bregma)]

Pushed an additional commit to repair a couple of miplaced free()s on teardown.

[Chase Douglas (chasedouglas)]

I no longer receive a segfault on client close. This satisfies all my criteria.

I'm approving the merge proposal. Please open a bug about the backend selection default issue.

Great work!

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2011-04-18 13:48:35 +0000
+++ .bzrignore	2011-10-18 19:34:23 +0000
@@ -6,13 +6,13 @@
 **/xcb_gesture.[ch]
 *.deps
 *.libs
+*.log
 *Makefile.in
 aclocal.m4
 autom4te.cache
 config.*
 configure
 debian/*.debhelper
-debian/*.log
 debian/*.substvars
 debian/files
 debian/libutouch-geis-dev
@@ -28,8 +28,13 @@
 examples/geis2
 geis_config.*
 libtool
+libtool.m4
 libutouch-geis.pc
+ltoptions.m4
+ltversion.m4
+lt~obsolete.m4
 stamp-*
+TAGS
 testsuite/geis1/*.log
 testsuite/geis1/check_geis1_api
 testsuite/geis2/*.log
@@ -38,3 +43,4 @@
 testsuite/libutouch-geis/*.log
 testsuite/libutouch-geis/*.xml
 testsuite/libutouch-geis/check_geis2_internals
+tools/geis-server/geis-server

=== modified file 'Makefile.am'
--- Makefile.am	2011-04-18 13:47:57 +0000
+++ Makefile.am	2011-10-18 19:34:23 +0000
@@ -20,6 +20,7 @@
 
 
 ACLOCAL_MFLAGS = -I m4
+AM_MAKEFLAGS = --no-print-directory
 
 SUBDIRS = include libs libutouch-geis testsuite python tools examples doc
 

=== modified file 'configure.ac'
--- configure.ac	2011-08-31 19:53:52 +0000
+++ configure.ac	2011-10-18 19:34:23 +0000
@@ -95,12 +95,14 @@
                  doc/Makefile
                  include/Makefile
                  libs/Makefile
+                 libs/geis-dbus/Makefile
                  libs/xcb/Makefile
                  libs/xcb/xcb_gesture.xml
                  libutouch-geis/Makefile
                  libutouch-geis/backend/Makefile
                  libutouch-geis/backend/test_fixture/Makefile
                  libutouch-geis/backend/xcb/Makefile
+                 libutouch-geis/backend/dbus/Makefile
                  libutouch-geis/server/Makefile
                  testsuite/Makefile
                  testsuite/libutouch-geis/Makefile
@@ -110,5 +112,6 @@
                  examples/Makefile
                  python/Makefile
                  tools/Makefile
-                 tools/geisview/Makefile])
+                 tools/geisview/Makefile
+                 tools/geis-server/Makefile])
 AC_OUTPUT

=== modified file 'include/geis/geis.h'
--- include/geis/geis.h	2011-08-17 04:26:54 +0000
+++ include/geis/geis.h	2011-10-18 19:34:23 +0000
@@ -459,18 +459,21 @@
  * @name Vendor-defined Initialization Arguments
  *
  * @par
- * These initialization arguments are not a part of te GEIS specification and
+ * These initialization arguments are not a part of the GEIS specification and
  * may change.
  *
  * @{
  *
- * @def GEIS_INIT_UTOUCH_MOCK_ENGINE
- *
- * @def GEIS_INIT_UTOUCH_XCB
+ * @def GEIS_INIT_UTOUCH_MOCK_BACKEND
+ *
+ * @def GEIS_INIT_UTOUCH_DBUS_BACKEND
+ *
+ * @def GEIS_INIT_UTOUCH_XCB_BACKEND
  */
 
-#define GEIS_INIT_UTOUCH_MOCK_ENGINE "com.canonical.utouch.mock.engine"
-#define GEIS_INIT_UTOUCH_XCB         "com.canonical.utouch.xcb"
+#define GEIS_INIT_UTOUCH_MOCK_BACKEND "com.canonical.utouch.backend.mock"
+#define GEIS_INIT_UTOUCH_DBUS_BACKEND "com.canonical.utouch.backend.dbus"
+#define GEIS_INIT_UTOUCH_XCB_BACKEND  "com.canonical.utouch.backend.xcb"
 
 /* @} */
 
@@ -1302,7 +1305,7 @@
  *
  * @param[in] gesture_class  The gesture class object.
  *
- * The reference count of teh object is decremented and, if it reaches zero, the
+ * The reference count of the object is decremented and, if it reaches zero, the
  * object is destroyed.
  */
 GEIS_API void geis_gesture_class_unref(GeisGestureClass gesture_class);
@@ -1332,7 +1335,7 @@
 GEIS_API GeisSize geis_gesture_class_attr_count(GeisGestureClass gesture_class);
 
 /**
- * Gets the indicated attribute of teh gesture class.
+ * Gets the indicated attribute of the gesture class.
  * @memberof GeisGestureClass
  *
  * @param[in] gesture_class  The gesture class object.

=== modified file 'libs/Makefile.am'
--- libs/Makefile.am	2011-01-17 15:03:18 +0000
+++ libs/Makefile.am	2011-10-18 19:34:23 +0000
@@ -19,5 +19,5 @@
 # 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 #
 
-SUBDIRS = xcb
+SUBDIRS = xcb geis-dbus
 

=== added directory 'libs/geis-dbus'
=== added file 'libs/geis-dbus/Makefile.am'
--- libs/geis-dbus/Makefile.am	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/Makefile.am	2011-10-18 19:34:23 +0000
@@ -0,0 +1,41 @@
+#
+# @file libs/geis-dbus/Makefile.am
+# @brief automake recipe for the uTouch GEIS v2.0 DBus helper library
+#
+# Copyright 2011 Canonical, Ltd.
+#
+# This file is part of the utouch-geis library. 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
+#
+
+noinst_LTLIBRARIES = libgeis-dbus.la
+
+dist_libgeis_dbus_la_SOURCES = \
+	geis_dbus.h \
+	geis_dbus_attr.h          geis_dbus_attr.c \
+	geis_dbus_class.h         geis_dbus_class.c \
+	geis_dbus_device.h        geis_dbus_device.c \
+	geis_dbus_dispatcher.h    geis_dbus_dispatcher.c \
+	geis_dbus_gesture_event.h geis_dbus_gesture_event.c \
+	geis_dbus_region.h        geis_dbus_region.c \
+	geis_dbus_subscription.h  geis_dbus_subscription.c 
+
+libgeis_dbus_la_CPPFLAGS = \
+	-I$(top_srcdir)/libutouch-geis \
+	$(DBUS_CFLAGS)
+
+libgeis_dbus_la_LIBADD = \
+	$(DBUS_LIBS)
+
+

=== renamed file 'libutouch-geis/server/geis_dbus.h' => 'libs/geis-dbus/geis_dbus.h'
--- libutouch-geis/server/geis_dbus.h	2011-01-31 12:25:35 +0000
+++ libs/geis-dbus/geis_dbus.h	2011-10-18 19:34:23 +0000
@@ -1,4 +1,9 @@
 /**
+ * @file geis_dbus.h
+ * @brief Common definitions for the GEIS DBus module(s).
+ */
+
+/*
  * Copyright 2011 Canonical Ltd.
  *
  * This library is free software; you can redistribute it and/or modify it under
@@ -11,12 +16,36 @@
  * 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
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-
-
-#define GEIS_DBUS_BUS_NAME "com.canonical.utouch"
-#define GEIS_REMOTE_FUNCTION "getAddress"
-
+#ifndef GEIS_DBUS_H_
+#define GEIS_DBUS_H_
+
+#define GEIS_DBUS_SERVICE_PATH        "/com/canonical/utouch/Geis"
+#define GEIS_DBUS_SERVICE_INTERFACE   "com.canonical.utouch.Geis"
+
+#define GEIS_DBUS_GET_SERVER_ADDRESS  "GetServerAddress"
+
+#define GEIS_DBUS_INIT_COMPLETE       "InitComplete"
+
+#define GEIS_DBUS_DEVICE_AVAILABLE    "DeviceAvailable"
+#define GEIS_DBUS_DEVICE_UNAVAILABLE  "DeviceUnavailable"
+
+#define GEIS_DBUS_CLASS_AVAILABLE     "ClassAvailable"
+#define GEIS_DBUS_CLASS_UNAVAILABLE   "ClassUnavailable"
+
+#define GEIS_DBUS_REGION_AVAILABLE    "RegionAvailable"
+#define GEIS_DBUS_REGION_UNAVAILABLE  "RegionUnavailable"
+
+#define GEIS_DBUS_SUBSCRIPTION_CREATE     "SubscriptionCreate"
+#define GEIS_DBUS_SUBSCRIPTION_ACTIVATE   "SubscriptionActivate"
+#define GEIS_DBUS_SUBSCRIPTION_DEACTIVATE "SubscriptionDeactivate"
+#define GEIS_DBUS_SUBSCRIPTION_DESTROY    "SubscriptionDestroy"
+
+#define GEIS_DBUS_GESTURE_EVENT       "GestureEvent"
+
+#define GEIS_DBUS_ERROR_SUBSCRIPTION_FAIL GEIS_DBUS_SERVICE_INTERFACE \
+                                          ".SubscriptionFail"
+
+#endif /* GEIS_DBUS_H_ */

=== added file 'libs/geis-dbus/geis_dbus_attr.c'
--- libs/geis-dbus/geis_dbus_attr.c	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_attr.c	2011-10-18 19:34:23 +0000
@@ -0,0 +1,178 @@
+/**
+ * @file geis_dbus_attr.c
+ * @brief Implementation of the GEIS DBus attr transport.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "geis_config.h"
+#include "geis_dbus_attr.h"
+
+#include "geis_attr.h"
+#include "geis_logging.h"
+
+
+/*
+ * Marshalls a single GEIS attr to an open DBus message container iterator.
+ */
+void 
+geis_dbus_attr_marshall(GeisAttr attr, DBusMessageIter *iter)
+{
+  DBusMessageIter dict_iter;
+  GeisString attr_name = geis_attr_name(attr);
+
+  dbus_message_iter_open_container(iter,
+                                   DBUS_TYPE_STRUCT,
+                                   NULL,
+                                   &dict_iter);
+  dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &attr_name);
+  switch (geis_attr_type(attr))
+  {
+    case GEIS_ATTR_TYPE_BOOLEAN:
+    {
+      DBusMessageIter variant_iter;
+      dbus_bool_t val = geis_attr_value_to_boolean(attr);
+      dbus_message_iter_open_container(&dict_iter,
+                                       DBUS_TYPE_VARIANT,
+                                       DBUS_TYPE_BOOLEAN_AS_STRING,
+                                       &variant_iter);
+      dbus_message_iter_append_basic(&variant_iter, DBUS_TYPE_BOOLEAN, &val);
+      dbus_message_iter_close_container(&dict_iter, &variant_iter);
+      break;
+    }
+
+    case GEIS_ATTR_TYPE_FLOAT:
+    {
+      DBusMessageIter variant_iter;
+      double val = geis_attr_value_to_float(attr);
+      dbus_message_iter_open_container(&dict_iter,
+                                       DBUS_TYPE_VARIANT,
+                                       DBUS_TYPE_DOUBLE_AS_STRING,
+                                       &variant_iter);
+      dbus_message_iter_append_basic(&variant_iter, DBUS_TYPE_DOUBLE, &val);
+      dbus_message_iter_close_container(&dict_iter, &variant_iter);
+      break;
+    }
+
+    case GEIS_ATTR_TYPE_INTEGER:
+    {
+      DBusMessageIter variant_iter;
+      dbus_int32_t val = geis_attr_value_to_integer(attr);
+      dbus_message_iter_open_container(&dict_iter,
+                                       DBUS_TYPE_VARIANT,
+                                       DBUS_TYPE_INT32_AS_STRING,
+                                       &variant_iter);
+      dbus_message_iter_append_basic(&variant_iter, DBUS_TYPE_INT32, &val);
+      dbus_message_iter_close_container(&dict_iter, &variant_iter);
+      break;
+    }
+
+    case GEIS_ATTR_TYPE_STRING:
+    {
+      DBusMessageIter variant_iter;
+      GeisString val = geis_attr_value_to_string(attr);
+      dbus_message_iter_open_container(&dict_iter,
+                                       DBUS_TYPE_VARIANT,
+                                       DBUS_TYPE_STRING_AS_STRING,
+                                       &variant_iter);
+      dbus_message_iter_append_basic(&variant_iter, DBUS_TYPE_STRING, &val);
+      dbus_message_iter_close_container(&dict_iter, &variant_iter);
+      break;
+    }
+
+    default:
+      geis_error("invalid attribute type for DBus");
+  }
+  dbus_message_iter_close_container(iter, &dict_iter);
+}
+
+
+/*
+ * Unmarshalls a single GEIS attr from a DBus message iterator.
+ */
+GeisAttr
+geis_dbus_attr_unmarshall(DBusMessageIter *iter)
+{
+  GeisAttr attr = NULL;
+  DBusMessageIter dict_iter;
+
+  dbus_message_iter_recurse(iter, &dict_iter);
+  int dtype = dbus_message_iter_get_arg_type(&dict_iter);
+  if (dtype != DBUS_TYPE_STRING)
+  {
+    geis_error("error getting attr name from DBus message");
+    goto final_exit;
+  }
+
+  char *attr_name;
+  dbus_message_iter_get_basic(&dict_iter, &attr_name);
+
+  dbus_message_iter_next(&dict_iter);
+  dtype = dbus_message_iter_get_arg_type(&dict_iter);
+  if (dtype != DBUS_TYPE_VARIANT)
+  {
+    geis_error("error getting attr variant from DBus message");
+    goto final_exit;
+  }
+
+  DBusMessageIter variant_iter;
+  dbus_message_iter_recurse(&dict_iter, &variant_iter);
+  int vtype = dbus_message_iter_get_arg_type(&variant_iter);
+  switch (vtype)
+  {
+    case DBUS_TYPE_BOOLEAN:
+    {
+      dbus_bool_t val;
+      dbus_message_iter_get_basic(&variant_iter, &val);
+      attr = geis_attr_new(attr_name, GEIS_ATTR_TYPE_BOOLEAN, &val);
+      break;
+    }
+
+    case DBUS_TYPE_DOUBLE:
+    {
+      double dval;
+      dbus_message_iter_get_basic(&variant_iter, &dval);
+      float fval = dval;
+      attr = geis_attr_new(attr_name, GEIS_ATTR_TYPE_FLOAT, &fval);
+      break;
+    }
+
+    case DBUS_TYPE_INT32:
+    {
+      dbus_int32_t val;
+      dbus_message_iter_get_basic(&variant_iter, &val);
+      attr = geis_attr_new(attr_name, GEIS_ATTR_TYPE_INTEGER, &val);
+      break;
+    }
+
+    case DBUS_TYPE_STRING:
+    {
+      GeisString val;
+      dbus_message_iter_get_basic(&variant_iter, &val);
+      attr = geis_attr_new(attr_name, GEIS_ATTR_TYPE_STRING, (void *)val);
+      break;
+    }
+
+    default:
+      geis_error("unexpected attr data type from DBus");
+      break;
+  }
+
+final_exit:
+  return attr;
+}
+

=== added file 'libs/geis-dbus/geis_dbus_attr.h'
--- libs/geis-dbus/geis_dbus_attr.h	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_attr.h	2011-10-18 19:34:23 +0000
@@ -0,0 +1,57 @@
+/**
+ * @file geis_dbus_attr.h
+ * @brief Interface for the GEIS DBus attr transport.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef GEIS_DBUS_ATTR_H_
+#define GEIS_DBUS_ATTR_H_
+
+#include <dbus/dbus.h>
+#include "geis/geis.h"
+
+
+/**
+ * The DBus type signature for a GEIS attrlist entry.
+ */
+#define GEIS_DBUS_TYPE_SIGNATURE_ATTR \
+               DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
+               DBUS_TYPE_STRING_AS_STRING \
+               DBUS_TYPE_VARIANT_AS_STRING \
+               DBUS_STRUCT_END_CHAR_AS_STRING
+
+/**
+ * Marshalls a single GEIS attr to an open DBus message container iterator.
+ *
+ * @param[in] attr  The GEIS attr.
+ * @param[in] iter  The DBus message iterator.
+ */
+void 
+geis_dbus_attr_marshall(GeisAttr attr, DBusMessageIter *iter);
+
+/**
+ * Unmarshalls a single GEIS attr from a DBus message iterator.
+ *
+ * @param[in] iter  The DBus message iterator.
+ *
+ * @returns a GEIS attribute or NULL on error.
+ */
+GeisAttr
+geis_dbus_attr_unmarshall(DBusMessageIter *iter);
+
+#endif /* GEIS_DBUS_ATTR_H_ */

=== added file 'libs/geis-dbus/geis_dbus_class.c'
--- libs/geis-dbus/geis_dbus_class.c	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_class.c	2011-10-18 19:34:23 +0000
@@ -0,0 +1,126 @@
+/**
+ * @file geis_dbus_gesture_class.c
+ * @brief Implementations of the GEIS DBus gesture_class transport.
+ */
+
+/*
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#include "geis_config.h"
+#include "geis_dbus_class.h"
+
+#include "geis_dbus.h"
+#include "geis_dbus_attr.h"
+#include "geis_class.h"
+#include "geis_logging.h"
+
+
+/*
+ * Creates a Dbus "gesture_class available" message from a GEIS gesture_class.
+ *
+ * The Wire protocol for this message is class_id and class_name followed by
+ * the list of class attributes.
+ */
+DBusMessage *
+geis_dbus_class_available_message_from_class(GeisGestureClass gesture_class)
+{
+  DBusMessage *message = dbus_message_new_signal(GEIS_DBUS_SERVICE_PATH,
+                                                 GEIS_DBUS_SERVICE_INTERFACE,
+                                                 GEIS_DBUS_CLASS_AVAILABLE);
+  DBusMessageIter iter;
+  dbus_message_iter_init_append(message, &iter);
+
+  dbus_int32_t gesture_class_id = geis_gesture_class_id(gesture_class);
+  dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &gesture_class_id);
+
+  const char *gesture_class_name = geis_gesture_class_name(gesture_class);
+  dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &gesture_class_name);
+
+  DBusMessageIter array_iter;
+  dbus_message_iter_open_container(&iter,
+                                   DBUS_TYPE_ARRAY,
+                                   GEIS_DBUS_TYPE_SIGNATURE_ATTR,
+                                   &array_iter);
+  GeisSize attr_count = geis_gesture_class_attr_count(gesture_class);
+  for (GeisSize i = 0; i < attr_count; ++i)
+  {
+    geis_dbus_attr_marshall(geis_gesture_class_attr(gesture_class, i),
+                            &array_iter);
+  }
+  dbus_message_iter_close_container(&iter, &array_iter);
+  return message;
+}
+
+
+/*
+ * Creates GEIS gesture_class from a DBus "gesture_class available" message.
+ */
+GeisGestureClass
+geis_dbus_class_class_from_available_message(DBusMessage *message)
+{
+  GeisGestureClass gesture_class = NULL;
+  DBusMessageIter iter;
+  dbus_message_iter_init(message, &iter);
+
+  int type = dbus_message_iter_get_arg_type(&iter);
+  if (type != DBUS_TYPE_INT32)
+  {
+    geis_error("error getting gesture_class ID from DBus message.");
+    goto final_exit;
+  }
+  dbus_int32_t gesture_class_id;
+  dbus_message_iter_get_basic(&iter, &gesture_class_id);
+
+  dbus_message_iter_next(&iter);
+  type = dbus_message_iter_get_arg_type(&iter);
+  if (type != DBUS_TYPE_STRING)
+  {
+    geis_error("error getting gesture_class name from DBus message.");
+    goto final_exit;
+  }
+
+  char *gesture_class_name;
+  dbus_message_iter_get_basic(&iter, &gesture_class_name);
+  gesture_class = geis_gesture_class_new(gesture_class_name, gesture_class_id);
+
+  dbus_message_iter_next(&iter);
+  type = dbus_message_iter_get_arg_type(&iter);
+  if (type != DBUS_TYPE_ARRAY)
+  {
+    geis_error("error getting gesture_class attr list from DBus message.");
+    goto final_exit;
+  }
+
+  DBusMessageIter array_iter;
+  dbus_message_iter_recurse(&iter, &array_iter);
+  int atype = dbus_message_iter_get_arg_type(&array_iter);
+  while (atype == DBUS_TYPE_DICT_ENTRY)
+  {
+    GeisAttr attr = geis_dbus_attr_unmarshall(&array_iter);
+    if (attr)
+    {
+      geis_gesture_class_add_attr(gesture_class, attr);
+    }
+
+    dbus_message_iter_next(&array_iter);
+    atype = dbus_message_iter_get_arg_type(&array_iter);
+  }
+
+final_exit:
+  return gesture_class;
+}
+
+

=== added file 'libs/geis-dbus/geis_dbus_class.h'
--- libs/geis-dbus/geis_dbus_class.h	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_class.h	2011-10-18 19:34:23 +0000
@@ -0,0 +1,45 @@
+/**
+ * @file geis_dbus_class.h
+ * @brief Interface for the GEIS DBus gesture class transport.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef GEIS_DBUS_GESTURE_CLASS_H_
+#define GEIS_DBUS_GESTURE_CLASS_H_
+
+#include <dbus/dbus.h>
+#include "geis/geis.h"
+
+
+/**
+ * Creates a Dbus "class available" message from a GEIS class.
+ *
+ * @param[in] class  A GEIS gesture class.
+ */
+DBusMessage *
+geis_dbus_class_available_message_from_class(GeisGestureClass gesture_class);
+
+/**
+ * Creates GEIS class from a DBus "class available" message.
+ *
+ * @param[in] message  A DBus message.
+ */
+GeisGestureClass
+geis_dbus_class_class_from_available_message(DBusMessage *message);
+
+#endif /* GEIS_DBUS_GESTURE_CLASS_H_ */

=== added file 'libs/geis-dbus/geis_dbus_device.c'
--- libs/geis-dbus/geis_dbus_device.c	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_device.c	2011-10-18 19:34:23 +0000
@@ -0,0 +1,152 @@
+/**
+ * @file geis_dbus_device.c
+ * @brief Implementations of the GEIS DBus device transport.
+ */
+
+/*
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#include "geis_config.h"
+#include "geis_dbus_device.h"
+
+#include "geis_dbus.h"
+#include "geis_dbus_attr.h"
+#include "geis_device.h"
+#include "geis_logging.h"
+
+
+/*
+ * Creates a Dbus "device available" message from a GEIS device.
+ *
+ * The Wire protocol for this message is device_id and device_name followed by
+ * the list of device attributes.
+ */
+DBusMessage *
+geis_dbus_device_available_message_from_device(GeisDevice device)
+{
+  DBusMessage *message = dbus_message_new_signal(GEIS_DBUS_SERVICE_PATH,
+                                                 GEIS_DBUS_SERVICE_INTERFACE,
+                                                 GEIS_DBUS_DEVICE_AVAILABLE);
+  DBusMessageIter iter;
+  dbus_message_iter_init_append(message, &iter);
+
+  dbus_int32_t device_id = geis_device_id(device);
+  dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &device_id);
+
+  const char *device_name = geis_device_name(device);
+  dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &device_name);
+
+  DBusMessageIter array_iter;
+  dbus_message_iter_open_container(&iter,
+                                   DBUS_TYPE_ARRAY,
+                                   GEIS_DBUS_TYPE_SIGNATURE_ATTR,
+                                   &array_iter);
+  GeisSize attr_count = geis_device_attr_count(device);
+  for (GeisSize i = 0; i < attr_count; ++i)
+  {
+    geis_dbus_attr_marshall(geis_device_attr(device, i), &array_iter);
+  }
+  dbus_message_iter_close_container(&iter, &array_iter);
+  return message;
+}
+
+
+/*
+ * Creates GEIS device from a DBus "device available" message.
+ */
+GeisDevice
+geis_dbus_device_device_from_available_message(DBusMessage *message)
+{
+  geis_debug("begins");
+  GeisDevice device = NULL;
+  DBusMessageIter iter;
+  dbus_message_iter_init(message, &iter);
+
+  int type = dbus_message_iter_get_arg_type(&iter);
+  if (type != DBUS_TYPE_INT32)
+  {
+    geis_error("error getting device ID from DBus message.");
+    goto final_exit;
+  }
+  dbus_int32_t device_id;
+  dbus_message_iter_get_basic(&iter, &device_id);
+
+  dbus_message_iter_next(&iter);
+  type = dbus_message_iter_get_arg_type(&iter);
+  if (type != DBUS_TYPE_STRING)
+  {
+    geis_error("error getting device name from DBus message.");
+    goto final_exit;
+  }
+
+  char *device_name;
+  dbus_message_iter_get_basic(&iter, &device_name);
+  device = geis_device_new(device_name, device_id);
+
+  dbus_message_iter_next(&iter);
+  type = dbus_message_iter_get_arg_type(&iter);
+  if (type != DBUS_TYPE_ARRAY)
+  {
+    geis_error("error getting device attr list from DBus message.");
+    goto final_exit;
+  }
+
+  DBusMessageIter array_iter;
+  dbus_message_iter_recurse(&iter, &array_iter);
+  int atype = dbus_message_iter_get_arg_type(&array_iter);
+  while (atype == DBUS_TYPE_DICT_ENTRY)
+  {
+    GeisAttr attr = geis_dbus_attr_unmarshall(&array_iter);
+    if (attr)
+    {
+      geis_device_add_attr(device, attr);
+    }
+
+    dbus_message_iter_next(&array_iter);
+    atype = dbus_message_iter_get_arg_type(&array_iter);
+  }
+
+final_exit:
+  geis_debug("ends");
+  return device;
+}
+
+
+/*
+ * Creates a Dbus "device unavailable" message from a GEIS device.
+ */
+DBusMessage *
+geis_dbus_device_unavailable_message_from_device(GeisDevice device GEIS_UNUSED)
+{
+  geis_debug("begins");
+  DBusMessage *message = NULL;
+  geis_debug("ends");
+  return message;
+}
+
+
+/*
+ * Creates GEIS device from a DBus "device unavailable" message.
+ */
+GeisDevice
+geis_dbus_device_device_from_unavailable_message(DBusMessage *message GEIS_UNUSED)
+{
+  geis_debug("begins");
+  GeisDevice device = NULL;
+  geis_debug("ends");
+  return device;
+}
+

=== added file 'libs/geis-dbus/geis_dbus_device.h'
--- libs/geis-dbus/geis_dbus_device.h	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_device.h	2011-10-18 19:34:23 +0000
@@ -0,0 +1,61 @@
+/**
+ * @file geis_dbus_device.h
+ * @brief Interface for the GEIS DBus device transport.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef GEIS_DBUS_DEVICE_H_
+#define GEIS_DBUS_DEVICE_H_
+
+#include <dbus/dbus.h>
+#include "geis/geis.h"
+
+
+/**
+ * Creates a Dbus "device available" message from a GEIS device.
+ *
+ * @param[in] device  A GEIS device.
+ */
+DBusMessage *
+geis_dbus_device_available_message_from_device(GeisDevice device);
+
+/**
+ * Creates GEIS device from a DBus "device available" message.
+ *
+ * @param[in] message  A DBus message.
+ */
+GeisDevice
+geis_dbus_device_device_from_available_message(DBusMessage *message);
+
+/**
+ * Creates a Dbus "device unavailable" message from a GEIS device.
+ *
+ * @param[in] device  A GEIS device.
+ */
+DBusMessage *
+geis_dbus_device_unavailable_message_from_device(GeisDevice device);
+
+/**
+ * Creates GEIS device from a DBus "device unavailable" message.
+ *
+ * @param[in] message  A DBus message.
+ */
+GeisDevice
+geis_dbus_device_device_from_unavailable_message(DBusMessage *message);
+
+#endif /* GEIS_DBUS_DEVICE_H_ */

=== added file 'libs/geis-dbus/geis_dbus_dispatcher.c'
--- libs/geis-dbus/geis_dbus_dispatcher.c	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_dispatcher.c	2011-10-18 19:34:23 +0000
@@ -0,0 +1,486 @@
+/**
+ * @file geis_dbus_dispatcher.c
+ * @brief Implementation of the GEIS DBus dispatcher.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "geis_config.h"
+#include "geis_dbus_dispatcher.h"
+
+#include "geis_logging.h"
+#include "geis_private.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+
+typedef struct GeisDBusWatch *GeisDBusWatch;
+typedef struct GeisDBusWatchBag *GeisDBusWatchBag;
+
+/*
+ * Connects a DBusWatch back to a DBusConnection.
+ *
+ * This is an intrusive linked list node.  See GeisDBusWatchBag.
+ */
+struct GeisDBusWatch 
+{
+  DBusConnection     *connection;
+  DBusWatch          *watch;
+  GeisDBusWatch       next;
+};
+
+
+/*
+ * Maps file descriptors to watches and connections.
+ *
+ * A DBusWatch is assciated with a single file descriptor, but each file
+ * descriptor may be associated with more than one DBusWatch. 
+ *
+ * Each DBusConnection has one or more DBusWatch.  The DBusWatches are passed
+ * around without reference to the connection itself, but we often need the
+ * connection when all we have is the watch.
+ *
+ * To make things more complex, the DBusServer does not have a connection
+ * associated with its watches.
+ *
+ * This is a linked list with a free pool.
+ */
+struct GeisDBusWatchBag
+{
+  GeisDBusWatch front;
+  GeisDBusWatch back;
+  GeisDBusWatch pool;
+};
+
+static const int   _geis_dbus_watch_bag_initial_size = 4;
+
+
+struct GeisDBusDispatcher
+{
+  Geis             geis;
+  GeisDBusWatchBag watches;
+};
+
+
+/*
+ * Creates a new empty collection of watches.
+ *
+ * The pool is primed with a few empty watches to save time later, on the
+ * assumption that if you're creating a bag you're going to use it.
+ */
+static GeisDBusWatchBag 
+_geis_dbus_watch_bag_new()
+{
+  GeisDBusWatchBag bag = calloc(1, sizeof(struct GeisDBusWatchBag));
+  if (!bag)
+  {
+    geis_error("error allocating GeisDBusWatchBag");
+    goto final_exit;
+  }
+
+  /* Prime the free pool. */
+  for (int i = 0; i < _geis_dbus_watch_bag_initial_size; ++i)
+  {
+    GeisDBusWatch gdbw = calloc(1, sizeof(struct GeisDBusWatch));
+    if (!gdbw)
+    {
+      geis_error("error allocating GeisDBusWatchBag");
+      goto unwind_pool;
+    }
+    gdbw->next = bag->pool;
+    bag->pool = gdbw;
+  }
+  goto final_exit;
+
+unwind_pool:
+final_exit:
+  return bag;
+}
+
+
+/*
+ * Destroys a collection of watches.
+ *
+ * @param[in] bag  A collection of %GeisDBusWatches.
+ *
+ * There should be no need to unref any of the contents of the bag, they can
+ * just be freed without consequence.
+ */
+static void 
+_geis_dbus_watch_bag_delete(GeisDBusWatchBag bag)
+{
+  /* Free the pool. */
+  GeisDBusWatch gdbw = bag->pool;
+  while (gdbw)
+  {
+    GeisDBusWatch next = gdbw->next;
+    free(gdbw);
+    gdbw = next;
+  }
+
+  /* Free the in-use watches. */
+  gdbw = bag->front;
+  while (gdbw)
+  {
+    GeisDBusWatch next = gdbw->next;
+    free(gdbw);
+    gdbw = next;
+  }
+
+  free(bag);
+}
+
+
+/*
+ * Gets an allocated watch from the bag.
+ *
+ * @param[in] bag        A collection of %GeisDBusWatches.
+ * @param[in] connection A DBusConnection.
+ * @param[in] watch      A DBusWatch.
+ *
+ * A factory function to create a new watch in the collection and return a
+ * pointer to it.
+ */
+static GeisDBusWatch
+_geis_dbus_watch_bag_alloc_watch(GeisDBusWatchBag    bag,
+                                 DBusConnection     *connection,
+                                 DBusWatch          *watch)
+{
+  GeisDBusWatch gdbw = NULL;
+
+  /* Either pull a free watch off the pool or allocate a new one. */
+  if (bag->pool)
+  {
+    gdbw = bag->pool;
+    bag->pool = bag->pool->next;
+  }
+  else
+  {
+    gdbw = calloc(1, sizeof(struct GeisDBusWatch));
+    if (!gdbw)
+    {
+      geis_error("error allocating GeisDBusWatchBag");
+      goto final_exit;
+    }
+  }
+
+  /* Fill in the data bits. */
+  gdbw->connection = connection;
+  gdbw->watch = watch;
+  gdbw->next = NULL;
+
+  /* Add it to the in-use list. */
+  if (!bag->front)
+  {
+    bag->front = gdbw;
+  }
+  if (bag->back)
+  {
+    bag->back->next = gdbw;
+  }
+  bag->back = gdbw;
+
+final_exit:
+  return gdbw;
+}
+
+
+/*
+ * Removes a watch from a collection of such beasts.
+ *
+ * @param[in] bag      A collection of %GeisDBusWatches.
+ * @param[in] watch    The watch to remove.
+ */
+static void
+_geis_dbus_watch_bag_remove_watch(GeisDBusWatchBag    bag,
+                                  DBusWatch          *watch)
+{
+  for (GeisDBusWatch gdbw = bag->front, prev = NULL; gdbw; gdbw = gdbw->next)
+  {
+    if (gdbw->watch == watch)
+    {
+      if (gdbw == bag->front)
+      {
+	bag->front = gdbw->next;
+      }
+      else
+      {
+	prev->next = gdbw->next;
+      }
+      if (gdbw == bag->back)
+      {
+	bag->back = prev;
+      }
+
+      gdbw->next = bag->pool;
+      bag->pool = gdbw;
+
+      break;
+    }
+    prev = gdbw;
+  }
+}
+
+
+/*
+ * Indicates if a file descriptor is already held in the watch bag.
+ *
+ * @param[in]  bag    A collection of %GeisDBusWatches.
+ * @param[in]  fd     A file descriptor.
+ * @param[out] flags  The DBus watch flags for any enabled watches found.
+ *
+ * @returns zero if the file descriptor is not in the bag, non-zero otherwise.
+ */
+static int
+_geis_dbus_watch_bag_has_fd(GeisDBusWatchBag bag, int fd, unsigned int *flags)
+{
+  int has_fd = 0;
+  for (GeisDBusWatch gdbw = bag->front; gdbw; gdbw = gdbw->next)
+  {
+    if (dbus_watch_get_unix_fd(gdbw->watch) == fd)
+    {
+      has_fd |= ~0;
+      if (dbus_watch_get_enabled(gdbw->watch))
+      {
+	*flags |= dbus_watch_get_flags(gdbw->watch);
+      }
+    }
+  }
+  return has_fd;
+}
+
+
+/*
+ * Finds a DBusWatch in the bag that matches the fd and current activity.
+ *
+ * @param[in] bag      A collection of %GeisDBusWatches.
+ * @param[in] fd       The file descriptor on which an activity has been detected.
+ * @param[in] activity The bitmask of currently detected activity on the fd.
+ *
+ * A DBusWatch will match if it has the same file descriptor and is watching for
+ * (one of) the activity(ies) that has just occurred.
+ *
+ * Note that writers are implicitly looking for hangups or errors but the DBus
+ * library goes into an infinite loop when a hangup has occurred no a write
+ * watch, so defer that to a read watch.
+ *
+ * @returns a GeisDBusWatch or NULL if no matching watch was found.
+ */
+static GeisDBusWatch
+_geis_dbus_watch_bag_find_fd_activity(GeisDBusWatchBag               bag,
+                                      int                            fd,
+                                      GeisBackendMultiplexorActivity activity)
+{
+  GeisDBusWatch gdbw = NULL;
+  for (gdbw = bag->front; gdbw; gdbw = gdbw->next)
+  {
+    if (dbus_watch_get_unix_fd(gdbw->watch) == fd)
+    {
+      unsigned int flags = dbus_watch_get_flags(gdbw->watch);
+      if ((activity & GEIS_BE_MX_READ_AVAILABLE && flags & DBUS_WATCH_READABLE)
+       || (activity & GEIS_BE_MX_WRITE_AVAILABLE && flags & DBUS_WATCH_WRITABLE)
+       || (activity & GEIS_BE_MX_HANGUP_DETECTED && flags & DBUS_WATCH_READABLE)
+       || (activity & GEIS_BE_MX_ERROR_DETECTED))
+      {
+	break;
+      }
+    }
+  }
+  return gdbw;
+}
+
+
+/*
+ * A callback function passed to the Geis multiplexor.
+ *
+ * @param[in] fd       The file descriptor on which an activity has been detected.
+ * @param[in] activity The bitmask of currently detected activity on the fd.
+ * @param[in] context  The %GeisDBusDispatcher passed through the multiplexor.
+ *
+ * This callback gets invoked whenever a requested activity is detected on a
+ * regostered DBusWatch file descriptor.  It translates the GEIS Multiplexor
+ * activity to DBus activity.
+ */
+static void
+_geis_dbus_dispatcher_callback(int                             fd,
+                               GeisBackendMultiplexorActivity  activity,
+                               void                           *context)
+{
+  GeisDBusDispatcher dispatcher = (GeisDBusDispatcher)context;
+  GeisDBusWatch gdb = _geis_dbus_watch_bag_find_fd_activity(dispatcher->watches,
+                                                            fd,
+                                                            activity);
+  if (gdb)
+  {
+    /* Translate GEIS multiplexor activity to DBus watch flags. */
+    unsigned int flags = 0;
+    if (activity & GEIS_BE_MX_READ_AVAILABLE)  flags |= DBUS_WATCH_READABLE;
+    if (activity & GEIS_BE_MX_WRITE_AVAILABLE) flags |= DBUS_WATCH_WRITABLE;
+    if (activity & GEIS_BE_MX_HANGUP_DETECTED) flags |= DBUS_WATCH_HANGUP;
+    if (activity & GEIS_BE_MX_ERROR_DETECTED)  flags |= DBUS_WATCH_ERROR;
+    dbus_watch_handle(gdb->watch, flags);
+
+    if (gdb->connection)
+    {
+      if (activity & GEIS_BE_MX_HANGUP_DETECTED)
+      {
+        dbus_connection_close(gdb->connection);
+      }
+      else
+      {
+        DBusDispatchStatus s;
+        s = dbus_connection_get_dispatch_status(gdb->connection);
+        while (DBUS_DISPATCH_DATA_REMAINS == s)
+        {
+          s = dbus_connection_dispatch(gdb->connection);
+        }
+      }
+    }
+  }
+}
+
+
+/*
+ * Creates a new GEIS DBus dispatcher.
+ */
+GeisDBusDispatcher
+geis_dbus_dispatcher_new(Geis geis)
+{
+  GeisDBusDispatcher dispatcher = calloc(1, sizeof(struct GeisDBusDispatcher));
+  if (!dispatcher)
+  {
+    geis_error("error allocating GEIS DBus dispatcher.");
+    goto final_exit;
+  }
+
+  dispatcher->geis = geis;
+  dispatcher->watches = _geis_dbus_watch_bag_new();
+  if (!dispatcher->watches)
+  {
+    geis_error("error creating GEIS DBus dispatcher watches.");
+    goto unwind_dispatcher;
+  }
+
+  goto final_exit;
+
+unwind_dispatcher:
+  free(dispatcher);
+final_exit:
+  return dispatcher;
+}
+
+
+/*
+ * Destroys an existing %GeisDBusDispatcher object.
+ */
+void
+geis_dbus_dispatcher_delete(GeisDBusDispatcher dispatcher)
+{
+  _geis_dbus_watch_bag_delete(dispatcher->watches);
+  free(dispatcher);
+ }
+
+
+/*
+ * Registers a new DBusWatch with a %GeisDBusDispatcher object.
+ */
+void
+geis_dbus_dispatcher_register(GeisDBusDispatcher  dispatcher,
+                              DBusConnection     *connection,
+                              DBusWatch          *watch)
+{
+  int watch_fd = dbus_watch_get_unix_fd(watch);
+
+  /* Calculate all the enabled flags on the fd for all watches. */
+  unsigned int flags = 0;
+  int has_fd = _geis_dbus_watch_bag_has_fd(dispatcher->watches, watch_fd, &flags);
+  _geis_dbus_watch_bag_alloc_watch(dispatcher->watches, connection, watch);
+  if (dbus_watch_get_enabled(watch))
+  {
+    flags |= dbus_watch_get_flags(watch);
+  }
+
+  /* Convert the watch flags to multiplexor activities. */
+  GeisBackendMultiplexorActivity activity = 0;
+  if (flags & DBUS_WATCH_READABLE) activity |= GEIS_BE_MX_READ_AVAILABLE;
+  if (flags & DBUS_WATCH_WRITABLE) activity |= GEIS_BE_MX_WRITE_AVAILABLE;
+
+  /* Set or adjust the multiplexor seubscription. */
+  if (has_fd)
+  {
+    geis_remultiplex_fd(dispatcher->geis, watch_fd, activity);
+  }
+  else
+  {
+    geis_multiplex_fd(dispatcher->geis,
+                      watch_fd,
+                      activity,
+                      _geis_dbus_dispatcher_callback,
+                      dispatcher);
+  }
+}
+
+
+/*
+ * Unregisters a DBusWatch for events.
+ */
+void
+geis_dbus_dispatcher_unregister(GeisDBusDispatcher  dispatcher,
+                                DBusWatch          *watch)
+{
+  int watch_fd = dbus_watch_get_unix_fd(watch);
+  unsigned int flags = 0;
+  _geis_dbus_watch_bag_remove_watch(dispatcher->watches, watch);
+  if (!_geis_dbus_watch_bag_has_fd(dispatcher->watches, watch_fd, &flags))
+  {
+    geis_demultiplex_fd(dispatcher->geis, watch_fd);
+  }
+}
+
+
+/*
+ * Marks a DBusWatch as active, maybe.
+ */
+void
+geis_dbus_dispatcher_toggle_watch(GeisDBusDispatcher  dispatcher,
+                                  DBusWatch          *watch)
+{
+  int watch_fd = dbus_watch_get_unix_fd(watch);
+
+  /* Calculate all the enabled flags on the fd for all watches. */
+  unsigned int flags = 0;
+  _geis_dbus_watch_bag_has_fd(dispatcher->watches, watch_fd, &flags);
+  if (dbus_watch_get_enabled(watch))
+  {
+    flags |= dbus_watch_get_flags(watch);
+  }
+  else
+  {
+    flags &= ~dbus_watch_get_flags(watch);
+  }
+
+  /* Convert the watch flags to multiplexor activities. */
+  GeisBackendMultiplexorActivity activity = 0;
+  if (flags & DBUS_WATCH_READABLE) activity |= GEIS_BE_MX_READ_AVAILABLE;
+  if (flags & DBUS_WATCH_WRITABLE) activity |= GEIS_BE_MX_WRITE_AVAILABLE;
+
+  /* Set or adjust the multiplexor seubscription. */
+  geis_remultiplex_fd(dispatcher->geis, watch_fd, activity);
+
+}
+
+

=== added file 'libs/geis-dbus/geis_dbus_dispatcher.h'
--- libs/geis-dbus/geis_dbus_dispatcher.h	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_dispatcher.h	2011-10-18 19:34:23 +0000
@@ -0,0 +1,116 @@
+/**
+ * @file geis_dbus_dispatcher.h
+ * @brief Interface for the GEIS DBus dispatcher.
+ *
+ * The GEIS DBus dispatcher provides a central dispatch point for all DBus
+ * events used internally by GEIS.
+ *
+ * This header is for internal GEIS use only and contains no client
+ * (externally-visible) symbols.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef GEIS_DBUS_DISPATCHER_H_
+#define GEIS_DBUS_DISPATCHER_H_
+
+#include <dbus/dbus.h>
+#include "geis/geis.h"
+
+
+/**
+ * The %GeisDBusDispatcher centralizes all dispatch for all DBus events used
+ * internally by the GEIS client-server mechanism.
+ *
+ * Geis implements single-threaded ansynchronous dispatch for DBus events, in
+ * case a single-threaded client is making use of GEIS.  This also simplifies a
+ * lot of the internal design of the GEIS DBus service, since no locking or
+ * other forms of synchronization are required.
+ */
+typedef struct GeisDBusDispatcher *GeisDBusDispatcher;
+
+/**
+ * A callback type for the handler function dispatched on DBus events.
+ *
+ * @todo the parameters of the GeisDispatchCallback must be defined.
+ */
+typedef void (*GeisDispatchCallback)(void *context);
+
+
+/**
+ * Creates a new GEIS DBus dispatcher.
+ *
+ * @param[in] geis  A GEIS instance.
+ *
+ * Creates a new %GeisDBusDispatcher and registers it with the GEIS API instance
+ * so it will be multiplexed and receive event notification.
+ *
+ * @returns a new %GeisDBusDispatcher object or NULL on failure.
+ */
+GeisDBusDispatcher
+geis_dbus_dispatcher_new(Geis geis);
+
+/**
+ * Destroys an existing %GeisDBusDispatcher object.
+ *
+ * @param[in] dispatcher  A %GeisDBusDispatcher object.
+ */
+void
+geis_dbus_dispatcher_delete(GeisDBusDispatcher dispatcher);
+
+/**
+ * Registers a new DBusWatch with a %GeisDBusDispatcher object.
+ *
+ * @param[in] dispatcher  A %GeisDBusDispatcher object.
+ * @param[in] connection  A DBus connection.
+ * @param[in] watch       A DBusWatch om the connection.
+ *
+ * The @p watch will be registered with the @p dispatcher for future DBus
+ * events.  The @p watch may or may not be activated, depending on its @a
+ * enabled state at the time of registration.
+ */
+void
+geis_dbus_dispatcher_register(GeisDBusDispatcher  dispatcher,
+                              DBusConnection     *connection,
+                              DBusWatch          *watch);
+
+/**
+ * Unregisters a DBusWatch for events.
+ *
+ * @param[in] dispatcher  A %GeisDBusDispatcher object.
+ * @param[in] watch       A DBusWatch.
+ */
+void
+geis_dbus_dispatcher_unregister(GeisDBusDispatcher  dispatcher,
+                                DBusWatch          *watch);
+
+/**
+ * Marks a DBusWatch as active or not, depending on its state.
+ *
+ * @param[in] dispatcher  A %GeisDBusDispatcher object.
+ * @param[in] watch       A pointer to a DBusWatch object.
+ *
+ * The @p dispatcher will listen for events on the @p watch if its @a is_enabled
+ * state is true or not.
+ */
+void
+geis_dbus_dispatcher_toggle_watch(GeisDBusDispatcher  dispatcher,
+                                  DBusWatch          *watch);
+
+
+
+#endif /* GEIS_DBUS_DISPATCHER_H_ */

=== added file 'libs/geis-dbus/geis_dbus_gesture_event.c'
--- libs/geis-dbus/geis_dbus_gesture_event.c	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_gesture_event.c	2011-10-18 19:34:23 +0000
@@ -0,0 +1,573 @@
+/**
+ * @file geis_dbus_gesture_event.c
+ * @brief Implementation of the GEIS DBus gesture event transport.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "geis_config.h"
+#include "geis_dbus_gesture_event.h"
+
+#include "geis_attr.h"
+#include "geis_dbus.h"
+#include "geis_dbus_attr.h"
+#include "geis_event.h"
+#include "geis_group.h"
+#include "geis_logging.h"
+#include "geis_private.h"
+#include "geis_touch.h"
+
+/**
+ * A frame is marshalled as a dict entry of
+ * {id: [array of attrs, array of classes, array of touch ids]}, which is
+ * {i(a(sv)aiai))} in DBus terminaology.
+ */
+#define GEIS_DBUS_TYPE_SIGNATURE_FRAME \
+                       DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING \
+                       DBUS_TYPE_INT32_AS_STRING \
+                       DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
+                       DBUS_TYPE_ARRAY_AS_STRING \
+                       GEIS_DBUS_TYPE_SIGNATURE_ATTR \
+                       DBUS_TYPE_ARRAY_AS_STRING \
+                       DBUS_TYPE_INT32_AS_STRING \
+                       DBUS_TYPE_ARRAY_AS_STRING \
+                       DBUS_TYPE_INT32_AS_STRING \
+                       DBUS_STRUCT_END_CHAR_AS_STRING \
+                       DBUS_DICT_ENTRY_END_CHAR_AS_STRING \
+
+#define GEIS_DBUS_TYPE_SIGNATURE_FRAMESET \
+                       DBUS_TYPE_ARRAY_AS_STRING \
+                       GEIS_DBUS_TYPE_SIGNATURE_FRAME 
+
+
+static void
+_marshall_touchset(GeisTouchSet touchset, DBusMessageIter *iter)
+{
+  DBusMessageIter touchset_iter;
+  dbus_message_iter_open_container(iter,
+                                   DBUS_TYPE_ARRAY,
+                                   DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+                                   DBUS_TYPE_INT32_AS_STRING
+                                   DBUS_TYPE_ARRAY_AS_STRING
+                                   GEIS_DBUS_TYPE_SIGNATURE_ATTR
+                                   DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+                                   &touchset_iter);
+  for (GeisSize t = 0; t < geis_touchset_touch_count(touchset); ++t)
+  {
+    DBusMessageIter touch_iter;
+    dbus_message_iter_open_container(&touchset_iter,
+                                     DBUS_TYPE_DICT_ENTRY,
+                                     NULL,
+                                     &touch_iter);
+    GeisTouch touch = geis_touchset_touch(touchset, t);
+    dbus_int32_t touch_id = geis_touch_id(touch);
+
+    dbus_message_iter_append_basic(&touch_iter, DBUS_TYPE_INT32, &touch_id);
+    DBusMessageIter attr_iter;
+    dbus_message_iter_open_container(&touch_iter,
+                                     DBUS_TYPE_ARRAY,
+                                     GEIS_DBUS_TYPE_SIGNATURE_ATTR,
+                                     &attr_iter);
+    for (GeisSize a = 0; a < geis_touch_attr_count(touch); ++a)
+    {
+      geis_dbus_attr_marshall(geis_touch_attr(touch, a), &attr_iter);
+    }
+    dbus_message_iter_close_container(&touch_iter, &attr_iter);
+    dbus_message_iter_close_container(&touchset_iter, &touch_iter);
+  }
+  dbus_message_iter_close_container(iter, &touchset_iter);
+}
+
+
+static void
+_unmarshall_touchset(DBusMessageIter *iter, GeisTouchSet touchset)
+{
+  int dtype = dbus_message_iter_get_arg_type(iter);
+  if (dtype != DBUS_TYPE_ARRAY)
+  {
+    geis_error("malformed GeisEvent touchset");
+  }
+
+  DBusMessageIter touch_iter;
+  dbus_message_iter_recurse(iter, &touch_iter);
+  for (dtype = dbus_message_iter_get_arg_type(&touch_iter);
+       dtype != DBUS_TYPE_INVALID;
+       dbus_message_iter_next(&touch_iter),
+       dtype = dbus_message_iter_get_arg_type(&touch_iter))
+  {
+    DBusMessageIter dict_iter;
+    dbus_message_iter_recurse(&touch_iter, &dict_iter);
+    int type = dbus_message_iter_get_arg_type(&dict_iter);
+    if (type !=  DBUS_TYPE_INT32)
+    {
+      geis_error("malformed GeisEvent touchset");
+      continue;
+    }
+    dbus_int32_t touch_id;
+    dbus_message_iter_get_basic(&dict_iter, &touch_id);
+    dbus_message_iter_next(&dict_iter);
+    GeisTouch touch = geis_touch_new(touch_id);
+
+    type = dbus_message_iter_get_arg_type(&dict_iter);
+    if (type != DBUS_TYPE_ARRAY)
+    {
+      geis_error("malformed GeisEvent touchset");
+      continue;
+    }
+
+    DBusMessageIter attr_iter;
+    dbus_message_iter_recurse(&dict_iter, &attr_iter);
+    for (int type = dbus_message_iter_get_arg_type(&attr_iter);
+         type != DBUS_TYPE_INVALID;
+         dbus_message_iter_next(&attr_iter),
+         type = dbus_message_iter_get_arg_type(&attr_iter))
+    {
+      GeisAttr attr = geis_dbus_attr_unmarshall(&attr_iter);
+      geis_touch_add_attr(touch, attr);
+    }
+    geis_touchset_insert(touchset, touch);
+  }
+}
+
+
+/**
+ * Marshalls a GEIS frame to a DBus message via a message iterator.
+ * @param[in]  frame  The GEIS frame to marshall.
+ * @param[in]  iter   The DBus message iterator.
+ *
+ * @todo The class set and matrix need to be added.
+ */
+static void
+_marshall_frame(GeisFrame frame,  DBusMessageIter *frame_iter)
+{
+  DBusMessageIter dict_iter;
+  dbus_message_iter_open_container(frame_iter,
+                                   DBUS_TYPE_DICT_ENTRY,
+                                   NULL,
+                                   &dict_iter);
+
+  dbus_int32_t frame_id = geis_frame_id(frame);
+  dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_INT32, &frame_id);
+
+  {
+    DBusMessageIter struct_iter;
+    dbus_message_iter_open_container(&dict_iter,
+                                     DBUS_TYPE_STRUCT,
+                                     NULL,
+                                     &struct_iter);
+    {
+      DBusMessageIter attr_iter;
+      dbus_message_iter_open_container(&struct_iter,
+                                       DBUS_TYPE_ARRAY,
+                                       GEIS_DBUS_TYPE_SIGNATURE_ATTR,
+                                       &attr_iter);
+      for (GeisSize a = 0; a < geis_frame_attr_count(frame); ++a)
+      {
+        geis_dbus_attr_marshall(geis_frame_attr(frame, a), &attr_iter);
+      }
+      dbus_message_iter_close_container(&struct_iter, &attr_iter);
+    }
+    {
+      DBusMessageIter class_iter;
+      dbus_message_iter_open_container(&struct_iter,
+                                       DBUS_TYPE_ARRAY,
+                                       DBUS_TYPE_INT32_AS_STRING,
+                                       &class_iter);
+      for (GeisSize t = 0; t < geis_frame_class_count(frame); ++t)
+      {
+        GeisGestureClass frame_class = geis_frame_class(frame, t);
+        dbus_int32_t class_id = geis_gesture_class_id(frame_class);
+        dbus_message_iter_append_basic(&class_iter, DBUS_TYPE_INT32, &class_id);
+      }
+      dbus_message_iter_close_container(&struct_iter, &class_iter);
+    }
+    {
+      DBusMessageIter touch_iter;
+      dbus_message_iter_open_container(&struct_iter,
+                                       DBUS_TYPE_ARRAY,
+                                       DBUS_TYPE_INT32_AS_STRING,
+                                       &touch_iter);
+      for (GeisSize t = 0; t < geis_frame_touchid_count(frame); ++t)
+      {
+        dbus_int32_t touch_id = geis_frame_touchid(frame, t);
+        dbus_message_iter_append_basic(&touch_iter, DBUS_TYPE_INT32, &touch_id);
+      }
+      dbus_message_iter_close_container(&struct_iter, &touch_iter);
+    }
+    dbus_message_iter_close_container(&dict_iter, &struct_iter);
+  }
+  dbus_message_iter_close_container(frame_iter, &dict_iter);
+}
+
+
+/**
+ * Unmarshalls a GEIS frame from a DBus message via a message iterator.
+ * @param[in]  frame_iter The DBus message iterator.
+ * @param[in]  group      The group the unmarshalled frame will belong to.
+ */
+static void
+_unmarshall_frame(Geis geis, DBusMessageIter *frame_iter, GeisGroup group)
+{
+  int type = dbus_message_iter_get_arg_type(frame_iter);
+  if (type != DBUS_TYPE_DICT_ENTRY)
+  {
+    geis_error("malformed GeisEvent frame: expected %c, received %c",
+               DBUS_TYPE_DICT_ENTRY, type);
+    goto final_exit;
+  }
+  DBusMessageIter dict_iter;
+  dbus_message_iter_recurse(frame_iter, &dict_iter);
+
+  type = dbus_message_iter_get_arg_type(&dict_iter);
+  if (type != DBUS_TYPE_INT32)
+  {
+    geis_error("malformed GeisEvent frame: expected %c, received %c",
+               DBUS_TYPE_INT32, type);
+    goto final_exit;
+  }
+  dbus_int32_t frame_id;
+  dbus_message_iter_get_basic(&dict_iter, &frame_id);
+  GeisFrame frame = geis_frame_new(frame_id);
+  geis_group_insert_frame(group, frame);
+
+  dbus_message_iter_next(&dict_iter);
+  type = dbus_message_iter_get_arg_type(&dict_iter);
+  if (type != DBUS_TYPE_STRUCT)
+  {
+    geis_error("malformed GeisEvent frame: expected %c, received %c",
+               DBUS_TYPE_STRUCT, type);
+  }
+  else
+  {
+    DBusMessageIter struct_iter;
+    dbus_message_iter_recurse(&dict_iter, &struct_iter);
+
+    type = dbus_message_iter_get_arg_type(&struct_iter);
+    if (type != DBUS_TYPE_ARRAY)
+    {
+      geis_error("malformed GeisEvent frame: expected %c, received %c",
+                 DBUS_TYPE_ARRAY, type);
+    }
+    else
+    {
+      DBusMessageIter attr_iter;
+      dbus_message_iter_recurse(&struct_iter, &attr_iter);
+      for (int type = dbus_message_iter_get_arg_type(&attr_iter);
+           type != DBUS_TYPE_INVALID;
+           dbus_message_iter_next(&attr_iter),
+           type = dbus_message_iter_get_arg_type(&attr_iter))
+      {
+        GeisAttr attr = geis_dbus_attr_unmarshall(&attr_iter);
+        geis_frame_add_attr(frame, attr);
+      }
+    }
+
+    dbus_message_iter_next(&struct_iter),
+    type = dbus_message_iter_get_arg_type(&struct_iter);
+    if (type != DBUS_TYPE_ARRAY)
+    {
+      geis_error("malformed GeisEvent frame: expected %c, received %c",
+                 DBUS_TYPE_ARRAY, type);
+    }
+    else
+    {
+      DBusMessageIter class_iter;
+      dbus_message_iter_recurse(&struct_iter, &class_iter);
+      for (int type = dbus_message_iter_get_arg_type(&class_iter);
+           type != DBUS_TYPE_INVALID;
+           dbus_message_iter_next(&class_iter),
+           type = dbus_message_iter_get_arg_type(&class_iter))
+      {
+        type = dbus_message_iter_get_arg_type(&class_iter);
+        if (type != DBUS_TYPE_INT32)
+        {
+          geis_error("malformed GeisEvent frame: expected %c, received %c",
+                     DBUS_TYPE_INT32, type);
+          break;
+        }
+
+        dbus_int32_t class_id;
+        dbus_message_iter_get_basic(&class_iter, &class_id);
+        GeisGestureClassBag bag = geis_gesture_classes(geis);
+        for (GeisSize i = 0; i < geis_gesture_class_bag_count(bag); ++i)
+        {
+          GeisGestureClass gesture_class;
+          gesture_class = geis_gesture_class_bag_gesture_class(bag, i);
+          if (geis_gesture_class_id(gesture_class) == class_id)
+          {
+            geis_frame_set_is_class(frame, gesture_class);
+            break;
+          }
+        }
+      }
+    }
+
+    dbus_message_iter_next(&struct_iter),
+    type = dbus_message_iter_get_arg_type(&struct_iter);
+    if (type != DBUS_TYPE_ARRAY)
+    {
+      geis_error("malformed GeisEvent frame: expected %c, received %c",
+                 DBUS_TYPE_ARRAY, type);
+    }
+    else
+    {
+      DBusMessageIter touch_iter;
+      dbus_message_iter_recurse(&struct_iter, &touch_iter);
+      for (int type = dbus_message_iter_get_arg_type(&touch_iter);
+           type != DBUS_TYPE_INVALID;
+           dbus_message_iter_next(&touch_iter),
+           type = dbus_message_iter_get_arg_type(&touch_iter))
+      {
+        type = dbus_message_iter_get_arg_type(&touch_iter);
+        if (type != DBUS_TYPE_INT32)
+        {
+          geis_error("malformed GeisEvent frame: expected %c, received %c",
+                     DBUS_TYPE_INT32, type);
+          break;
+        }
+
+        dbus_int32_t touch_id;
+        dbus_message_iter_get_basic(&touch_iter, &touch_id);
+        geis_frame_add_touchid(frame, touch_id);
+      }
+    }
+  }
+
+final_exit:
+  return;
+}
+
+
+/**
+ * Marshalls a GEIS groupset to a DBus message via a message iterator.
+ * @param[in]  groupset  The GEIS groupset.
+ * @param[in]  iter      A DBus message iterator.
+ */
+static void
+_marshall_groupset(GeisGroupSet groupset, DBusMessageIter *iter)
+{
+  DBusMessageIter groupset_iter;
+  dbus_message_iter_open_container(iter,
+                                   DBUS_TYPE_ARRAY,
+                                   DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+                                   DBUS_TYPE_INT32_AS_STRING
+                                   GEIS_DBUS_TYPE_SIGNATURE_FRAMESET 
+                                   DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+                                   &groupset_iter);
+  for (GeisSize i = 0; i < geis_groupset_group_count(groupset); ++i)
+  {
+    GeisGroup group = geis_groupset_group(groupset, i);
+    if (!group)
+    {
+      geis_warning("can not extract group %zu from groupset", i);
+      goto final_exit;
+    }
+    DBusMessageIter group_iter;
+    dbus_message_iter_open_container(&groupset_iter,
+                                     DBUS_TYPE_DICT_ENTRY,
+                                     NULL,
+                                     &group_iter);
+    dbus_int32_t group_id = geis_group_id(group);
+    dbus_message_iter_append_basic(&group_iter, DBUS_TYPE_INT32, &group_id);
+    DBusMessageIter frameset_iter;
+    dbus_message_iter_open_container(&group_iter,
+                                     DBUS_TYPE_ARRAY,
+                                     GEIS_DBUS_TYPE_SIGNATURE_FRAME,
+                                     &frameset_iter);
+    for (GeisSize j = 0; j < geis_group_frame_count(group); ++j)
+    {
+      GeisFrame frame = geis_group_frame(group, j);
+      if (!frame)
+      {
+        geis_warning("can not extract frame %zu from group", j);
+        goto final_exit;
+      }
+      _marshall_frame(frame, &frameset_iter);
+    }
+    dbus_message_iter_close_container(&group_iter, &frameset_iter);
+    dbus_message_iter_close_container(&groupset_iter, &group_iter);
+  }
+  dbus_message_iter_close_container(iter, &groupset_iter);
+
+final_exit:
+  return;
+}
+
+
+static void
+_unmarshall_groupset(Geis geis, DBusMessageIter *iter, GeisGroupSet groupset)
+{
+  int dtype = dbus_message_iter_get_arg_type(iter);
+  if (dtype != DBUS_TYPE_ARRAY)
+  {
+    geis_error("malformed GeisEvent groupset");
+  }
+
+  DBusMessageIter groupset_iter;
+  dbus_message_iter_recurse(iter, &groupset_iter);
+  for (dtype = dbus_message_iter_get_arg_type(&groupset_iter);
+       dtype != DBUS_TYPE_INVALID;
+       dbus_message_iter_next(&groupset_iter),
+       dtype = dbus_message_iter_get_arg_type(&groupset_iter))
+  {
+    DBusMessageIter group_iter;
+    dbus_message_iter_recurse(&groupset_iter, &group_iter);
+
+    int type = dbus_message_iter_get_arg_type(&group_iter);
+    if (type !=  DBUS_TYPE_INT32)
+    {
+      geis_error("malformed GeisEvent group");
+      continue;
+    }
+    dbus_int32_t group_id;
+    dbus_message_iter_get_basic(&group_iter, &group_id);
+    GeisGroup group = geis_group_new(group_id);
+    geis_groupset_insert(groupset, group);
+    dbus_message_iter_next(&group_iter);
+
+    DBusMessageIter frameset_iter;
+    dbus_message_iter_recurse(&group_iter, &frameset_iter);
+    for (int ftype = dbus_message_iter_get_arg_type(&frameset_iter);
+         ftype != DBUS_TYPE_INVALID;
+         dbus_message_iter_next(&frameset_iter),
+         ftype = dbus_message_iter_get_arg_type(&frameset_iter))
+    {
+      _unmarshall_frame(geis, &frameset_iter, group);
+    }
+  }
+}
+
+
+/*
+ * Creates a Dbus "gesture event" message from a GEIS gesture event.
+ *
+ * A gesture event has the following structure.
+ *   - a numeric event type (begin/update/end)
+ *   - a set of one or more touches, where each touch has
+ *     - a touch ID
+ *     - a set of one or more attrs
+ *   - a set of one or more gesture groups, where is group has
+ *     - a group ID
+ *     - a set of one or more gesture frames, where each frame has
+ *       - a set of one or more gesture classes
+ *       - a set of one or more gesture attrs
+ *       - a zet of one or more touch indexes
+ *
+ * @todo add the gesture classes
+ */
+DBusMessage *
+geis_dbus_gesture_event_message_from_geis_event(GeisEvent event)
+{
+  DBusMessage *message = dbus_message_new_signal(GEIS_DBUS_SERVICE_PATH,
+                                                 GEIS_DBUS_SERVICE_INTERFACE,
+                                                 GEIS_DBUS_GESTURE_EVENT);
+  DBusMessageIter iter;
+  dbus_message_iter_init_append(message, &iter);
+
+  dbus_uint32_t event_type = geis_event_type(event);
+  dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &event_type);
+
+  GeisAttr attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_TOUCHSET);
+  if (!attr)
+  {
+    geis_error("no touchset for gesture event");
+    goto final_exit;
+  }
+
+  GeisTouchSet touchset = geis_attr_value_to_pointer(attr);
+  if (!touchset)
+  {
+    geis_warning("can not convert attr to touchset");
+    goto final_exit;
+  }
+
+  _marshall_touchset(touchset, &iter);
+
+  attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_GROUPSET);
+  if (!attr)
+  {
+    geis_error("no groupset for gesture event");
+    goto final_exit;
+  }
+
+  GeisGroupSet groupset = geis_attr_value_to_pointer(attr);
+  if (!groupset)
+  {
+    geis_warning("can not convert attr to groupset");
+    goto final_exit;
+  }
+
+  _marshall_groupset(groupset, &iter);
+
+final_exit:
+  return message;
+}
+
+
+/*
+ * Indicates if a DBus message is a "gesture event" message.
+ */
+GeisBoolean
+geis_dbus_message_is_gesture_event(DBusMessage *message)
+{
+  GeisBoolean is_gesture_event_message = GEIS_FALSE;
+  if (dbus_message_is_signal(message,
+                             GEIS_DBUS_SERVICE_INTERFACE,
+                             GEIS_DBUS_GESTURE_EVENT))
+  {
+    is_gesture_event_message = GEIS_TRUE;
+  }
+
+  return is_gesture_event_message;
+}
+
+
+/*
+ * Creates GEIS event from a DBus "gesture_event" message.
+ */
+GeisEvent
+geis_dbus_gesture_event_from_message(Geis geis, DBusMessage *message)
+{
+  DBusMessageIter iter;
+  dbus_message_iter_init(message, &iter);
+
+  dbus_uint32_t event_type;
+  dbus_message_iter_get_basic(&iter, &event_type);
+  GeisEvent event = geis_event_new(event_type);
+
+  dbus_message_iter_next(&iter);
+  GeisTouchSet  touchset = geis_touchset_new();
+  _unmarshall_touchset(&iter, touchset);
+  GeisAttr touch_attr = geis_attr_new(GEIS_EVENT_ATTRIBUTE_TOUCHSET,
+                                      GEIS_ATTR_TYPE_POINTER,
+                                      touchset);
+  geis_attr_set_destructor(touch_attr, (GeisAttrDestructor)geis_touchset_delete);
+  geis_event_add_attr(event, touch_attr);
+
+  dbus_message_iter_next(&iter);
+  GeisGroupSet  groupset = geis_groupset_new();
+  _unmarshall_groupset(geis, &iter, groupset);
+  GeisAttr      group_attr = geis_attr_new(GEIS_EVENT_ATTRIBUTE_GROUPSET,
+                                           GEIS_ATTR_TYPE_POINTER,
+                                           groupset);
+  geis_attr_set_destructor(group_attr, (GeisAttrDestructor)geis_groupset_delete);
+  geis_event_add_attr(event, group_attr);
+
+  return event;
+}
+
+

=== added file 'libs/geis-dbus/geis_dbus_gesture_event.h'
--- libs/geis-dbus/geis_dbus_gesture_event.h	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_gesture_event.h	2011-10-18 19:34:23 +0000
@@ -0,0 +1,55 @@
+/**
+ * @file geis_dbus_gesture_event.h
+ * @brief Interface for the GEIS DBus gesture event transport.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef GEIS_DBUS_GESTURE_EVENT_H_
+#define GEIS_DBUS_GESTURE_EVENT_H_
+
+#include <dbus/dbus.h>
+#include "geis/geis.h"
+
+
+/**
+ * Creates a Dbus "gesture event" message from a GEIS gesture event.
+ *
+ * @param[in] event  A GEIS event.
+ */
+DBusMessage *
+geis_dbus_gesture_event_message_from_geis_event(GeisEvent event);
+
+/**
+ * Indicates if a DBus message is a "gesture event" message.
+ *
+ * @param[in] message  A DBus message.
+ */
+GeisBoolean
+geis_dbus_message_is_gesture_event(DBusMessage *message);
+
+/**
+ * Creates GEIS event from a DBus "gesture_event" message.
+ *
+ * @param[in] message  A DBus message.
+ */
+GeisEvent
+geis_dbus_gesture_event_from_message(Geis geis, DBusMessage *message);
+
+
+#endif /* GEIS_DBUS_GESTURE_EVENT_H_ */
+

=== added file 'libs/geis-dbus/geis_dbus_region.c'
--- libs/geis-dbus/geis_dbus_region.c	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_region.c	2011-10-18 19:34:23 +0000
@@ -0,0 +1,91 @@
+/**
+ * @file geis_dbus_region.c
+ * @brief Implementations of the GEIS DBus region transport.
+ */
+
+/*
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#include "geis_config.h"
+#include "geis_dbus_region.h"
+
+#include "geis_dbus.h"
+#include "geis_logging.h"
+
+
+/*
+ * Creates a Dbus "region available" message from a GEIS region.
+ */
+DBusMessage *
+geis_dbus_region_available_message_from_region(GeisFilterableAttribute fa)
+{
+  DBusMessage *message = dbus_message_new_signal(GEIS_DBUS_SERVICE_PATH,
+                                                 GEIS_DBUS_SERVICE_INTERFACE,
+                                                 GEIS_DBUS_REGION_AVAILABLE);
+  DBusMessageIter iter;
+  dbus_message_iter_init_append(message, &iter);
+
+  const char *attr_name = fa->name;
+  dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &attr_name);
+
+  dbus_int32_t attr_type = fa->type;
+  dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &attr_type);
+
+
+  return message;
+}
+
+
+/*
+ * Creates GEIS region filterable attribute from a DBus "region available"
+ * message.
+ */
+GeisFilterableAttribute
+geis_dbus_region_from_region_available_message(DBusMessage *message)
+{
+  geis_debug("begins");
+  static struct GeisFilterableAttribute attr;
+  DBusMessageIter iter;
+  dbus_message_iter_init(message, &iter);
+
+  int type = dbus_message_iter_get_arg_type(&iter);
+  if (type != DBUS_TYPE_STRING)
+  {
+    geis_error("error getting attr name name from DBus message.");
+    goto final_exit;
+  }
+  char *attr_name;
+  dbus_message_iter_get_basic(&iter, &attr_name);
+  dbus_message_iter_next(&iter);
+
+  type = dbus_message_iter_get_arg_type(&iter);
+  if (type != DBUS_TYPE_INT32)
+  {
+    geis_error("error getting attr type from DBus message.");
+    goto final_exit;
+  }
+  dbus_int32_t attr_type;
+  dbus_message_iter_get_basic(&iter, &attr_type);
+
+  attr.name = attr_name;
+  attr.type = attr_type;
+
+final_exit:
+  geis_debug("ends");
+  return &attr;
+}
+
+

=== added file 'libs/geis-dbus/geis_dbus_region.h'
--- libs/geis-dbus/geis_dbus_region.h	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_region.h	2011-10-18 19:34:23 +0000
@@ -0,0 +1,47 @@
+/**
+ * @file geis_dbus_region.h
+ * @brief Interface for the GEIS DBus region transport.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef GEIS_DBUS_REGION_H_
+#define GEIS_DBUS_REGION_H_
+
+#include <dbus/dbus.h>
+#include "geis/geis.h"
+#include "geis_filterable.h"
+
+
+/**
+ * Creates a Dbus "region available" message from a GEIS region.
+ *
+ * @param[in] fa  A GEIS region filterable attribute.
+ */
+DBusMessage *
+geis_dbus_region_available_message_from_region(GeisFilterableAttribute fa);
+
+/**
+ * Creates GEIS region filterable attribute from a DBus "region available"
+ * message.
+ *
+ * @param[in] message  A DBus message.
+ */
+GeisFilterableAttribute
+geis_dbus_region_from_region_available_message(DBusMessage *message);
+
+#endif /* GEIS_DBUS_REGION_H_ */

=== added file 'libs/geis-dbus/geis_dbus_subscription.c'
--- libs/geis-dbus/geis_dbus_subscription.c	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_subscription.c	2011-10-18 19:34:23 +0000
@@ -0,0 +1,506 @@
+/**
+ * @file geis_dbus_subscription.c
+ * @brief Implementation of the GEIS DBus subscription transport.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "geis_config.h"
+#include "geis_dbus_subscription.h"
+
+#include "geis_dbus.h"
+#include "geis_dbus_attr.h"
+#include "geis_filter_term.h"
+#include "geis_logging.h"
+#include "geis_subscription.h"
+#include <stdint.h>
+
+
+/*
+ * A filter term is marshalled as a (facility, operation, value) tuple.
+ * That would be a (ii(sv)) in DBusspeak.
+ */
+#define GEIS_DBUS_TYPE_SIGNATURE_TERM \
+             DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
+             DBUS_TYPE_INT32_AS_STRING \
+             DBUS_TYPE_INT32_AS_STRING \
+             GEIS_DBUS_TYPE_SIGNATURE_ATTR \
+             DBUS_STRUCT_END_CHAR_AS_STRING
+
+/*
+ * A term list is an array of terms, as in a(ii(sv)).
+ */
+#define GEIS_DBUS_TYPE_SIGNATURE_TERM_LIST \
+             DBUS_TYPE_ARRAY_AS_STRING \
+             GEIS_DBUS_TYPE_SIGNATURE_TERM
+
+/*
+ * A filter is a named array of filter terms.
+ * That's a {sa(ii(sv))} in the DBus tongue.
+ */
+#define GEIS_DBUS_TYPE_SIGNATURE_FILTER \
+             DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING \
+             DBUS_TYPE_STRING_AS_STRING \
+             GEIS_DBUS_TYPE_SIGNATURE_TERM_LIST \
+             DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+
+
+/**
+ * Adds filter terms to a DBus message.
+ *
+ * @param[in] filter      The filter for which terms will be marshalled.
+ * @param[in] filter_iter A DBus message output iterator.
+ */
+static void
+_geis_dbus_marshall_subscription_filter_terms(GeisFilter       filter,
+                                              DBusMessageIter *filter_iter)
+{
+  DBusMessageIter term_list_iter;
+  dbus_message_iter_open_container(filter_iter,
+                                   DBUS_TYPE_ARRAY,
+                                   GEIS_DBUS_TYPE_SIGNATURE_TERM,
+                                   &term_list_iter);
+  for (GeisSize i = 0; i < geis_filter_term_count(filter); ++i)
+  {
+    GeisFilterTerm term = geis_filter_term(filter, i);
+    dbus_int32_t facility = geis_filter_term_facility(term);
+    dbus_int32_t operation = geis_filter_term_operation(term);
+    GeisAttr     attr = geis_filter_term_attr(term);
+
+    DBusMessageIter term_iter;
+    dbus_message_iter_open_container(&term_list_iter,
+                                     DBUS_TYPE_STRUCT,
+                                     NULL,
+                                     &term_iter);
+    dbus_message_iter_append_basic(&term_iter, DBUS_TYPE_INT32, &facility);
+    dbus_message_iter_append_basic(&term_iter, DBUS_TYPE_INT32, &operation);
+    geis_dbus_attr_marshall(attr, &term_iter);
+    dbus_message_iter_close_container(&term_list_iter, &term_iter);
+  }
+  dbus_message_iter_close_container(filter_iter, &term_list_iter);
+}
+
+
+/**
+ * Squeezes the filters on a subscription into the DBus wire protocol.
+ *
+ * @param[in] sub      A %GeisSubscription
+ * @param[in] msg_iter The open output iterator for a DBus message.
+ *
+ * The filters are marshalled as an array of DBus dict entries.
+ */
+static void
+_geis_dbus_marshall_subscription_filters(GeisSubscription  subscription,
+                                         DBusMessageIter  *msg_iter)
+{
+  DBusMessageIter filter_list_iter;
+
+  dbus_message_iter_open_container(msg_iter,
+                                   DBUS_TYPE_ARRAY,
+                                   GEIS_DBUS_TYPE_SIGNATURE_FILTER,
+                                   &filter_list_iter);
+
+  for (GeisFilterIterator it = geis_subscription_filter_begin(subscription);
+       it != geis_subscription_filter_end(subscription);
+       it = geis_subscription_filter_next(subscription, it))
+  {
+    const char *filter_name = geis_filter_name(*it);
+
+    DBusMessageIter filter_iter;
+    dbus_message_iter_open_container(&filter_list_iter,
+                                     DBUS_TYPE_DICT_ENTRY,
+                                     NULL,
+                                     &filter_iter);
+    dbus_message_iter_append_basic(&filter_iter, DBUS_TYPE_STRING, &filter_name);
+    _geis_dbus_marshall_subscription_filter_terms(*it, &filter_iter);
+    dbus_message_iter_close_container(&filter_list_iter, &filter_iter);
+  }
+  dbus_message_iter_close_container(msg_iter, &filter_list_iter);
+}
+
+
+static void
+_geis_dbus_unmarshall_filter_terms(GeisFilter       filter,
+                                   DBusMessageIter *filter_iter)
+{
+  DBusMessageIter term_list_iter;
+  dbus_message_iter_recurse(filter_iter, &term_list_iter);
+  for (int dtype = dbus_message_iter_get_arg_type(&term_list_iter);
+       dtype != DBUS_TYPE_INVALID;
+       dbus_message_iter_next(&term_list_iter),
+       dtype = dbus_message_iter_get_arg_type(&term_list_iter))
+  {
+    int ttype = dbus_message_iter_get_arg_type(&term_list_iter);
+    if (ttype != DBUS_TYPE_STRUCT)
+    {
+      geis_error("malformed GeisSubscription term");
+      goto final_exit;
+    }
+
+    DBusMessageIter term_iter;
+    dbus_message_iter_recurse(&term_list_iter, &term_iter);
+
+    dbus_int32_t facility;
+    dbus_message_iter_get_basic(&term_iter, &facility);
+    dbus_message_iter_next(&term_iter);
+
+    dbus_int32_t operation;
+    dbus_message_iter_get_basic(&term_iter, &operation);
+    dbus_message_iter_next(&term_iter);
+
+    GeisAttr attr = geis_dbus_attr_unmarshall(&term_iter);
+    GeisFilterTerm term = geis_filter_term_new(facility, operation, attr);
+    geis_filter_add_term_internal(filter, term);
+  }
+
+final_exit:
+  return;
+}
+
+
+/**
+ * Unmarshalls a filter from a DBus message.
+ *
+ * @param[in] geis         A GEIS instance.
+ * @param[in] filter_iter  A DBus message iterator pointing to the filter.
+ */
+static GeisFilter
+_geis_dbus_unmarshall_filter(Geis geis, DBusMessageIter *filter_iter)
+{
+  GeisFilter filter = NULL;
+
+  int ftype = dbus_message_iter_get_arg_type(filter_iter);
+  if (ftype != DBUS_TYPE_DICT_ENTRY)
+  {
+    geis_error("malformed GeisSubscription filter");
+    goto final_exit;
+  }
+
+  DBusMessageIter dict_iter;
+  dbus_message_iter_recurse(filter_iter, &dict_iter);
+
+  ftype = dbus_message_iter_get_arg_type(&dict_iter);
+  if (ftype != DBUS_TYPE_STRING)
+  {
+    geis_error("malformed GeisSubscription filter");
+    goto final_exit;
+  }
+  GeisString filter_name;
+  dbus_message_iter_get_basic(&dict_iter, &filter_name);
+  dbus_message_iter_next(&dict_iter);
+
+  filter = geis_filter_new(geis, filter_name);
+
+  ftype = dbus_message_iter_get_arg_type(&dict_iter);
+  if (ftype != DBUS_TYPE_ARRAY)
+  {
+    geis_error("malformed GeisSubscription filter");
+    goto final_exit;
+  }
+  _geis_dbus_unmarshall_filter_terms(filter, &dict_iter);
+
+final_exit:
+  return filter;
+}
+
+
+/**
+ * Unmarshalls a list of filters from a DBus message.
+ *
+ * @param[in] geis               A GEIS instance.
+ * @param[in] subscription_iter  A DBus message iterator for the subscription.
+ * @param[in] subscription       A GEIS subsccription.
+ *
+ * This function unmarshalls filters from a GEIS DBus subscription message and
+ * adds them to a existing GEIS subscription.
+ */
+static void
+_geis_dbus_unmarshall_subscription_filters(Geis              geis,
+                                           DBusMessageIter  *subscription_iter,
+                                           GeisSubscription  subscription)
+{
+  DBusMessageIter filter_list_iter;
+  dbus_message_iter_recurse(subscription_iter, &filter_list_iter);
+  for (int dtype = dbus_message_iter_get_arg_type(&filter_list_iter);
+       dtype != DBUS_TYPE_INVALID;
+       dbus_message_iter_next(&filter_list_iter),
+       dtype = dbus_message_iter_get_arg_type(&filter_list_iter))
+  {
+    GeisFilter filter = _geis_dbus_unmarshall_filter(geis, &filter_list_iter);
+    if (filter)
+    {
+      geis_subscription_add_filter(subscription, filter);
+    }
+  }
+}
+
+
+/*
+ * Indicates if a DBus message is a GEIS_DBUS_SUBSCRIPTION_CREATE method call.
+ */
+GeisBoolean
+geis_dbus_message_is_subscription_create_call(DBusMessage *message)
+{
+  return dbus_message_is_method_call(message,
+                                     GEIS_DBUS_SERVICE_INTERFACE,
+                                     GEIS_DBUS_SUBSCRIPTION_CREATE);
+}
+
+
+/*
+ * Creates a GEIS_DBUS_SUBSCRIPTION_CREATE method call message.
+ */
+DBusMessage *
+geis_dbus_subscription_create_call_message(GeisSubscription subscription)
+{
+  DBusMessage  *message   = NULL;
+  GeisString    sub_name  = "dummy";
+  dbus_int32_t  sub_id    = -1;
+  dbus_uint32_t sub_flags = 0;
+  DBusMessageIter iter;
+
+  message = dbus_message_new_method_call(GEIS_DBUS_SERVICE_INTERFACE,
+                                         GEIS_DBUS_SERVICE_PATH,
+                                         GEIS_DBUS_SERVICE_INTERFACE,
+                                         GEIS_DBUS_SUBSCRIPTION_CREATE);
+
+  if (subscription)
+  {
+    sub_name  = geis_subscription_name(subscription);
+    sub_id    = geis_subscription_id(subscription);
+    sub_flags = geis_subscription_flags(subscription);
+  }
+  dbus_message_iter_init_append(message, &iter);
+
+  dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &sub_name);
+  dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32,  &sub_id);
+  dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32,  &sub_flags);
+  _geis_dbus_marshall_subscription_filters(subscription, &iter);
+
+  return message;
+}
+
+
+/*
+ * Creates a %GeisSubscription from a method call message.
+ */
+GeisSubscription
+geis_dbus_subscription_from_create_call_message(Geis geis, DBusMessage *message)
+{
+  DBusMessageIter  message_iter;
+  dbus_message_iter_init(message, &message_iter);
+
+  GeisString       client_sub_name;
+  dbus_message_iter_get_basic(&message_iter, &client_sub_name);
+  dbus_message_iter_next(&message_iter);
+
+  dbus_int32_t     client_sub_id;
+  dbus_message_iter_get_basic(&message_iter, &client_sub_id);
+  dbus_message_iter_next(&message_iter);
+
+  dbus_uint32_t    client_sub_flags;
+  dbus_message_iter_get_basic(&message_iter, &client_sub_flags);
+  dbus_message_iter_next(&message_iter);
+
+  GeisSubscription subscription = NULL;
+  subscription = geis_subscription_new(geis, client_sub_name, client_sub_flags);
+  if (!subscription)
+  {
+    geis_error("error creating proxy subscription");
+    goto final_exit;
+  }
+  intptr_t fudge = client_sub_id;
+  geis_subscription_set_pdata(subscription, (GeisPointer)fudge);
+
+  int dtype = dbus_message_iter_get_arg_type(&message_iter);
+  if (dtype != DBUS_TYPE_ARRAY)
+  {
+    geis_error("malformed GeisSubscription message"
+               " (expected type %c, received type %c)",
+               DBUS_TYPE_ARRAY, dtype);
+    goto final_exit;
+  }
+
+  _geis_dbus_unmarshall_subscription_filters(geis, &message_iter, subscription);
+
+final_exit:
+  return subscription;
+}
+
+
+/*
+ * Creates a GEIS_DBUS_SUBSCRIPTION_CREATE method return message.
+ */
+DBusMessage *
+geis_dbus_subscription_create_return_message(DBusMessage      *message,
+                                             GeisSubscription  subscription)
+{
+  DBusMessage *reply = dbus_message_new_method_return(message);
+  intptr_t fudge = (intptr_t)geis_subscription_pdata(subscription);
+  dbus_int32_t client_sub_id = fudge;
+  dbus_int32_t server_sub_id = geis_subscription_id(subscription);
+  dbus_message_append_args(reply,
+                           DBUS_TYPE_INT32, &client_sub_id,
+                           DBUS_TYPE_INT32, &server_sub_id,
+                           DBUS_TYPE_INVALID);
+
+  return reply;
+}
+
+
+/*
+ * Indicates if a DBus message is a GEIS_DBUS_SUBSCRIPTION_ACTIVATE message.
+ */
+GeisBoolean
+geis_dbus_message_is_subscription_activate_call(DBusMessage *message)
+{
+  return dbus_message_is_method_call(message,
+                                     GEIS_DBUS_SERVICE_INTERFACE,
+                                     GEIS_DBUS_SUBSCRIPTION_ACTIVATE);
+}
+
+
+/*
+ * Creates a GEIS_DBUS_SUBSCRIPTION_ACTIVATE method call message.
+ */
+DBusMessage *
+geis_dbus_subscription_activate_call_message(GeisSubscription subscription)
+{
+  DBusMessage *message   = NULL;
+  DBusMessageIter iter;
+
+  message = dbus_message_new_method_call(GEIS_DBUS_SERVICE_INTERFACE,
+                                         GEIS_DBUS_SERVICE_PATH,
+                                         GEIS_DBUS_SERVICE_INTERFACE,
+                                         GEIS_DBUS_SUBSCRIPTION_ACTIVATE);
+  dbus_message_iter_init_append(message, &iter);
+
+  dbus_int32_t subscription_id = geis_subscription_id(subscription);
+  dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &subscription_id);
+  _geis_dbus_marshall_subscription_filters(subscription, &iter);
+  return message;
+}
+
+
+/*
+ * Creates a GEIS_DBUS_SUBSCRIPTION_ACTIVATE method return message.
+ */
+DBusMessage *
+geis_dbus_subscription_activate_return_message(DBusMessage      *message,
+                                               GeisSubscription  subscription)
+{
+  DBusMessage *reply   = NULL;
+  reply = dbus_message_new_method_return(message);
+  dbus_int32_t subscription_id = -1;
+
+  if (subscription)
+  {
+    subscription_id = geis_subscription_id(subscription);
+  }
+  dbus_message_append_args(reply,
+                           DBUS_TYPE_INT32, &subscription_id,
+                           DBUS_TYPE_INVALID);
+  return reply;
+}
+
+
+/*
+ * Indicates if a DBus message is a GEIS_DBUS_SUBSCRIPTION_DEACTIVATE message.
+ */
+GeisBoolean
+geis_dbus_message_is_subscription_deactivate_call(DBusMessage *message)
+{
+  return dbus_message_is_method_call(message,
+                                     GEIS_DBUS_SERVICE_INTERFACE,
+                                     GEIS_DBUS_SUBSCRIPTION_DEACTIVATE);
+}
+
+
+/*
+ * Creates a GEIS_DBUS_SUBSCRIPTION_DEACTIVATE method call message.
+ */
+DBusMessage *
+geis_dbus_subscription_deactivate_call_message(GeisSubscription subscription GEIS_UNUSED)
+{
+  DBusMessage *message   = NULL;
+  message = dbus_message_new_method_call(GEIS_DBUS_SERVICE_INTERFACE,
+                                         GEIS_DBUS_SERVICE_PATH,
+                                         GEIS_DBUS_SERVICE_INTERFACE,
+                                         GEIS_DBUS_SUBSCRIPTION_DEACTIVATE);
+  return message;
+}
+
+
+/**
+ */
+DBusMessage *
+geis_dbus_subscription_deactivate_return_message(DBusMessage      *message,
+                                                 GeisSubscription  subscription)
+{
+  DBusMessage *reply   = NULL;
+  reply = dbus_message_new_method_return(message);
+  dbus_int32_t subscription_id = geis_subscription_id(subscription);
+  dbus_message_append_args(reply,
+                           DBUS_TYPE_INT32, &subscription_id,
+                           DBUS_TYPE_INVALID);
+  return reply;
+}
+
+
+/*
+ * Indicates if a DBus message is a GEIS_DBUS_SUBSCRIPTION_DESTROY message.
+ */
+GeisBoolean
+geis_dbus_message_is_subscription_destroy_call(DBusMessage *message)
+{
+  return dbus_message_is_method_call(message,
+                                     GEIS_DBUS_SERVICE_INTERFACE,
+                                     GEIS_DBUS_SUBSCRIPTION_DESTROY);
+}
+
+
+/*
+ * Creates a GEIS_DBUS_SUBSCRIPTION_DESTROY method call message.
+ */
+DBusMessage *
+geis_dbus_subscription_destroy_call_message(GeisSubscription subscription)
+{
+  DBusMessage  *message   = NULL;
+  message = dbus_message_new_method_call(GEIS_DBUS_SERVICE_INTERFACE,
+                                         GEIS_DBUS_SERVICE_PATH,
+                                         GEIS_DBUS_SERVICE_INTERFACE,
+                                         GEIS_DBUS_SUBSCRIPTION_DESTROY);
+
+  dbus_int32_t server_sub_id = (intptr_t)geis_subscription_pdata(subscription);
+  dbus_message_append_args(message,
+                           DBUS_TYPE_INT32, &server_sub_id,
+                           DBUS_TYPE_INVALID);
+
+  return message;
+}
+
+
+/*
+ * Creates a GEIS_DBUS_SUBSCRIPTION_DESTROY method return message.
+ */
+DBusMessage *
+geis_dbus_subscription_destroy_return_message(DBusMessage *message)
+{
+ return dbus_message_new_method_return(message);
+}
+
+

=== added file 'libs/geis-dbus/geis_dbus_subscription.h'
--- libs/geis-dbus/geis_dbus_subscription.h	1970-01-01 00:00:00 +0000
+++ libs/geis-dbus/geis_dbus_subscription.h	2011-10-18 19:34:23 +0000
@@ -0,0 +1,206 @@
+/**
+ * @file geis_dbus_subscription.h
+ * @brief Interface for the GEIS DBus subscription transport.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef GEIS_DBUS_SUBSCRIPTION_H_
+#define GEIS_DBUS_SUBSCRIPTION_H_
+
+#include <dbus/dbus.h>
+#include "geis/geis.h"
+
+
+/**
+ * Indicates if a DBus message is a GEIS_DBUS_SUBSCRIPTION_CREATE method call.
+ *
+ * @param[in] message  A DBus message.
+ *
+ * This function is used on the server side to identify if a received message is
+ * a GEIS_DBUS_SUBSCRIPTION_CREATE method call.
+ *
+ * @returns GEIS_TRUE if the message is GEIS_DBUS_SUBSCRIPTION_CREATE,
+ *          GEIS_FALSE otherwise.
+ */
+GeisBoolean
+geis_dbus_message_is_subscription_create_call(DBusMessage *message);
+
+/**
+ * Creates a GEIS_DBUS_SUBSCRIPTION_CREATE method call message.
+ *
+ * @param[in] subscription  A GEIS subscription.
+ *
+ * This function is used on the client side to create a
+ * GEIS_DBUS_SUBSCRIPTION_CREATE method call message from a local
+ * %GeisSubscription object.
+ *
+ * @returns A DBus message object.
+ */
+DBusMessage *
+geis_dbus_subscription_create_call_message(GeisSubscription subscription);
+
+/**
+ * Creates a %GeisSubscription from a GEIS_DBUS_SUBSCRIPTION_CREATE method call
+ * message.
+ *
+ * @param[in] geis     A %Geis instance.
+ * @param[in] message  A DBus message.
+ *
+ * This function is used on the server side to create a subscription object to
+ * proxy the client-side subscription object.
+ *
+ * @returns a %GeisSubscription or NULL on failure.
+ */
+GeisSubscription
+geis_dbus_subscription_from_create_call_message(Geis geis, DBusMessage *message);
+
+/**
+ * Creates a GEIS_DBUS_SUBSCRIPTION_CREATE method return message.
+ *
+ * @param[in] message       The DBUs method_call message to reply to.
+ * @param[in] subscription  A GEIS subscription.
+ *
+ * This function is used on the server side to create a response to a received
+ * GEIS_DBUS_SUBSCRIPTION_CREATE method call message.
+ *
+ * @returns A DBus message object.
+ */
+DBusMessage *
+geis_dbus_subscription_create_return_message(DBusMessage      *message,
+                                             GeisSubscription  subscription);
+
+/**
+ * Indicates if a DBus message is a GEIS_DBUS_SUBSCRIPTION_ACTIVATE message.
+ *
+ * @param[in] message  A DBus message.
+ *
+ * @returns GEIS_TRUE if the message is GEIS_DBUS_SUBSCRIPTION_ACTIVATE,
+ *          GEIS_FALSE otherwise.
+ */
+GeisBoolean
+geis_dbus_message_is_subscription_activate_call(DBusMessage *message);
+
+/**
+ * Creates a GEIS_DBUS_SUBSCRIPTION_ACTIVATE method call message.
+ *
+ * @param[in] subscription  A GEIS subscription.
+ *
+ * This function is used on the client side to create a
+ * GEIS_DBUS_SUBSCRIPTION_ACTIVATE method call message from a local
+ * %GeisSubscription object.
+ *
+ * @returns A DBus message object.
+ */
+DBusMessage *
+geis_dbus_subscription_activate_call_message(GeisSubscription subscription);
+
+/**
+ * Creates a GEIS_DBUS_SUBSCRIPTION_ACTIVATE method return message.
+ *
+ * @param[in] message       The DBUs method_call message to reply to.
+ * @param[in] subscription  A GEIS subscription.
+ *
+ * This function is used on the server side to create a response to a received
+ * GEIS_DBUS_SUBSCRIPTION_ACTIVATE method call message.
+ *
+ * @returns A DBus message object.
+ */
+DBusMessage *
+geis_dbus_subscription_activate_return_message(DBusMessage      *message,
+                                               GeisSubscription  subscription);
+
+/**
+ * Indicates if a DBus message is a GEIS_DBUS_SUBSCRIPTION_DEACTIVATE message.
+ *
+ * @param[in] message  A DBus message.
+ *
+ * @returns GEIS_TRUE if the message is GEIS_DBUS_SUBSCRIPTION_DEACTIVATE,
+ *          GEIS_FALSE otherwise.
+ */
+GeisBoolean
+geis_dbus_message_is_subscription_deactivate_call(DBusMessage *message);
+
+/**
+ * Creates a GEIS_DBUS_SUBSCRIPTION_DEACTIVATE method return message.
+ *
+ * @param[in] message       The DBUs method_call message to reply to.
+ * @param[in] subscription  A GEIS subscription.
+ *
+ * This function is used on the server side to create a response to a received
+ * GEIS_DBUS_SUBSCRIPTION_DEACTIVATE method call message.
+ *
+ * @returns A DBus message object.
+ */
+DBusMessage *
+geis_dbus_subscription_deactivate_return_message(DBusMessage      *message,
+                                                 GeisSubscription  subscription);
+
+/**
+ * Creates a GEIS_DBUS_SUBSCRIPTION_DEACTIVATE method call message.
+ *
+ * @param[in] subscription  A GEIS subscription.
+ *
+ * This function is used on the client side to create a
+ * GEIS_DBUS_SUBSCRIPTION_DEACTIVATE method call message from a local
+ * %GeisSubscription object.
+ *
+ * @returns A DBus message object.
+ */
+DBusMessage *
+geis_dbus_subscription_deactivate_call_message(GeisSubscription subscription);
+
+/**
+ * Indicates if a DBus message is a GEIS_DBUS_SUBSCRIPTION_DESTROY message.
+ *
+ * @param[in] message  A DBus message.
+ *
+ * @returns GEIS_TRUE if the message is GEIS_DBUS_SUBSCRIPTION_DESTROY,
+ *          GEIS_FALSE otherwise.
+ */
+GeisBoolean
+geis_dbus_message_is_subscription_destroy_call(DBusMessage *message);
+
+/**
+ * Creates a GEIS_DBUS_SUBSCRIPTION_DESTROY method call message.
+ *
+ * @param[in] subscription  A GEIS subscription.
+ *
+ * This function is used on the client side to create a
+ * GEIS_DBUS_SUBSCRIPTION_DESTROY method call message from a local
+ * %GeisSubscription object.
+ *
+ * @returns A DBus message object.
+ */
+DBusMessage *
+geis_dbus_subscription_destroy_call_message(GeisSubscription subscription);
+
+/**
+ * Creates a GEIS_DBUS_SUBSCRIPTION_DESTROY method return message.
+ *
+ * @param[in] message       The DBUs method_call message to reply to.
+ *
+ * This function is used on the server side to create a response to a received
+ * GEIS_DBUS_SUBSCRIPTION_DESTROY method call message.
+ *
+ * @returns A DBus message object.
+ */
+DBusMessage *
+geis_dbus_subscription_destroy_return_message(DBusMessage *message);
+
+
+#endif /* GEIS_DBUS_SUBSCRIPTION_H_ */

=== modified file 'libutouch-geis/Makefile.am'
--- libutouch-geis/Makefile.am	2011-08-17 15:48:51 +0000
+++ libutouch-geis/Makefile.am	2011-10-18 19:34:23 +0000
@@ -39,6 +39,7 @@
 	geis_event.h                geis_event.c \
 	geis_event_queue.h          geis_event_queue.c \
 	geis_filter.h               geis_filter.c \
+	geis_filterable.h           geis_filterable.c \
 	geis_filter_term.h          geis_filter_term.c \
 	geis_frame.h                geis_frame.c \
 	geis_gesture_flick.h        geis_gesture_flick.c \
@@ -56,6 +57,8 @@
 	-I$(top_srcdir) \
 	-I$(top_srcdir)/include \
 	-I$(srcdir)/backend \
+	-I$(top_srcdir)/libs/geis-dbus \
+	$(DBUS_CFLAGS) \
 	$(GRAIL_CFLAGS) 
 
 libutouch_geis_la_LDFLAGS = \
@@ -66,8 +69,10 @@
 
 libutouch_geis_la_LIBADD = \
 	${builddir}/backend/test_fixture/libutouch-geis-test-fixture.la \
+	${builddir}/backend/dbus/libutouch-geis-dbus-backend.la \
 	${builddir}/backend/xcb/libutouch-geis-xcb-backend.la \
 	${builddir}/server/libutouch-geis-dbus-server.la \
+	$(top_builddir)/libs/geis-dbus/libgeis-dbus.la \
 	$(top_builddir)/libs/xcb/libxcb-gesture.la 
 
 EXTRA_DIST = $(version_script)

=== modified file 'libutouch-geis/backend/Makefile.am'
--- libutouch-geis/backend/Makefile.am	2011-01-17 14:58:27 +0000
+++ libutouch-geis/backend/Makefile.am	2011-10-18 19:34:23 +0000
@@ -19,5 +19,5 @@
 # 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 #
 
-SUBDIRS = test_fixture xcb
+SUBDIRS = test_fixture xcb dbus
 

=== added directory 'libutouch-geis/backend/dbus'
=== added file 'libutouch-geis/backend/dbus/Makefile.am'
--- libutouch-geis/backend/dbus/Makefile.am	1970-01-01 00:00:00 +0000
+++ libutouch-geis/backend/dbus/Makefile.am	2011-10-18 19:34:23 +0000
@@ -0,0 +1,34 @@
+#
+# @file libutouch-geis/backend/xcb/Makefile.am
+# @brief automake recipe for the uTouch GEIS v2.0 XCB back end
+#
+# Copyright 2011 Canonical, Ltd.
+#
+# This file is part of the utouch-geis library. 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 General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/
+#
+
+noinst_LTLIBRARIES = libutouch-geis-dbus-backend.la
+
+libutouch_geis_dbus_backend_la_SOURCES = \
+	geis_dbus_backend.c \
+	geis_dbus_client.h   geis_dbus_client.c \
+	geis_dbus_locator.h  geis_dbus_locator.c
+
+libutouch_geis_dbus_backend_la_CPPFLAGS = \
+	-I$(top_srcdir) \
+	-I$(top_srcdir)/libs/geis-dbus \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/libutouch-geis \
+	$(DBUS_CFLAGS)
+

=== added file 'libutouch-geis/backend/dbus/geis_dbus_backend.c'
--- libutouch-geis/backend/dbus/geis_dbus_backend.c	1970-01-01 00:00:00 +0000
+++ libutouch-geis/backend/dbus/geis_dbus_backend.c	2011-10-18 19:34:23 +0000
@@ -0,0 +1,249 @@
+/**
+ * @file geis_dbus_backend.c
+ * @brief GEIS DBus client back end
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "geis_config.h"
+#include "geis_backend.h"
+#include "geis_backend_protected.h"
+
+#include "geis_dbus_client.h"
+#include "geis_event.h"
+#include "geis_logging.h"
+#include "geis_private.h"
+
+
+/**
+ * @addtogroup geis_backend_dbus GEIS DBus Back End
+ * @ingroup geis_backends
+ *
+ * A GEIS Back End that is a DBus client, for connecting to a single central
+ * GEIS service offering data over the DBus.
+ *
+ * @{
+ */
+
+/** The opaque DBus Back End type. */
+typedef struct GeisDBusBackend *GeisDBusBackend;
+
+/** The less opaque DBus Back End structure. */
+struct GeisDBusBackend
+{
+  Geis            geis;
+  GeisDBusClient  dbus_client;
+};
+
+/** The DBus Back End token type */
+typedef struct GeisDBusToken
+{
+  struct GeisBackendToken base;
+  GeisDBusBackend         be;
+} *GeisDBusToken;
+
+
+/**
+ * Converts from a GeisBackendToken to an XcbBackendToken.
+ */
+static inline GeisDBusToken
+_geis_dbus_token_from_geis_token(GeisBackendToken gbt)
+{
+  return (GeisDBusToken)gbt;
+}
+
+
+/**
+ * Allocates memory for a token from a pool.
+ */
+static GeisDBusToken
+_geis_dbus_token_allocate(void)
+{
+  return calloc(1, sizeof(struct GeisDBusToken));
+}
+
+
+/**
+ * Returns memory for a token to a pool.
+ */
+static void
+_geis_dbus_token_deallocate(GeisDBusToken gdt)
+{
+  free(gdt);
+}
+
+
+/**
+ * Deep-copy-constructs a token.
+ */
+static GeisBackendToken
+_geis_dbus_token_clone(GeisBackendToken original)
+{
+  return original;
+}
+
+
+/**
+ * Releases resources for a token.
+ *
+ * @param[in] token  A %GeisDBusToken.
+ */
+static void             
+_geis_dbus_token_finalize(GeisBackendToken token GEIS_UNUSED)
+{
+  GeisDBusToken gdt = _geis_dbus_token_from_geis_token(token);
+  _geis_dbus_token_deallocate(gdt);
+}
+
+
+/**
+ * Composes one token onto another.
+ *
+ * @param[in,out] lhs
+ * @param[in]     rhs
+ */
+static void             
+_geis_dbus_token_compose(GeisBackendToken lhs GEIS_UNUSED,
+                         GeisBackendToken rhs GEIS_UNUSED)
+{
+}
+
+
+/**
+ * Activates a DBus back end token.
+ *
+ * @param[in] token        A %GeisDBusToken.
+ * @param[in] subscription The subscrition the token will be activated on.
+ *
+ * Sends a request to the server to activate a subscription with the tokenized
+ * content.
+ *
+ * @returns GEIS_STATUS_SUCCESS.
+ */
+static GeisStatus       
+_geis_dbus_token_activate(GeisBackendToken token, GeisSubscription subscription)
+{
+  GeisDBusToken gdt = _geis_dbus_token_from_geis_token(token);
+  geis_dbus_client_subscribe(gdt->be->dbus_client, subscription);
+  return GEIS_STATUS_SUCCESS;
+}
+
+
+/**
+ * Deactivates a DBus back end token.
+ *
+ * @param[in] token        A %GeisDBusToken.
+ */
+static GeisStatus       
+_geis_dbus_token_deactivate(GeisBackendToken token, GeisSubscription subscription)
+{
+  GeisDBusToken gdt = _geis_dbus_token_from_geis_token(token);
+  geis_dbus_client_unsubscribe(gdt->be->dbus_client, subscription);
+  return GEIS_STATUS_UNKNOWN_ERROR;
+}
+
+
+static struct GeisBackendTokenVtable _token_vtbl = {
+  _geis_dbus_token_clone,
+  _geis_dbus_token_finalize,
+  _geis_dbus_token_compose,
+  _geis_dbus_token_activate,
+  _geis_dbus_token_deactivate,
+};
+
+
+/**
+ * Constructs a DBus back end.
+ *
+ * @param[in] mem
+ * @param[in] geis
+ */
+static void
+_geis_dbus_backend_construct(void *mem, Geis geis)
+{
+  GeisDBusBackend gdb = (GeisDBusBackend)mem;
+  gdb->geis = geis;
+
+  gdb->dbus_client = geis_dbus_client_new(geis);
+  if (!gdb->dbus_client)
+  {
+    geis_error("error creating GEIS DBus client");
+    goto final_exit;
+  }
+
+final_exit:
+  return;
+}
+
+
+/**
+ * Deconstructs a DBus back end.
+ *
+ * @param[in] be  A %GeisDBusBackend.
+ */
+static void 
+_geis_dbus_backend_finalize(GeisBackend be)
+{
+  GeisDBusBackend gdb = (GeisDBusBackend)be;
+  geis_dbus_client_delete(gdb->dbus_client);
+}
+
+
+/**
+ * Creates DBus-back-end-specific back end token.
+ */
+static GeisBackendToken
+_geis_dbus_backend_create_token(GeisBackend be,
+                                GeisBackendTokenInitState init_state GEIS_UNUSED)
+{
+  GeisDBusBackend gdb = (GeisDBusBackend)be;
+  GeisDBusToken token = _geis_dbus_token_allocate();
+  if (token)
+  {
+    token->base.vtbl = &_token_vtbl;
+    token->be = gdb;
+  }
+  return (GeisBackendToken)token;
+}
+
+
+static struct GeisBackendVtable gdb_vtbl = {
+  _geis_dbus_backend_construct,
+  _geis_dbus_backend_finalize,
+  _geis_dbus_backend_create_token,
+};
+
+
+/**
+ * Registers the back end with the GEIS back end registry.
+ */
+static void __attribute__((constructor))
+_register_dbus_backend(void)
+{
+  geis_register_backend(GEIS_INIT_UTOUCH_DBUS_BACKEND,
+                        sizeof(struct GeisDBusBackend),
+                        &gdb_vtbl);
+}
+
+
+/** A dummy routine to force linkage of this module without dlopening it */
+void
+geis_include_dbus_backend(void)
+{
+}
+
+/** @} */

=== added file 'libutouch-geis/backend/dbus/geis_dbus_client.c'
--- libutouch-geis/backend/dbus/geis_dbus_client.c	1970-01-01 00:00:00 +0000
+++ libutouch-geis/backend/dbus/geis_dbus_client.c	2011-10-18 19:34:23 +0000
@@ -0,0 +1,685 @@
+/**
+ * @file geis_dbus_client.c
+ * @brief Implementations of the GEIS DBus client.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "geis_config.h"
+#include "geis_dbus_client.h"
+
+#include "geis_dbus.h"
+#include "geis_dbus_class.h"
+#include "geis_dbus_device.h"
+#include "geis_dbus_gesture_event.h"
+#include "geis_dbus_locator.h"
+#include "geis_dbus_region.h"
+#include "geis_dbus_subscription.h"
+#include "geis_event.h"
+#include "geis_logging.h"
+#include "geis_private.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+
+typedef enum GeisDBusClientState
+{
+  GEIS_DBUS_CLIENT_DISCONNECTED,   /* no server available */
+  GEIS_DBUS_CLIENT_INITIALIZING,   /* server connected, client initializing */
+  GEIS_DBUS_CLIENT_CONNECTING,     /* server connected, not initialized */
+  GEIS_DBUS_CLIENT_CONNECTED       /* server connected, all systems go */
+} GeisDBusClientState;
+
+
+struct GeisDBusClient
+{
+  Geis                geis;
+  GeisDBusDispatcher  dispatcher;
+  GeisDBusLocator     locator;
+  GeisDBusClientState state;
+  DBusConnection     *connection;
+  GeisSubBag          subscription_bag;
+};
+
+
+/**
+ * Handles a device-available message from the server.
+ *
+ * @param[in] client  A %GeisDBusClient.
+ * @param[in] message The %DBusMessage.
+ */
+static void
+_client_device_available(GeisDBusClient client, DBusMessage *message)
+{
+  GeisDevice device = geis_dbus_device_device_from_available_message(message);
+  if (device)
+  {
+    geis_register_device(client->geis, device, 0, NULL);
+  }
+  else
+  {
+    geis_error("no device received from remote back end");
+  }
+}
+
+
+/**
+ * Handles a device-unavailable message from the server.
+ *
+ * @param[in] client  A %GeisDBusClient.
+ * @param[in] message The %DBusMessage.
+ */
+static void
+_client_device_unavailable(GeisDBusClient client, DBusMessage *message)
+{
+  GeisDevice device = geis_dbus_device_device_from_unavailable_message(message);
+  if (device)
+  {
+    geis_unregister_device(client->geis, device);
+  }
+  else
+  {
+    geis_error("no device received from remote back end");
+  }
+}
+
+
+/**
+ * Handles a class-available message from the server.
+ *
+ * @param[in] client  A %GeisDBusClient.
+ * @param[in] message The %DBusMessage.
+ */
+static void
+_client_class_available(GeisDBusClient client, DBusMessage *message)
+{
+  GeisGestureClass gesture_class;
+
+  gesture_class = geis_dbus_class_class_from_available_message(message);
+  if (gesture_class)
+  {
+    geis_register_gesture_class(client->geis, gesture_class, 0, NULL);
+  }
+  else
+  {
+    geis_error("no gesture class received from remote back end");
+  }
+}
+
+
+/**
+ * Handles a region-available message from the server.
+ *
+ * @param[in] client  A %GeisDBusClient.
+ * @param[in] message The %DBusMessage.
+ */
+static void
+_client_region_available(GeisDBusClient client, DBusMessage *message)
+{
+  GeisFilterableAttribute attr;
+
+  attr = geis_dbus_region_from_region_available_message(message);
+  if (attr)
+  {
+    attr->add_term_callback = 0;
+    attr->add_term_context = 0;
+    geis_register_region(client->geis, NULL, 1, attr);
+  }
+  else
+  {
+    geis_error("no region attr received from remote back end");
+  }
+}
+
+
+/**
+ * Handles a class-unavailable message from the server.
+ *
+ * @param[in] client  A %GeisDBusClient.
+ * @param[in] message The %DBusMessage.
+ */
+static void
+_client_gesture_event(GeisDBusClient client, DBusMessage *message)
+{
+  GeisEvent event = geis_dbus_gesture_event_from_message(client->geis, message);
+  if (!event)
+  {
+    geis_error("no gesture event received from remote back end");
+  }
+  else
+  {
+    geis_post_event(client->geis, event);
+  }
+}
+
+
+/**
+ * Processes an subscription-activate reply from the server.
+ *
+ * @param[in] pending    A DBusPendingCall object.
+ * @param[in] user_data  The %GeisDBusClient object.
+ */
+static void
+_geis_dbus_client_activate_reply(DBusPendingCall *pending, void *user_data)
+{
+  GeisDBusClient client GEIS_UNUSED = (GeisDBusClient)user_data;
+  DBusMessage *reply = dbus_pending_call_steal_reply(pending);
+
+  if (DBUS_MESSAGE_TYPE_ERROR == dbus_message_get_type(reply))
+  {
+    const char *s = NULL;
+    dbus_message_get_args(reply, NULL, DBUS_TYPE_STRING, &s, DBUS_TYPE_INVALID);
+    geis_error("error %s: %s", dbus_message_get_error_name(reply), s);
+  }
+}
+
+
+/**
+ * Processes a subscription-create reply from the server.
+ *
+ * @param[in] pending    A DBusPendingCall object.
+ * @param[in] user_data  The %GeisDBusClient object.
+ */
+static void
+_geis_dbus_client_subscribe_reply(DBusPendingCall *pending, void *user_data)
+{
+  GeisDBusClient client = (GeisDBusClient)user_data;
+  DBusMessage *reply = dbus_pending_call_steal_reply(pending);
+
+  if (DBUS_MESSAGE_TYPE_ERROR == dbus_message_get_type(reply))
+  {
+    const char *s = NULL;
+    dbus_message_get_args(reply, NULL, DBUS_TYPE_STRING, &s, DBUS_TYPE_INVALID);
+    geis_error("error %s: %s", dbus_message_get_error_name(reply), s);
+  }
+  else
+  {
+    DBusMessage *msg;
+    DBusPendingCall *pending;
+    DBusError error = DBUS_ERROR_INIT;
+    dbus_int32_t client_sub_id;
+    dbus_int32_t server_sub_id;
+    GeisSubscription subscription;
+
+    dbus_message_get_args(reply,
+                          &error,
+                          DBUS_TYPE_INT32, &client_sub_id,
+                          DBUS_TYPE_INT32, &server_sub_id,
+                          DBUS_TYPE_INVALID);
+    if (dbus_error_is_set(&error))
+    {
+      geis_error("error %s: %s", error.name, error.message);
+      dbus_error_free(&error);
+    }
+
+    subscription = geis_subscription_bag_find(client->subscription_bag,
+                                              client_sub_id);
+    if (!subscription)
+    {
+      geis_error("invalid client subcription id %d returned from server",
+                 client_sub_id);
+    }
+    else
+    {
+      geis_subscription_set_pdata(subscription, (GeisPointer)(intptr_t)server_sub_id);
+
+      msg = geis_dbus_subscription_activate_call_message(subscription);
+      dbus_connection_send_with_reply(client->connection, msg, &pending, -1);
+      dbus_message_unref(msg);
+      if (!pending)
+      {
+        geis_error("error sending DBus CreateSubscription method call");
+      }
+      else
+      {
+        dbus_pending_call_set_notify(pending,
+                                     _geis_dbus_client_activate_reply,
+                                     client, 0);
+      }
+    }
+  }
+
+  dbus_message_unref(reply);
+  dbus_pending_call_unref(pending);
+}
+
+
+/**
+ * Processes a deactivate-subscription reply from the server.
+ *
+ * @param[in] pending    A DBusPendingCall object.
+ * @param[in] user_data  The %GeisDBusClient object.
+ */
+static void
+_geis_dbus_client_unsubscribe_reply(DBusPendingCall *pending, void *user_data)
+{
+  GeisDBusClient client GEIS_UNUSED = (GeisDBusClient)user_data;
+  DBusMessage *reply = dbus_pending_call_steal_reply(pending);
+
+  if (DBUS_MESSAGE_TYPE_ERROR == dbus_message_get_type(reply))
+  {
+    const char *s = NULL;
+    dbus_message_get_args(reply, NULL, DBUS_TYPE_STRING, &s, DBUS_TYPE_INVALID);
+    geis_error("error %s: %s", dbus_message_get_error_name(reply), s);
+  }
+  else
+  {
+    geis_warning("signature=\"%s\"", dbus_message_get_signature(reply));
+    geis_warning("path=\"%s\"", dbus_message_get_path(reply));
+    geis_warning("interface=\"%s\"", dbus_message_get_interface(reply));
+    geis_warning("member=\"%s\"", dbus_message_get_member(reply));
+  }
+
+  dbus_message_unref(reply);
+  dbus_pending_call_unref(pending);
+}
+
+
+/**
+ * Creates a remote subscription.
+ */
+void
+_dbus_client_subscribe(GeisDBusClient   client,
+                       GeisSubscription subscription)
+{
+  DBusPendingCall *pending_return;
+
+  GeisSubscription sub = geis_subscription_bag_find(client->subscription_bag,
+                                 geis_subscription_id(subscription));
+  if (sub && geis_subscription_pdata(sub))
+  {
+    geis_warning("subscription already activated!");
+  }
+  else
+  {
+    DBusMessage *msg = geis_dbus_subscription_create_call_message(subscription);
+    dbus_connection_send_with_reply(client->connection, msg, &pending_return, -1);
+    dbus_message_unref(msg);
+    if (!pending_return)
+    {
+      geis_error("error sending DBus CreateSubscription method call");
+    }
+    else
+    {
+      dbus_pending_call_set_notify(pending_return,
+                                   _geis_dbus_client_subscribe_reply,
+                                   client, 0);
+    }
+  }
+}
+
+
+/**
+ * Re-subscribes all existing sibscriptions when the server appears or
+ * reappears.
+ */
+void
+_dbus_client_resubscribe_all(GeisDBusClient client)
+{
+  GeisSubBagIterator it;
+  for (it = geis_subscription_bag_begin(client->subscription_bag);
+       it != geis_subscription_bag_end(client->subscription_bag);
+       it = geis_subscription_bag_iterator_next(client->subscription_bag, it))
+  {
+    geis_subscription_set_pdata(*it, 0);
+    _dbus_client_subscribe(client, *it);
+  }
+}
+
+
+/**
+ * The DBus message dispatch function for the GEIS DBus client.
+ *
+ * @param[in] connection  The %GeisDBusClient DBus connection.
+ * @param[in] message     The DBus message received.
+ * @param[in] user_data   The %GeisDBusClient.
+ */
+static DBusHandlerResult
+_geis_dbus_client_message_handler(DBusConnection *connection GEIS_UNUSED,
+                                  DBusMessage    *message,
+                                  void           *user_data)
+{
+  DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+  GeisDBusClient client = (GeisDBusClient)user_data;
+  int type = dbus_message_get_type(message);
+
+  if (dbus_message_is_signal(message,
+                             DBUS_INTERFACE_LOCAL,
+                             "Disconnected"))
+  {
+    geis_warning("server disconnected?");
+    result = DBUS_HANDLER_RESULT_HANDLED;
+  }
+  else if (dbus_message_is_signal(message,
+                                  GEIS_DBUS_SERVICE_INTERFACE,
+                                  GEIS_DBUS_DEVICE_AVAILABLE))
+  {
+    _client_device_available(client, message);
+    result = DBUS_HANDLER_RESULT_HANDLED;
+  }
+  else if (dbus_message_is_signal(message,
+                                  GEIS_DBUS_SERVICE_INTERFACE,
+                                  GEIS_DBUS_DEVICE_UNAVAILABLE))
+
+  {
+    _client_device_unavailable(client, message);
+    result = DBUS_HANDLER_RESULT_HANDLED;
+  }
+  else if (dbus_message_is_signal(message,
+                                  GEIS_DBUS_SERVICE_INTERFACE,
+                                  GEIS_DBUS_CLASS_AVAILABLE))
+  {
+    _client_class_available(client, message);
+    result = DBUS_HANDLER_RESULT_HANDLED;
+  }
+  else if (dbus_message_is_signal(message,
+                                  GEIS_DBUS_SERVICE_INTERFACE,
+                                  GEIS_DBUS_REGION_AVAILABLE))
+  {
+    _client_region_available(client, message);
+    result = DBUS_HANDLER_RESULT_HANDLED;
+  }
+  else if (dbus_message_is_signal(message,
+                                  GEIS_DBUS_SERVICE_INTERFACE,
+                                  GEIS_DBUS_INIT_COMPLETE))
+  {
+    if (client->state == GEIS_DBUS_CLIENT_INITIALIZING)
+    {
+      geis_post_event(client->geis, geis_event_new(GEIS_EVENT_INIT_COMPLETE));
+    }
+    client->state = GEIS_DBUS_CLIENT_CONNECTED;
+    _dbus_client_resubscribe_all(client);
+    result = DBUS_HANDLER_RESULT_HANDLED;
+  }
+  else if (geis_dbus_message_is_gesture_event(message))
+  {
+    _client_gesture_event(client, message);
+    result = DBUS_HANDLER_RESULT_HANDLED;
+  }
+  else if (type == DBUS_MESSAGE_TYPE_ERROR)
+  {
+    const char *str = NULL;
+    dbus_message_get_args(message, NULL,
+                          DBUS_TYPE_STRING, &str,
+                          DBUS_TYPE_INVALID);
+    geis_warning("error %s: %s", dbus_message_get_error_name(message), str);
+  }
+  else 
+  {
+    geis_warning("unhandled DBus %s received:",
+                 dbus_message_type_to_string(dbus_message_get_type(message)));
+    geis_warning("  signature=\"%s\"", dbus_message_get_signature(message));
+    geis_warning("  sender=\"%s\"", dbus_message_get_sender(message));
+    geis_warning("  path=\"%s\"",
+                 dbus_message_get_path(message) ?
+                 dbus_message_get_path(message) :
+                 "(no path)");
+    geis_warning("  interface=\"%s\"",
+                 dbus_message_get_interface(message) ?
+                 dbus_message_get_interface(message) :
+                 "(no interface)");
+    geis_warning("  member=\"%s\"",
+                 dbus_message_get_member(message) ?
+                 dbus_message_get_member(message) :
+                 "(no member)");
+  }
+  return result;
+}
+
+
+/**
+ * Adds the client watches to the dispatcher watch list.
+ *
+ * @param[in] watch  A %DBusWatch.
+ * @param[in] data   The %GeisDBusClientProxy.
+ */
+static dbus_bool_t
+_client_add_watch(DBusWatch *watch, void *data)
+{
+  dbus_bool_t status = TRUE;
+  GeisDBusClient client = (GeisDBusClient)data;
+
+  geis_dbus_dispatcher_register(client->dispatcher, client->connection, watch);
+  return status;
+}
+
+
+/**
+ * Toggles the enabled/disabled status of the client watches.
+ *
+ * @param[in] watch  A %DBusWatch.
+ * @param[in] data   The %GeisDBusClientProxy.
+ */
+static void
+_client_toggle_watch(DBusWatch *watch, void *data)
+{
+  GeisDBusClient client = (GeisDBusClient)data;
+
+  geis_dbus_dispatcher_toggle_watch(client->dispatcher, watch);
+}
+
+
+/**
+ * Removes the client watches from the dispatcher watch list.
+ *
+ * @param[in] watch  A %DBusWatch.
+ * @param[in] data   The %GeisDBusClientProxy.
+ */
+static void
+_client_remove_watch(DBusWatch *watch, void *data)
+{
+  GeisDBusClient client = (GeisDBusClient)data;
+
+  geis_dbus_dispatcher_unregister(client->dispatcher, watch);
+}
+
+
+/**
+ * Connects to the GEIS server once an address is located.
+ *
+ * @param[in] client  A %GeisDBusClient object.
+ * @param[in] address The address of the server.
+ */
+static void
+_client_connect(GeisDBusClient client, const char *address)
+{
+  geis_debug("server address=\"%s\"", address);
+  DBusError error = DBUS_ERROR_INIT;
+  client->connection = dbus_connection_open(address, &error);
+  if (!client->connection || dbus_error_is_set(&error))
+  {
+    char msg[512];
+    snprintf(msg, sizeof(msg), "error %s connecting to server at address %s: %s",
+            error.name, address, error.message);
+    geis_error("%s", msg);
+    dbus_error_free(&error);
+    goto final_exit;
+  }
+
+  /* Integrate with the app event loop via the GEIS multiplexor. */
+  dbus_connection_set_watch_functions(client->connection,
+                                      _client_add_watch,
+                                      _client_remove_watch,
+                                      _client_toggle_watch,
+                                      client, 0);
+
+  /* Install a handler for any and all messages. */
+  dbus_connection_add_filter(client->connection,
+                             _geis_dbus_client_message_handler,
+                             client, 0);
+  if (client->state != GEIS_DBUS_CLIENT_INITIALIZING)
+  {
+    client->state = GEIS_DBUS_CLIENT_CONNECTING;
+  }
+
+final_exit:
+  return;
+}
+
+
+/*
+ * Creates a new GeisDBusClient.
+ */
+GeisDBusClient
+geis_dbus_client_new(Geis geis)
+{
+  GeisDBusClient client = calloc(1, sizeof(struct GeisDBusClient));
+  if (!client)
+  {
+    goto final_exit;
+  }
+
+  client->geis = geis;
+  client->state = GEIS_DBUS_CLIENT_INITIALIZING;
+
+  client->dispatcher = geis_dbus_dispatcher_new(geis);
+  if (!client->dispatcher)
+  {
+    goto unwind_client;
+  }
+
+  client->locator = geis_dbus_locator_new(client);
+  if (!client->locator)
+  {
+    goto unwind_dispatcher;
+  }
+
+  client->subscription_bag = geis_subscription_bag_new(1);
+  if (!client->subscription_bag)
+  {
+    goto unwind_locator;
+  }
+
+  goto final_exit;
+
+unwind_locator:
+  geis_dbus_locator_delete(client->locator);
+unwind_dispatcher:
+  geis_dbus_dispatcher_delete(client->dispatcher);
+unwind_client:
+  free(client);
+  client = NULL;
+final_exit:
+  return client;
+}
+
+
+/*
+ * Destroys a GeisDBusClient.
+ */
+void
+geis_dbus_client_delete(GeisDBusClient client)
+{
+  geis_subscription_bag_delete(client->subscription_bag);
+  geis_dbus_locator_delete(client->locator);
+  if (client->connection)
+  {
+    dbus_connection_unref(client->connection);
+  }
+  geis_dbus_dispatcher_delete(client->dispatcher);
+  free(client);
+}
+
+
+/*
+ * Gets the client dispatcher.
+ */
+GeisDBusDispatcher
+geis_dbus_client_dispatcher(GeisDBusClient client)
+{
+  return client->dispatcher;
+}
+
+
+/*
+ * Signals the client the server has been located.
+ */
+void
+geis_dbus_client_server_located(GeisDBusClient client)
+{
+  _client_connect(client, geis_dbus_locator_server_address(client->locator));
+}
+
+
+/*
+ * Signals the client the server has been dislocated.
+ */
+void
+geis_dbus_client_server_dislocated(GeisDBusClient client)
+{
+  GeisEvent event =  geis_event_new(GEIS_EVENT_ERROR);
+  client->state = GEIS_DBUS_CLIENT_DISCONNECTED;
+  geis_post_event(client->geis, event);
+}
+
+
+/*
+ * Requests a subscription on the remote end.
+ */
+GeisStatus
+geis_dbus_client_subscribe(GeisDBusClient   client,
+                           GeisSubscription subscription)
+{
+  GeisStatus status = GEIS_STATUS_SUCCESS;
+
+  if (client->state == GEIS_DBUS_CLIENT_CONNECTED)
+  {
+    _dbus_client_subscribe(client, subscription);
+  }
+  geis_subscription_bag_insert(client->subscription_bag, subscription);
+
+  return status;
+}
+
+
+/*
+ * Destroys a subscription on the remote end.
+ */
+GeisStatus
+geis_dbus_client_unsubscribe(GeisDBusClient   client,
+                             GeisSubscription subscription)
+{
+  GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
+  if (geis_subscription_bag_find(client->subscription_bag,
+                                 geis_subscription_id(subscription)))
+  {
+    DBusMessage *msg;
+    DBusPendingCall *pending_return;
+
+    msg = geis_dbus_subscription_destroy_call_message(subscription);
+    dbus_connection_send_with_reply(client->connection, msg, &pending_return, -1);
+    dbus_message_unref(msg);
+    if (!pending_return)
+    {
+      geis_error("error sending DBus CreateSubscription method call");
+      goto final_exit;
+    }
+
+    dbus_pending_call_set_notify(pending_return,
+                                 _geis_dbus_client_unsubscribe_reply,
+                                 client, 0);
+    geis_subscription_bag_remove(client->subscription_bag, subscription);
+    status = GEIS_STATUS_SUCCESS;
+  }
+
+final_exit:
+  return status;
+}
+
+
+
+

=== added file 'libutouch-geis/backend/dbus/geis_dbus_client.h'
--- libutouch-geis/backend/dbus/geis_dbus_client.h	1970-01-01 00:00:00 +0000
+++ libutouch-geis/backend/dbus/geis_dbus_client.h	2011-10-18 19:34:23 +0000
@@ -0,0 +1,97 @@
+/**
+ * @file geis_dbus_client.h
+ * @brief Interface for the GEIS DBus client.
+ *
+ * The GEIS DBus client offers remote GEIS functionality over a managed
+ * DBus connection.
+ *
+ * This header is for internal GEIS use only and contains no client
+ * (externally-visible) symbols.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef GEIS_DBUS_CLIENT_H_
+#define GEIS_DBUS_CLIENT_H_
+
+#include "geis/geis.h"
+#include "geis_dbus_dispatcher.h"
+
+
+typedef struct GeisDBusClient *GeisDBusClient;
+
+
+/**
+ * Creates a new %GeisDBusClient object.
+ */
+GeisDBusClient
+geis_dbus_client_new(Geis geis);
+
+/**
+ * Destroys a %GeisDBusClient.
+ *
+ * @param[in]  client  A GeisDBusClient.
+ */
+void
+geis_dbus_client_delete(GeisDBusClient client);
+
+/**
+ * Gets the client dispatcher.
+ *
+ * @param[in]  client  A GeisDBusClient.
+ */
+GeisDBusDispatcher
+geis_dbus_client_dispatcher(GeisDBusClient client);
+
+/**
+ * Signals the client the server has been located.
+ *
+ * @param[in]  client  A GeisDBusClient.
+ */
+void
+geis_dbus_client_server_located(GeisDBusClient client);
+
+/**
+ * Signals the client the server has been dislocated.
+ *
+ * @param[in]  client  A GeisDBusClient.
+ */
+void
+geis_dbus_client_server_dislocated(GeisDBusClient client);
+
+/**
+ * Cerates a subscription on the remote end.
+ *
+ * @param[in] client       The client-side of the DBus connection.
+ * @param[in] subscription The local subscription object.
+ */
+GeisStatus
+geis_dbus_client_subscribe(GeisDBusClient   client,
+                           GeisSubscription subscription);
+
+/**
+ * Deactivates a subscription on the remote end.
+ *
+ * @param[in] client       The client-side of the DBus connection.
+ * @param[in] subscription The local subscription object.
+ */
+GeisStatus
+geis_dbus_client_unsubscribe(GeisDBusClient   client,
+                             GeisSubscription subscription);
+
+
+#endif /* GEIS_DBUS_CLIENT_H_ */

=== added file 'libutouch-geis/backend/dbus/geis_dbus_locator.c'
--- libutouch-geis/backend/dbus/geis_dbus_locator.c	1970-01-01 00:00:00 +0000
+++ libutouch-geis/backend/dbus/geis_dbus_locator.c	2011-10-18 19:34:23 +0000
@@ -0,0 +1,270 @@
+/**
+ * @file geis_dbus_locator.c
+ * @brief Implementation of the GEIS DBus locator.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "geis_config.h"
+#include "geis_dbus_locator.h"
+
+#include <dbus/dbus.h>
+#include "geis_dbus.h"
+#include "geis_logging.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+typedef enum GeisDBusLocatorState
+{
+  GEIS_DBUS_LOCATOR_STATE_INITIALIZING,
+  GEIS_DBUS_LOCATOR_STATE_LOCATING,
+  GEIS_DBUS_LOCATOR_STATE_WAITING,
+  GEIS_DBUS_LOCATOR_STATE_FINALIZING
+} GeisDBusLocatorState;
+
+
+struct GeisDBusLocator 
+{
+  GeisDBusClient        client;
+  GeisDBusLocatorState  state;
+  DBusConnection       *session_bus;
+  char                 *server_address;
+  dbus_uint32_t         serial;
+};
+
+
+/*
+ * Performs the act of actually locating the server.
+ */
+static void
+_locator_find_server(GeisDBusLocator locator)
+{
+  locator->state = GEIS_DBUS_LOCATOR_STATE_LOCATING;
+  DBusMessage *msg = dbus_message_new_method_call(GEIS_DBUS_SERVICE_INTERFACE,
+                                                  GEIS_DBUS_SERVICE_PATH,
+                                                  GEIS_DBUS_SERVICE_INTERFACE,
+                                                  GEIS_DBUS_GET_SERVER_ADDRESS);
+  dbus_connection_send(locator->session_bus, msg, &locator->serial);
+  dbus_message_unref(msg);
+}
+
+
+/*
+ * A generic message handler function.
+ */
+static DBusHandlerResult
+_locator_message_handler(DBusConnection *connection GEIS_UNUSED,
+                         DBusMessage    *message,
+                         void           *user_data)
+{
+  DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+  GeisDBusLocator locator = (GeisDBusLocator)user_data;
+  int type = dbus_message_get_type(message);
+
+  if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameOwnerChanged"))
+  {
+    char *name;
+    char *old_owner;
+    char *new_owner;
+    dbus_message_get_args(message, NULL,
+                          DBUS_TYPE_STRING, &name,
+                          DBUS_TYPE_STRING, &old_owner,
+                          DBUS_TYPE_STRING, &new_owner,
+                          DBUS_TYPE_INVALID);
+    if (strlen(old_owner))
+    {
+      geis_debug("%s has gone away", name);
+      geis_dbus_client_server_dislocated(locator->client);
+      result = DBUS_HANDLER_RESULT_HANDLED;
+    }
+    else if (strlen(new_owner))
+    {
+      geis_debug("%s has appeared", name);
+      _locator_find_server(locator);
+      result = DBUS_HANDLER_RESULT_HANDLED;
+    }
+  }
+  else if (type == DBUS_MESSAGE_TYPE_METHOD_RETURN)
+  {
+    if (locator->serial == dbus_message_get_reply_serial(message))
+    {
+      const char *s = NULL;
+      dbus_message_get_args(message, NULL,
+                            DBUS_TYPE_STRING, &s,
+                            DBUS_TYPE_INVALID);
+      locator->server_address = strdup(s);
+      geis_dbus_client_server_located(locator->client);
+      result = DBUS_HANDLER_RESULT_HANDLED;
+    }
+  }
+  else if (type == DBUS_MESSAGE_TYPE_ERROR)
+  {
+    if (dbus_message_is_error(message, DBUS_ERROR_SERVICE_UNKNOWN))
+    {
+      geis_warning("server not found!");
+      geis_dbus_client_server_dislocated(locator->client);
+      result = DBUS_HANDLER_RESULT_HANDLED;
+    }
+    else
+    {
+      const char *str = NULL;
+      dbus_message_get_args(message, NULL,
+                            DBUS_TYPE_STRING, &str,
+                            DBUS_TYPE_INVALID);
+      geis_warning("error %s: %s", dbus_message_get_error_name(message), str);
+    }
+  }
+
+  return result;
+}
+
+
+/*
+ * Adds the locator watches to the dispatcher watch list.
+ */
+static dbus_bool_t
+_locator_add_watch(DBusWatch *watch, void *data)
+{
+  dbus_bool_t status = TRUE;
+  GeisDBusLocator locator = (GeisDBusLocator)data;
+  GeisDBusDispatcher dispatcher = geis_dbus_client_dispatcher(locator->client);
+
+  geis_dbus_dispatcher_register(dispatcher, locator->session_bus, watch);
+  return status;
+}
+
+
+/*
+ * Toggles the enabled/disabled status of the locator watches.
+ */
+static void
+_locator_toggle_watch(DBusWatch *watch, void *data)
+{
+  GeisDBusLocator locator = (GeisDBusLocator)data;
+  GeisDBusDispatcher dispatcher = geis_dbus_client_dispatcher(locator->client);
+
+  geis_dbus_dispatcher_toggle_watch(dispatcher, watch);
+}
+
+
+/*
+ * Removes the locator watches from the dispatcher watch list.
+ */
+static void
+_locator_remove_watch(DBusWatch *watch, void *data)
+{
+  GeisDBusLocator locator = (GeisDBusLocator)data;
+  GeisDBusDispatcher dispatcher = geis_dbus_client_dispatcher(locator->client);
+
+  geis_dbus_dispatcher_unregister(dispatcher, watch);
+}
+
+
+/*
+ * Creates a new GeisDBusLocator object.
+ */
+GeisDBusLocator
+geis_dbus_locator_new(GeisDBusClient client)
+{
+  GeisDBusLocator locator = calloc(1, sizeof(struct GeisDBusLocator));
+  if (!locator)
+  {
+    goto final_exit;
+  }
+
+  locator->client = client;
+  locator->state = GEIS_DBUS_LOCATOR_STATE_INITIALIZING;
+
+  /* Connect to the DBus session bus. */
+  DBusError error = DBUS_ERROR_INIT;
+  locator->session_bus = dbus_bus_get(DBUS_BUS_SESSION, &error);
+  if (!locator->session_bus || dbus_error_is_set(&error))
+  {
+    char msg[512];
+    snprintf(msg, sizeof(msg), "error %s connecting to session bus: %s",
+            error.name, error.message);
+    geis_error("%s", msg);
+    goto unwind_error;
+  }
+
+  /* Integrate with the app event loop via the GEIS multiplexor. */
+  dbus_connection_set_watch_functions(locator->session_bus,
+                                      _locator_add_watch,
+                                      _locator_remove_watch,
+                                      _locator_toggle_watch,
+                                      locator, 0);
+
+  /* Look for server-connect and server-disconnect messages. */
+  dbus_bus_add_match(locator->session_bus,
+                     "type='signal',sender='" DBUS_SERVICE_DBUS "'," \
+                     "interface='" DBUS_INTERFACE_DBUS "'," \
+                     "member='NameOwnerChanged'," \
+                     "arg0='" GEIS_DBUS_SERVICE_INTERFACE "'",
+                     &error);
+  if (dbus_error_is_set(&error))
+  {
+    char msg[512];
+    snprintf(msg, sizeof(msg), "error %s adding match to session bus: %s",
+            error.name, error.message);
+    geis_error("%s", msg);
+    goto unwind_error;
+  }
+
+  /* Install a handler for any and all messages. */
+  dbus_connection_add_filter(locator->session_bus,
+                             _locator_message_handler,
+                             locator, 0);
+
+  /* OK, go eh? */
+  _locator_find_server(locator);
+
+unwind_error:
+  dbus_error_free(&error);
+final_exit:
+  return locator;
+}
+
+
+/*
+ * Destroys a %GeisDBusLocator object.
+ */
+void
+geis_dbus_locator_delete(GeisDBusLocator locator)
+{
+  if (locator)
+  {
+    if (locator->server_address)
+    {
+      free(locator->server_address);
+    }
+    if (locator->session_bus)
+    {
+      dbus_connection_unref(locator->session_bus);
+    }
+    free(locator);
+  }
+}
+
+
+char *
+geis_dbus_locator_server_address(GeisDBusLocator locator)
+{
+  return locator->server_address;
+}
+

=== added file 'libutouch-geis/backend/dbus/geis_dbus_locator.h'
--- libutouch-geis/backend/dbus/geis_dbus_locator.h	1970-01-01 00:00:00 +0000
+++ libutouch-geis/backend/dbus/geis_dbus_locator.h	2011-10-18 19:34:23 +0000
@@ -0,0 +1,62 @@
+/**
+ * @file geis_dbus_locator.h
+ * @brief Interface for the GEIS DBus locator.
+ *
+ * The GEIS DBus locator makes the location of the GEIS DBus server available
+ * over the DBus session bus.
+ *
+ * This header is for internal GEIS use only and contains no client
+ * (externally-visible) symbols.
+ */
+
+/*
+ * 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 General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef GEIS_DBUS_LOCATOR_H_
+#define GEIS_DBUS_LOCATOR_H_
+
+#include "geis/geis.h"
+#include "geis_dbus_client.h"
+
+
+typedef struct GeisDBusLocator *GeisDBusLocator;
+
+
+/**
+ * Creates a new GeisDBusLocator object.
+ *
+ * @param[in]  client A GEIS DBus CLient.
+ */
+GeisDBusLocator
+geis_dbus_locator_new(GeisDBusClient client);
+
+/**
+ * Destroys a %GeisDBusLocator object.
+ *
+ * @param[in]  locator  A GeisDBusLocator.
+ */
+void
+geis_dbus_locator_delete(GeisDBusLocator locator);
+
+/**
+ * Gets the currently located server address.
+ *
+ * @param[in]  locator  A GeisDBusLocator.
+ */
+char *
+geis_dbus_locator_server_address(GeisDBusLocator locator);
+
+#endif /* GEIS_DBUS_LOCATOR_H_ */

=== modified file 'libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c'
--- libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c	2011-08-18 18:14:12 +0000
+++ libutouch-geis/backend/test_fixture/geis_backend_test_fixture.c	2011-10-18 19:34:23 +0000
@@ -77,8 +77,8 @@
 static GeisBackendToken _token_clone(GeisBackendToken);
 static void             _token_finalize(GeisBackendToken);
 static void             _token_compose(GeisBackendToken, GeisBackendToken);
-static GeisStatus       _token_activate(GeisBackendToken);
-static GeisStatus       _token_deactivate(GeisBackendToken);
+static GeisStatus       _token_activate(GeisBackendToken, GeisSubscription);
+static GeisStatus       _token_deactivate(GeisBackendToken, GeisSubscription);
 
 static struct GeisBackendTokenVtable _token_vtbl = {
   _token_clone,
@@ -361,7 +361,8 @@
 
 
 GeisStatus             
-_token_activate(GeisBackendToken gbtoken)
+_token_activate(GeisBackendToken gbtoken,
+                GeisSubscription subscription GEIS_UNUSED)
 {
   GeisStatus status = GEIS_STATUS_SUCCESS;
   TestBackendToken token = _tbtoken_from_token(gbtoken);
@@ -371,7 +372,8 @@
 
 
 GeisStatus             
-_token_deactivate(GeisBackendToken gbtoken GEIS_UNUSED)
+_token_deactivate(GeisBackendToken gbtoken GEIS_UNUSED,
+                  GeisSubscription subscription GEIS_UNUSED)
 {
   GeisStatus status = GEIS_STATUS_SUCCESS;
   return status;
@@ -381,7 +383,7 @@
 __attribute__((constructor))
 static void _register_test_fixture()
 {
-  geis_register_backend(GEIS_INIT_UTOUCH_MOCK_ENGINE,
+  geis_register_backend(GEIS_INIT_UTOUCH_MOCK_BACKEND,
                         sizeof(struct GeisBackendTestFixture),
                         &tf_vtbl);
 }

=== modified file 'libutouch-geis/backend/xcb/geis_xcb_backend.c'
--- libutouch-geis/backend/xcb/geis_xcb_backend.c	2011-09-02 15:52:27 +0000
+++ libutouch-geis/backend/xcb/geis_xcb_backend.c	2011-10-18 19:34:23 +0000
@@ -105,7 +105,7 @@
 static void _construct(void *mem, Geis geis);
 static void _finalize(GeisBackend g);
 static GeisBackendToken _create_token(GeisBackend be, GeisBackendTokenInitState);
-static void _fd_callback(int fd, GeisBackendMultiplexorEvent ev, void *ctx);
+static void _fd_callback(int fd, GeisBackendMultiplexorActivity ev, void *ctx);
 
 
 static struct GeisBackendVtable be_vtbl = {
@@ -116,7 +116,7 @@
 
 
 /* A handy little table to map grail types to geis gesture classes. */
-struct GrailTypeToGeisClass
+static struct GrailTypeToGeisClass
 {
   GeisInteger      grail_type;
   GeisGestureClass geis_class;
@@ -156,7 +156,8 @@
   { GRAIL_TYPE_MTOUCH, NULL }
 };
 
-GeisSize s_grail_type_map_size = sizeof(s_grail_type_map) / sizeof(struct GrailTypeToGeisClass);
+static GeisSize s_grail_type_map_size = sizeof(s_grail_type_map)
+                                      / sizeof(struct GrailTypeToGeisClass);
 
 static void
 _set_grail_type_class(GeisInteger grail_type, GeisGestureClass geis_class)
@@ -653,7 +654,8 @@
   }
 
   be->xcb_fd = xcb_get_file_descriptor(be->xcb_connection);
-  geis_multiplex_fd(be->geis, be->xcb_fd, _fd_callback, be);
+  geis_multiplex_fd(be->geis, be->xcb_fd, GEIS_BE_MX_READ_AVAILABLE,
+                    _fd_callback, be);
 
   be->sub_table = geis_xcb_backend_sub_table_new();
 
@@ -933,9 +935,9 @@
 
 /** @todo implement this */
 void
-_fd_callback(int                          fd GEIS_UNUSED,
-             GeisBackendMultiplexorEvent  ev GEIS_UNUSED,
-             void                        *ctx)
+_fd_callback(int                             fd GEIS_UNUSED,
+             GeisBackendMultiplexorActivity  ev GEIS_UNUSED,
+             void                           *ctx)
 {
   GeisXcbBackend be = (GeisXcbBackend)ctx;
   _xcb_dispatch(be);
@@ -1022,7 +1024,7 @@
 __attribute__((constructor))
 static void _register_xcb_backend()
 {
-  geis_register_backend(GEIS_INIT_UTOUCH_XCB,
+  geis_register_backend(GEIS_INIT_UTOUCH_XCB_BACKEND,
                         sizeof(struct GeisXcbBackend),
                         &be_vtbl);
 }

=== modified file 'libutouch-geis/backend/xcb/geis_xcb_backend_token.c'
--- libutouch-geis/backend/xcb/geis_xcb_backend_token.c	2011-08-29 18:41:20 +0000
+++ libutouch-geis/backend/xcb/geis_xcb_backend_token.c	2011-10-18 19:34:23 +0000
@@ -55,8 +55,8 @@
 static GeisBackendToken _token_clone(GeisBackendToken);
 static void             _token_finalize(GeisBackendToken);
 static void             _token_compose(GeisBackendToken, GeisBackendToken);
-static GeisStatus       _token_activate(GeisBackendToken);
-static GeisStatus       _token_deactivate(GeisBackendToken);
+static GeisStatus       _token_activate(GeisBackendToken, GeisSubscription);
+static GeisStatus       _token_deactivate(GeisBackendToken, GeisSubscription);
 
 static struct GeisBackendTokenVtable _token_vtbl = {
   _token_clone,
@@ -317,7 +317,7 @@
  * various back end subscriptions appropriately.
  */
 static GeisStatus             
-_token_activate(GeisBackendToken token)
+_token_activate(GeisBackendToken token, GeisSubscription subscripton GEIS_UNUSED)
 {
   GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
   XcbBackendToken t = _xcb_token_from_geis_token(token);
@@ -338,7 +338,7 @@
  * various back end subscriptions appropriately.
  */
 static GeisStatus             
-_token_deactivate(GeisBackendToken token)
+_token_deactivate(GeisBackendToken token, GeisSubscription sub GEIS_UNUSED)
 {
   GeisStatus status = GEIS_STATUS_SUCCESS;
   XcbBackendToken t = _xcb_token_from_geis_token(token);

=== modified file 'libutouch-geis/backend/xcb/grail_gestures.c'
--- libutouch-geis/backend/xcb/grail_gestures.c	2011-07-22 15:54:50 +0000
+++ libutouch-geis/backend/xcb/grail_gestures.c	2011-10-18 19:34:23 +0000
@@ -505,7 +505,7 @@
                                     (char *)grail_class->name);
       geis_frame_add_attr(frame, attr);
 
-      attr = geis_attr_new("geis gesture class id",
+      attr = geis_attr_new(GEIS_CLASS_ATTRIBUTE_ID,
                            GEIS_ATTR_TYPE_INTEGER,
                            (void *)&grail_class->geis_class_id);
       geis_frame_add_attr(frame, attr);

=== modified file 'libutouch-geis/geis.c'
--- libutouch-geis/geis.c	2011-08-21 16:28:27 +0000
+++ libutouch-geis/geis.c	2011-10-18 19:34:23 +0000
@@ -32,6 +32,7 @@
 #include "geis_attr.h"
 #include "geis_backend.h"
 #include "geis_class.h"
+#include "server/geis_dbus_server.h" /* @TODO replace me */
 #include "geis_device.h"
 #include "geis_backend_multiplexor.h"
 #include "geis_error.h"
@@ -45,16 +46,6 @@
 
 
 /*
- * An internal struct to collect filterable attributes for facilities.
- */
-typedef struct FilterableAttributeBag
-{
-  GeisFilterableAttribute store;
-  GeisSize                size;
-  GeisSize                count;
-} *FilterableAttributeBag;
-
-/*
  * An internal structure to track processing callbacks in some order.
  */
 typedef struct GeisProcessingEntry *GeisProcessingEntry;
@@ -78,6 +69,8 @@
   GeisSubBag              subscription_bag;
   GeisBackendMultiplexor  backend_multiplexor;
   GeisBackend             backend;
+  GeisBoolean             backend_pending;
+  GeisDBusServer          server; /* @TODO: replace me */
   GeisEventQueue          input_event_queue;
   int                     input_event_signal_pipe[2];
   GeisProcessingEntry     processing_callbacks;
@@ -200,12 +193,14 @@
  * Filters and transforms raw gesture events into cooked gesture events.
  */
 static void
-_input_event_handler(int fd, GeisBackendMultiplexorEvent mux_ev, void *context)
+_input_event_handler(int                             fd,
+                     GeisBackendMultiplexorActivity  activity,
+                     void                           *context)
 {
   Geis geis = (Geis)context;
   GeisProcessingEntry cb;
 
-  if (mux_ev == GEIS_BE_MX_READ_AVAILABLE)
+  if (activity & GEIS_BE_MX_READ_AVAILABLE)
   {
     GeisEvent event;
 
@@ -234,6 +229,20 @@
 	  handled = _class_event_handler(geis, event);
 	  break;
 
+        case GEIS_EVENT_INIT_COMPLETE:
+          geis->backend_pending = GEIS_FALSE;
+          break;
+
+        case GEIS_EVENT_ERROR:
+          if (geis->backend_pending)
+          {
+            geis->backend = geis_backend_by_name(geis,
+                                                 GEIS_INIT_UTOUCH_XCB_BACKEND);
+            geis->backend_pending = GEIS_FALSE;
+            handled = GEIS_TRUE;
+          }
+          break;
+
 	default:
 	  break;
       }
@@ -273,93 +282,6 @@
 
 
 /*
- * Constructs a new filterable attribute bag.
- */
-static FilterableAttributeBag
-_filterable_attribute_bag_new()
-{
-  FilterableAttributeBag bag = calloc(1, sizeof(struct FilterableAttributeBag));
-  if (!bag)
-  {
-    geis_error("failed to allocate filterable attribute bag");
-    goto final_exit;
-  }
-
-  bag->size = 2;
-  bag->count = 0;
-
-  bag->store = calloc(1, sizeof(struct GeisFilterableAttribute));
-  if (!bag)
-  {
-    geis_error("failed to allocate filterable attribute bag store");
-    goto unwind_bag;
-  }
-  goto final_exit;
-
-unwind_bag:
-  free(bag);
-  bag = NULL;
-final_exit:
-  return bag;
-}
-
-
-/*
- * Destroys a filterable attribute bag.
- */
-static void
-_filterable_attribute_bag_delete(FilterableAttributeBag bag)
-{
-  if (bag)
-  {
-    GeisSize i;
-    for (i = 0; i < bag->count; ++i)
-    {
-      free((char *)bag->store[i].name);
-    }
-    free(bag->store);
-  }
-  free(bag);
-}
-
-
-static void
-_filterable_attribute_copy(GeisFilterableAttribute src,
-                           GeisFilterableAttribute dst)
-{
-  dst->name = strdup(src->name);
-  dst->type = src->type;
-  dst->add_term_callback = src->add_term_callback;
-  dst->add_term_context  = src->add_term_context;
-}
-
-
-static void
-_filterable_attribute_bag_insert(FilterableAttributeBag  bag,
-                                 GeisFilterableAttribute fa)
-{
-  GeisSize new_count = bag->count + 1;
-  if (new_count >= bag->size)
-  {
-    GeisSize new_size = bag->size * 2;
-    GeisSize allocation_size = new_size * sizeof(struct GeisFilterableAttribute);
-    GeisFilterableAttribute new_store = realloc(bag->store, allocation_size);
-    if (!new_store)
-    {
-      geis_error("failed to reallocate filterable attribute bag store");
-    }
-    else
-    {
-      bag->store = new_store;
-      bag->size = new_size;
-    }
-  }
-  _filterable_attribute_copy(fa, &bag->store[bag->count]);
-  bag->count = new_count;
-}
-
-
-/*
  * Applies the back end callback to the back end token for each filterable
  * attribute with a name matching the argument.
  */
@@ -371,13 +293,16 @@
                                   void                   *value)
 {
   GeisStatus status = GEIS_STATUS_SUCCESS;
-  GeisSize i;
-  for (i = 0; i < bag->count; ++i)
+  GeisFilterableAttributeBagIter it;
+  for (it = geis_filterable_attribute_bag_begin(bag);
+       it != geis_filterable_attribute_bag_end(bag);
+       it = geis_filterable_attribute_bag_next(bag, it))
   {
-    GeisFilterableAttribute fa = &bag->store[i];
-    if (0 == strcmp(fa->name, name))
+    if (0 == strcmp(it->name, name) && it->add_term_callback)
     {
-      status = fa->add_term_callback(token, fa->add_term_context, name, op, value);
+      status = it->add_term_callback(token,
+                                     it->add_term_context,
+                                     name, op, value);
     }
   }
   return status;
@@ -389,11 +314,11 @@
  */
 GeisStatus
 geis_filterable_attribute_foreach(Geis geis,
-                                  GeisFilterFacility  facility,
-                                  GeisBackendToken    token,
-                                  GeisString          name,
-                                  GeisFilterOperation op,
-                                  void               *value)
+                                  GeisFilterFacility   facility,
+                                  GeisBackendToken     token,
+                                  GeisString           name,
+                                  GeisFilterOperation  op,
+                                  void                *value)
 {
   GeisStatus status = GEIS_STATUS_UNKNOWN_ERROR;
   switch (facility)
@@ -470,6 +395,7 @@
   }
   geis_backend_multiplexor_add_fd(geis->backend_multiplexor,
                                   geis->input_event_signal_pipe[0],
+                                  GEIS_BE_MX_READ_AVAILABLE,
                                   _input_event_handler,
                                   geis);
 
@@ -482,7 +408,7 @@
   }
   geis->output_event_callback = _default_output_event_callback;
 
-  geis->class_filterable_attributes = _filterable_attribute_bag_new();
+  geis->class_filterable_attributes = geis_filterable_attribute_bag_new();
   if (!geis->class_filterable_attributes)
   {
     geis_error_push(NULL, GEIS_STATUS_UNKNOWN_ERROR);
@@ -499,7 +425,7 @@
   }
   geis->class_event_callback = _default_output_event_callback;
 
-  geis->device_filterable_attributes = _filterable_attribute_bag_new();
+  geis->device_filterable_attributes = geis_filterable_attribute_bag_new();
   if (!geis->device_filterable_attributes)
   {
     geis_error_push(NULL, GEIS_STATUS_UNKNOWN_ERROR);
@@ -516,13 +442,13 @@
   }
   geis->device_event_callback = _default_output_event_callback;
 
-  geis->region_filterable_attributes = _filterable_attribute_bag_new();
+  geis->region_filterable_attributes = geis_filterable_attribute_bag_new();
   if (!geis->region_filterable_attributes)
   {
     goto unwind_device_bag;
   }
 
-  geis->special_filterable_attributes = _filterable_attribute_bag_new();
+  geis->special_filterable_attributes = geis_filterable_attribute_bag_new();
   if (!geis->special_filterable_attributes)
   {
     goto unwind_region_attrs;
@@ -531,15 +457,15 @@
   goto final_exit;
 
 unwind_region_attrs:
-  _filterable_attribute_bag_delete(geis->region_filterable_attributes);
+  geis_filterable_attribute_bag_delete(geis->region_filterable_attributes);
 unwind_device_bag:
   geis_device_bag_delete(geis->devices);
 unwind_device_attrs:
-  _filterable_attribute_bag_delete(geis->device_filterable_attributes);
+  geis_filterable_attribute_bag_delete(geis->device_filterable_attributes);
 unwind_class_bag:
   geis_gesture_class_bag_delete(geis->gesture_classes);
 unwind_class_attrs:
-  _filterable_attribute_bag_delete(geis->class_filterable_attributes);
+  geis_filterable_attribute_bag_delete(geis->class_filterable_attributes);
 unwind_output_queue:
   geis_event_queue_delete(geis->output_event_queue);
 unwind_input_signal_pipe:
@@ -564,6 +490,7 @@
 {
   BACK_END_TYPE_NONE,
   BACK_END_TYPE_MOCK_ENGINE,
+  BACK_END_TYPE_DBUS,
   BACK_END_TYPE_XCB
 } BackendType;
 
@@ -580,7 +507,7 @@
   {
     if (0 == strcmp(init_arg_name, GEIS_INIT_SERVICE_PROVIDER))
     {
-      geis_debug("initializing GEIS server");
+      geis->server = geis_dbus_server_new(geis);
     }
     else if (0 == strcmp(init_arg_name, GEIS_INIT_TRACK_DEVICES))
     {
@@ -590,7 +517,7 @@
     {
       /* no longer supported */
     }
-    else if (0 == strcmp(init_arg_name, GEIS_INIT_UTOUCH_MOCK_ENGINE))
+    else if (0 == strcmp(init_arg_name, GEIS_INIT_UTOUCH_MOCK_BACKEND))
     {
       if (back_end_type != BACK_END_TYPE_NONE)
       {
@@ -598,7 +525,15 @@
       }
       back_end_type = BACK_END_TYPE_MOCK_ENGINE;
     }
-    else if (0 == strcmp(init_arg_name, GEIS_INIT_UTOUCH_XCB))
+    else if (0 == strcmp(init_arg_name, GEIS_INIT_UTOUCH_DBUS_BACKEND))
+    {
+      if (back_end_type != BACK_END_TYPE_NONE)
+      {
+	geis_error("multiple back ends requested, only using last request");
+      }
+      back_end_type = BACK_END_TYPE_DBUS;
+    }
+    else if (0 == strcmp(init_arg_name, GEIS_INIT_UTOUCH_XCB_BACKEND))
     {
       if (back_end_type != BACK_END_TYPE_NONE)
       {
@@ -612,16 +547,22 @@
 
   if (back_end_type == BACK_END_TYPE_MOCK_ENGINE)
   {
-    geis->backend = geis_backend_by_name(geis, GEIS_INIT_UTOUCH_MOCK_ENGINE);
-  }
-  else if (back_end_type ==BACK_END_TYPE_XCB)
-  {
-    geis->backend = geis_backend_by_name(geis, GEIS_INIT_UTOUCH_XCB);
+    geis->backend = geis_backend_by_name(geis, GEIS_INIT_UTOUCH_MOCK_BACKEND);
+  }
+  else if (back_end_type == BACK_END_TYPE_DBUS)
+  {
+    geis->backend = geis_backend_by_name(geis, GEIS_INIT_UTOUCH_DBUS_BACKEND);
+    geis->backend_pending = GEIS_TRUE;
+  }
+  else if (back_end_type == BACK_END_TYPE_XCB)
+  {
+    geis->backend = geis_backend_by_name(geis, GEIS_INIT_UTOUCH_XCB_BACKEND);
   }
   else
   {
-    geis_warning("back end not specified, defaulting to XCB");
-    geis->backend = geis_backend_by_name(geis, GEIS_INIT_UTOUCH_XCB);
+    geis_warning("back end not specified, defaulting to DBus");
+    geis->backend = geis_backend_by_name(geis, GEIS_INIT_UTOUCH_DBUS_BACKEND);
+    geis->backend_pending = GEIS_TRUE;
   }
   if (!geis->backend)
   {
@@ -681,16 +622,18 @@
   }
 
   geis_gesture_flick_delete(geis->flick);
-  _filterable_attribute_bag_delete(geis->special_filterable_attributes);
-  _filterable_attribute_bag_delete(geis->region_filterable_attributes);
+  geis_filterable_attribute_bag_delete(geis->special_filterable_attributes);
+  geis_filterable_attribute_bag_delete(geis->region_filterable_attributes);
   geis_device_bag_delete(geis->devices);
-  _filterable_attribute_bag_delete(geis->device_filterable_attributes);
+  geis_filterable_attribute_bag_delete(geis->device_filterable_attributes);
   geis_gesture_class_bag_delete(geis->gesture_classes);
-  _filterable_attribute_bag_delete(geis->class_filterable_attributes);
+  geis_filterable_attribute_bag_delete(geis->class_filterable_attributes);
   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->server)
+      geis_dbus_server_delete(geis->server);