Merge lp:~bregma/geis/geis-windows into lp:geis

[Stephen M. Webb]

Fixed gesture subscriptions on multiple windows simultaneously.

Fixed the implementation to allow for gesture subscriptions on multiple windows simultaneously.

[lp:~bregma/geis/geis-windows]

77. By Stephen M. Webb on 2010-08-30

removed debug code

78. By Stephen M. Webb on 2010-08-31

Removed input device enumeration handling until later.

[Chase Douglas (chasedouglas)]

1. There's a typo in the geistest man page in line 97 of the big merge diff below. Another typo in line 107.

2. "#if 0" and "#ifdef REVERT_XCB_CHANGES" code should be removed:
  a. geis_instance_input_devices should be removed if it doesn't work.
  b. xcb connection stuff should be removed since we need Xlib for XI2. That won't change anytime soon.
  c. geis_xcb_input_devices should either be removed, or the printf's should be changed to the new diagnostics framework

3. Why does _GeisXcb include a win_info? On cursory glance I would think it should just contain the xcb connection information. As a side note, having GeisWinInfo contain a field called "win_info" makes grepping through the source hard. Perhaps the internal field should be called win_info_impl, or something along those lines?

I got through to line 309 of the merge diff below, but I have to stop now to leave :(. I will pick up my review later.

review: Needs Fixing

Unmerged revisions

=== modified file 'ChangeLog'
--- ChangeLog	2010-08-30 20:28:40 +0000
+++ ChangeLog	2010-08-30 20:28:40 +0000
@@ -1,5 +1,50 @@
 2010-08-30  Stephen M. Webb  <[e-mail]>
 
+  Removed some debug code and fixed pasto.
+
+  * libutouch-geis-xcb/geis_instance.c: fixed a pasto
+  * testsuite/geistest/geistest.c: removed debug code
+
[phone]  Stephen M. Webb  <[e-mail]>
+
+  Fixed so multiple windows will work.
+
+  Altered geistest to work with a single window or all windows, had to fix geis
+  implementation so this was possible.
+
+  * libutouch-geis-xcb/geis_instance_table.c: new file
+  * libutouch-geis-xcb/geis_instance_table.h: new file
+  * configure.ac: added package checks for x11-xcb and xi
+  * doc/geistest.1: documented new CLI switches
+  * geis/geis.h (geis_input_devices): fixed argument type
+  * libutouch-geis-xcb/Makefile.am (libutouch_geis_la_SOURCES): added new files
+    (libutouch_geis_la_CFLAGS): aded X11XCB_CFLAGS and XI2_CFLAGS
+    (libutouch_geis_la_LIBADD): aded X11XCB_LIBS and XI2LIBS_
+  * libutouch-geis-xcb/geis.c (s_geis_xcb): new static global
+    (geis_init): used it
+  * libutouch-geis-xcb/geis_instance.h (_GeisInstance): added window_id
+    (geis_instance_new): renamed from geis_instance_get
+    (geis_instance_input_devices): new function
+    (geis_instance_subscribe): added GeisXcb parameter
+    (geis_instance_get_window_id): new function
+    (geis_instance_fd): removed function
+    (geis_instance_event_dispatch): removed function
+  * libutouch-geis-xcb/geis_instance.c: implemented new functions
+  * libutouch-geis-xcb/geis_xcb.h (geis_xcb_new): renamed from geis_xcb_get
+    (geis_xcb_create_instance): new function
+    (geis_xcb_input_devices): new function
+    (geis_xcb_subscribe): added GeisInstance parameter
+    (geis_xcb_dispatch): changed parameter type to GeisXcb
+  * libutouch-geis-xcb/geis_xcb.c: Implemeneted new functions
+  * testsuite/geistest/geistest.c (parse_opts): added -w switch
+    (subscribe_window): new function
+    (subscribe_windows_preorder): new function
+    (subscribe_all_windows): new function
+    (main): used the new functions
+
+
[phone]  Stephen M. Webb  <[e-mail]>
+
   Added runtime diagnostic facility.
 
   * libutouch-geis-xcb/geis_debug.h: replaced with

=== modified file 'configure.ac'
--- configure.ac	2010-08-25 20:41:17 +0000
+++ configure.ac	2010-08-30 20:28:40 +0000
@@ -24,6 +24,11 @@
 		  AC_MSG_ERROR([Grail development libraries not found]))
 PKG_CHECK_MODULES([XCB], [xcb >= 1.6], ,
 		  AC_MSG_ERROR([XCB development libraries not found]))
+PKG_CHECK_MODULES([X11XCB], [x11-xcb >= 1.3.3], ,
+		  AC_MSG_ERROR([X11-XCB development libraries not found]))
+PKG_CHECK_MODULES([XI2], [xi >= 1.3], ,
+		  AC_MSG_ERROR([XI2 development libraries not found]))
+
 # XCB code generation configuration
 AC_MSG_CHECKING(XCBPROTO_XCBINCLUDEDIR)
 XCBPROTO_XCBINCLUDEDIR=`$PKG_CONFIG --variable=xcbincludedir xcb-proto`

=== modified file 'doc/geistest.1'
--- doc/geistest.1	2010-08-16 16:25:17 +0000
+++ doc/geistest.1	2010-08-30 20:28:40 +0000
@@ -4,7 +4,10 @@
 geistest \- test operatoin of the GEIS API
 
 .SH SYNOPSIS
-.B geistest windowid
+.B geistest [ 
+.B -w 
+.I windowid
+.B ]
 .br
 
 .SH DESCRIPTION
@@ -12,8 +15,21 @@
 .B geistest
 program. This program is a test driver for verifying the recognition and propagation of gestures through the GEIS API.
 
-
-.SH EXAMPLE
+.SH OPTIONS
+.IP -w
+Specifies the
+.I windowId
+of a specific windo to associate with gestures.
+Particularly useful with touchscreens.
+
+The
+.I windowId
+can be determined using the program
+.BR xwininfo .
+
+.SH ENVIRONMENT
+.IP GEIS_DEBUG
+Enables GEIS libraru diagnostic messages on stderr.
 
 .SH "SEE ALSO"
-gesturetest(1)
\ No newline at end of file
+gesturetest(1)

=== modified file 'geis/geis.h'
--- geis/geis.h	2010-08-24 17:59:37 +0000
+++ geis/geis.h	2010-08-30 20:28:40 +0000
@@ -293,7 +293,7 @@
  * @retval GEIS_STATUS_SUCCESS  normal successful completion
  */
 GEIS_API GeisStatus geis_input_devices(GeisInstance    geis_instance,
-                                       GeisInputFuncs  func,
+                                       GeisInputFuncs *func,
                                        void           *cookie);
 
 /* @} */

=== modified file 'libutouch-geis-xcb/Makefile.am'
--- libutouch-geis-xcb/Makefile.am	2010-08-30 20:28:40 +0000
+++ libutouch-geis-xcb/Makefile.am	2010-08-30 20:28:40 +0000
@@ -16,9 +16,10 @@
 
 libutouch_geis_la_SOURCES = \
 	geis.c \
-	geis_logging.h  geis_logging.c \
-	geis_xcb.h      geis_xcb.c \
-	geis_instance.h geis_instance.c
+	geis_logging.h        geis_logging.c \
+	geis_instance.h       geis_instance.c \
+	geis_instance_table.h geis_instance_table.c \
+	geis_xcb.h            geis_xcb.c 
 
 dist_libutouch_geis_la_SOURCES = \
 	xcb_gesture.h xcb_gesture.c
@@ -29,7 +30,9 @@
 	-DGEIS_BUILDING_DSO=1 \
 	-I$(top_srcdir) \
 	$(GRAIL_CFLAGS) \
-	$(XCB_CFLAGS)
+	$(X11XCB_CFLAGS) \
+	$(XCB_CFLAGS) \
+	$(XI2_CFLAGS)
 
 libutouch_geis_la_LDFLAGS = \
 	-Wl,-z,defs -Wl,--as-needed \
@@ -37,7 +40,9 @@
 	-Wl,--version-script=$(version_script)
 
 libutouch_geis_la_LIBADD = \
-       $(XCB_LIBS)
+	$(X11XCB_LIBS) \
+	$(XCB_LIBS) \
+	$(XI2_LIBS)
 
 BUILT_SOURCES = $(dist_libutouch_geis_la_SOURCES)
 CLEANFILES = $(dist_libutouch_geis_la_SOURCES)

=== modified file 'libutouch-geis-xcb/geis.c'
--- libutouch-geis-xcb/geis.c	2010-08-11 13:54:54 +0000
+++ libutouch-geis-xcb/geis.c	2010-08-30 20:28:40 +0000
@@ -20,9 +20,13 @@
 #include <geis/geis.h>
 
 #include "geis_instance.h"
+#include "geis_xcb.h"
 #include <stdlib.h>
 
 
+static GeisXcb s_geis_xcb = NULL;
+
+
 /**
  * @param[in]  win_info
  * @param[out] geis_instance
@@ -34,13 +38,19 @@
 geis_init(GeisWinInfo *win_info, GeisInstance *geis_instance)
 {
   *geis_instance = NULL;
+  GeisXcbWinInfo *xcb_win_info = (GeisXcbWinInfo*)win_info->win_info;
 
   if (win_info->win_type != GEIS_XCB_FULL_WINDOW)
   {
     return GEIS_BAD_ARGUMENT;
   }
 
-  *geis_instance = geis_instance_get((GeisXcbWinInfo*)win_info->win_info);
+  if (!s_geis_xcb)
+  {
+    s_geis_xcb = geis_xcb_new(xcb_win_info);
+  }
+
+  *geis_instance = geis_xcb_create_instance(s_geis_xcb, xcb_win_info->window_id);
   return GEIS_STATUS_SUCCESS;
 }
 
@@ -109,7 +119,7 @@
   switch (configuration_item)
   {
     case GEIS_CONFIG_UNIX_FD:
-      *(int *)value = geis_instance_fd(geis_instance);
+      *(int *)value = geis_xcb_fd(s_geis_xcb);
       status = GEIS_STATUS_SUCCESS;
       break;
   }
@@ -147,7 +157,7 @@
     return GEIS_BAD_ARGUMENT;
   }
 
-  geis_instance_event_dispatch(geis_instance);
+  geis_xcb_dispatch(s_geis_xcb);
   return GEIS_STATUS_SUCCESS;
 }
 
@@ -159,7 +169,7 @@
  */
 GeisStatus
 geis_input_devices(GeisInstance    geis_instance,
-                   GeisInputFuncs  funcs,
+                   GeisInputFuncs *funcs,
                    void           *cookie)
 {
   if (!geis_instance_is_valid(geis_instance))
@@ -167,7 +177,11 @@
     return GEIS_BAD_ARGUMENT;
   }
 
-  return GEIS_UNKNOWN_ERROR;
+#if 0
+  return geis_instance_input_devices(geis_instance, funcs, cookie);
+#else
+  return geis_xcb_input_devices(s_geis_xcb);
+#endif
 }
 
 
@@ -191,6 +205,7 @@
   }
 
   return geis_instance_subscribe(geis_instance,
+  				 s_geis_xcb,
                                  input_list,
                                  gesture_list,
                                  funcs,

=== modified file 'libutouch-geis-xcb/geis_instance.c'
--- libutouch-geis-xcb/geis_instance.c	2010-08-27 17:05:55 +0000
+++ libutouch-geis-xcb/geis_instance.c	2010-08-30 20:28:40 +0000
@@ -19,17 +19,27 @@
  */
 #include "geis_instance.h"
 
+#include "geis_logging.h"
 #include <stdlib.h>
 
 
+/**
+ * Creates a new GeisInstance for an X11 windowId.
+ *
+ * @param[in] An X11 windowId.
+ *
+ * @returns a new GeisInstance or NULL on failure.
+ */
 GeisInstance
-geis_instance_get(GeisXcbWinInfo* win_info)
+geis_instance_new(uint32_t window_id)
 {
   GeisInstance instance = calloc(1, sizeof(struct _GeisInstance));
-  if (instance)
+  if (!instance)
   {
-    instance->xcb = geis_xcb_get(win_info);
+    geis_error("allocating GeisInstance");
+    return NULL;
   }
+  instance->window_id = window_id;
   return instance;
 }
 
@@ -44,12 +54,26 @@
 int
 geis_instance_is_valid(GeisInstance instance)
 {
-  return (instance != 0 && instance->xcb != 0);
-}
+  return (instance != 0 && instance->window_id != 0);
+}
+
+
+#ifdef REVERT_XCB_CHANGES
+GeisStatus
+geis_instance_input_devices(GeisInstance     instance,
+                            GeisInputFuncs  *funcs,
+                            void            *cookie)
+{
+  instance->input_funcs    = funcs;
+  instance->input_cookie   = cookie;
+  return geis_xcb_input_devices(instance);
+}
+#endif
 
 
 GeisStatus
 geis_instance_subscribe(GeisInstance         instance,
+                        GeisXcb              xcb,
                         GeisInputDeviceId   *input_list,
                         const char*         *gesture_list,
                         GeisGestureFuncs    *funcs,
@@ -60,14 +84,14 @@
   instance->gesture_cookie   = cookie;
   if (input_list == GEIS_ALL_INPUT_DEVICES)
   {
-    result = geis_xcb_subscribe(instance, 0, gesture_list);
+    result = geis_xcb_subscribe(xcb, instance, 0, gesture_list);
   }
   else
   {
     GeisInputDeviceId *device_id = input_list;
     for (; *device_id; ++device_id)
     {
-      GeisStatus a_result = geis_xcb_subscribe(instance,
+      GeisStatus a_result = geis_xcb_subscribe(xcb, instance,
                                                (uint16_t)*device_id,
                                                gesture_list);
       if (a_result == GEIS_STATUS_SUCCESS)
@@ -80,25 +104,15 @@
 }
 
 
-int
-geis_instance_fd(GeisInstance instance)
-{
-  if (instance == NULL)
-    return -1;
-    
-  return geis_xcb_fd(instance->xcb);
-}
-
-
-void
-geis_instance_event_dispatch(GeisInstance instance)
-{
-  geis_xcb_dispatch(instance);
+uint32_t
+geis_instance_get_window_id(GeisInstance instance)
+{
+  return instance->window_id;
 }
 
 
 void
 geis_instance_free(GeisInstance instance)
 {
-  geis_xcb_free(instance->xcb);
+  free(instance);
 }

=== modified file 'libutouch-geis-xcb/geis_instance.h'
--- libutouch-geis-xcb/geis_instance.h	2010-08-22 16:53:46 +0000
+++ libutouch-geis-xcb/geis_instance.h	2010-08-30 20:28:40 +0000
@@ -26,31 +26,34 @@
 
 struct _GeisInstance
 {
-	GeisXcb             *xcb;
-	GeisInputCallback    input_callback;
-	void                *input_cookie;
-	GeisGestureFuncs    *gesture_funcs;
-	void                *gesture_cookie;
+	uint32_t          window_id;
+	GeisInputFuncs   *input_funcs;
+	void             *input_cookie;
+	GeisGestureFuncs *gesture_funcs;
+	void             *gesture_cookie;
 };
 
 /** @brief Constructs a GeisInstance. */
-GeisInstance geis_instance_get(GeisXcbWinInfo* win_info);
+GeisInstance geis_instance_new(uint32_t win_info);
+
 
 /** @brief Indicates if the GeisInstance is valid. */
 int geis_instance_is_valid(GeisInstance instance);
 
+/** @brief Subscribe to input devices. */
+GeisStatus geis_instance_input_devices(GeisInstance     instance,
+                                       GeisInputFuncs  *funcs,
+                                       void            *cookie);
+
 /** @brief Subscribe to gestures. */
 GeisStatus geis_instance_subscribe(GeisInstance         instance,
+                                   GeisXcb              xcb,
                                    GeisInputDeviceId   *input_list,
                                    const char*         *gesture_list,
                                    GeisGestureFuncs    *funcs,
                                    void                *cookie);
 
-/** @brief Gets the event file descriptor. */
-int geis_instance_fd(GeisInstance instance);
-
-/** @brief Dispatches events. */
-void geis_instance_event_dispatch(GeisInstance instance);
+uint32_t geis_instance_get_window_id(GeisInstance instance);
 
 /** @brief Tears down the GeisInstance. */
 void geis_instance_free(GeisInstance instance);

=== added file 'libutouch-geis-xcb/geis_instance_table.c'
--- libutouch-geis-xcb/geis_instance_table.c	1970-01-01 00:00:00 +0000
+++ libutouch-geis-xcb/geis_instance_table.c	2010-08-30 20:28:40 +0000
@@ -0,0 +1,127 @@
+/**
+ * geis_instance_table.h
+ *
+ * Copyright 2010 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.	 See the GNU Lesser General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU 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 US
+ */
+#include "geis_instance_table.h"
+
+#include "geis_instance.h"
+#include <stdlib.h>
+
+#define GROWTH_FACTOR 2
+
+
+typedef struct _GeisInstanceTableEntry
+{
+  uint32_t      id;
+  GeisInstance  type;
+} *GeisInstanceTableEntry;
+
+struct _GeisInstanceTable
+{
+  size_t                 capacity;
+  size_t                 size;
+  GeisInstanceTableEntry data;
+};
+
+
+GeisInstanceTable
+geis_instance_table_new(int size_hint)
+{
+  GeisInstanceTable table = malloc(sizeof(struct _GeisInstanceTable));
+  if (!table)
+  {
+    /* TODO: report error */
+  }
+
+  table->capacity = size_hint;
+  table->size = 0;
+  table->data = calloc(table->capacity,
+                       size_hint * sizeof(struct _GeisInstanceTableEntry));
+  if (!table->data)
+  {
+    /* TODO: report error */
+  }
+
+  return table;
+}
+
+
+/**
+ * Adds (or replaces) a gesture type in the table.
+ */
+void
+geis_instance_table_add(GeisInstanceTable table,
+                        GeisInstance      instance)
+{
+  size_t i;
+  uint32_t window_id = geis_instance_get_window_id(instance);
+
+  /* If the ID is already present, just replace the gesture type */
+  for (i = 0; i < table->size; ++i)
+  {
+    if (table->data[i].id == window_id)
+    {
+      table->data[i].type = instance;
+      return;
+    }
+  }
+
+  /* If there is no space to insert, grow the table. */
+  if (table->size >= table->capacity)
+  {
+    size_t new_capacity = table->capacity * GROWTH_FACTOR;
+    GeisInstanceTableEntry new_data = realloc(table->data,
+                               new_capacity * sizeof(struct _GeisInstanceTableEntry));
+    if (!new_data)
+    {
+      /* TODO: report error */
+    }
+
+    table->capacity = new_capacity;
+    table->data     = new_data;
+  }
+
+  table->data[table->size].id   = window_id;
+  table->data[table->size].type = instance;
+  ++table->size;
+}
+
+
+GeisInstance
+geis_instance_table_get(GeisInstanceTable table,
+                        uint32_t          window_id)
+{
+  size_t i;
+  for (i = 0; i < table->size; ++i)
+  {
+    if (table->data[i].id == window_id)
+    {
+      return table->data[i].type;
+    }
+  }
+  return NULL;
+}
+
+
+void
+geis_instance_table_free(GeisInstanceTable table)
+{
+  free(table->data);
+  free(table);
+}
+

=== added file 'libutouch-geis-xcb/geis_instance_table.h'
--- libutouch-geis-xcb/geis_instance_table.h	1970-01-01 00:00:00 +0000
+++ libutouch-geis-xcb/geis_instance_table.h	2010-08-30 20:28:40 +0000
@@ -0,0 +1,41 @@
+/**
+ * geis_instance_table.h
+ *
+ * Copyright 2010 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation; either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.	 See the GNU Lesser General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU 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 US
+ */
+#ifndef GEIS_INSTANCE_TABLE_H_
+#define GEIS_INSTANCE_TABLE_H_
+
+#include "geis_config.h"
+#include <geis/geis.h>
+
+/**
+ * A map from XCB window IDs to geisInstances.
+ */
+typedef struct _GeisInstanceTable *GeisInstanceTable;
+
+GeisInstanceTable geis_instance_table_new(int size_hint);
+
+void geis_instance_table_add(GeisInstanceTable type_table,
+                             GeisInstance      instance);
+
+GeisInstance geis_instance_table_get(GeisInstanceTable type_table,
+                                     uint32_t          window_id);
+
+void geis_instance_table_free(GeisInstanceTable type_table);
+
+#endif /* GEIS_INSTANCE_TABLE_H_ */

=== modified file 'libutouch-geis-xcb/geis_xcb.c'
--- libutouch-geis-xcb/geis_xcb.c	2010-08-30 20:28:40 +0000
+++ libutouch-geis-xcb/geis_xcb.c	2010-08-30 20:28:40 +0000
@@ -20,27 +20,25 @@
 #include "geis_xcb.h"
 
 #include "geis_instance.h"
+#include "geis_instance_table.h"
 #include "geis_logging.h"
 #include <grail.h>
 #include <grail-types.h>
 #include <stdlib.h>
 #include <string.h>
+#include <X11/extensions/XInput2.h>
 #include <X11/X.h>
+#include <X11/Xlib-xcb.h>
 #include "xcb_gesture.h"
 #include <xcb/xcb.h>
 
 struct _GeisXcb
 {
   GeisXcbWinInfo   *win_info;
+  Display          *display;
   xcb_connection_t *connection;
   int               fd;
-};
-
-static GeisXcb s_geis_xcb =
-{
-  NULL,
-  NULL,
-  -1
+  GeisInstanceTable instance_table;
 };
 
 typedef struct _GrailAttrMap
@@ -625,79 +623,136 @@
 /**
  * @param[in] win_info
  */
-GeisXcb *
-geis_xcb_get(GeisXcbWinInfo *win_info)
-{
-  if (!s_geis_xcb.connection)
-  {
-    s_geis_xcb.win_info = win_info;
-    s_geis_xcb.connection = xcb_connect(win_info->display_name,
-                                        win_info->screenp);
-    if (!s_geis_xcb.connection)
-    {
-      geis_error("error connecting to X server.");
-      return NULL;
-    }
-
-#if 0
-    {
-      char buffer[128];
-      xcb_input_get_extension_version_cookie_t input_version_cookie;
-
-      input_version_cookie = xcb_input_get_extension_version(s_geis_xcb.connection,
-                                                             127,
-                                                             buffer);
-    }
-#endif
-
-    {
-      xcb_generic_error_t                *error;
-      xcb_gesture_query_version_cookie_t  version_cookie;
-      xcb_gesture_query_version_reply_t  *version_reply = NULL;
-
-      version_cookie = xcb_gesture_query_version(s_geis_xcb.connection,
-                                                 XCB_GESTURE_MAJOR_VERSION,
-                                                 XCB_GESTURE_MINOR_VERSION);
-      version_reply = xcb_gesture_query_version_reply(s_geis_xcb.connection,
-                                                      version_cookie,
-                                                      &error);
-      if (!version_reply)
-      {
-	geis_error("failed to receive gesture version reply\n");
-	return NULL;
-      }
-
-      if (version_reply->major_version != XCB_GESTURE_MAJOR_VERSION
-       && version_reply->minor_version != XCB_GESTURE_MINOR_VERSION)
-      {
-	geis_error("server supports unrecognized version: %d.%d\n",
-	           version_reply->major_version, version_reply->minor_version);
-	free(version_reply);
-	return NULL;
-      }
-
-     free(version_reply);
-    }
-
-
-    s_geis_xcb.fd = xcb_get_file_descriptor(s_geis_xcb.connection);
-  }
-
-  return &s_geis_xcb;
-}
-
-
+GeisXcb
+geis_xcb_new(GeisXcbWinInfo *win_info)
+{
+  GeisXcb xcb = calloc(1, sizeof(struct _GeisXcb));
+  if (!xcb)
+  {
+    /** @todo: report error */
+  }
+
+  xcb->win_info = win_info;
+#if 0
+  xcb->connection = xcb_connect(win_info->display_name,
+                                win_info->screenp);
+#else
+  xcb->display = XOpenDisplay(win_info->display_name);
+  if (!xcb->display)
+  {
+    geis_error("error opening X server.");
+    return NULL;
+  }
+
+  xcb->connection = XGetXCBConnection(xcb->display);
+#endif
+  if (!xcb->connection)
+  {
+    geis_error("error connecting to X server.");
+    return NULL;
+  }
+
+  {
+#if 0
+    char buffer[128];
+    xcb_input_get_extension_version_cookie_t input_version_cookie;
+
+    input_version_cookie = xcb_input_get_extension_version(xcb->connection,
+							   127,
+							   buffer);
+#else
+    /* XInput Extension available? */
+    int opcode, event, error;
+    if (!XQueryExtension(xcb->display, "XInputExtension",
+                         &opcode, &event, &error))
+    {
+       geis_error("X Input extension not available.\n");
+       return NULL;
+    }
+
+    /* Which version of XI2? We support 2.0 */
+    int major = 2, minor = 0;
+    if (XIQueryVersion(xcb->display, &major, &minor) == BadRequest)
+    {
+      geis_error("XI2 not available. Server supports %d.%d\n", major, minor);
+      return NULL;
+    }
+#endif
+  }
+
+  {
+    xcb_gesture_query_version_cookie_t  version_cookie;
+    xcb_gesture_query_version_reply_t  *version_reply = NULL;
+    xcb_generic_error_t                *error = NULL;
+
+    version_cookie = xcb_gesture_query_version(xcb->connection,
+                                               XCB_GESTURE_MAJOR_VERSION,
+                                               XCB_GESTURE_MINOR_VERSION);
+    version_reply = xcb_gesture_query_version_reply(xcb->connection,
+                                                    version_cookie,
+                                                    &error);
+    if (!version_reply)
+    {
+      geis_error("failed to receive gesture version reply\n");
+      return NULL;
+    }
+
+    if (version_reply->major_version != XCB_GESTURE_MAJOR_VERSION
+     && version_reply->minor_version != XCB_GESTURE_MINOR_VERSION)
+    {
+      geis_error("server supports unrecognized version: %d.%d\n",
+                 version_reply->major_version, version_reply->minor_version);
+      return NULL;
+    }
+
+   free(version_reply);
+  }
+
+
+  xcb->fd = xcb_get_file_descriptor(xcb->connection);
+  xcb->instance_table = geis_instance_table_new(1);
+
+  return xcb;
+}
+
+
+/**
+ * Create a new GeisInstance for a windowId.
+ *
+ * @param[in] An X11 windowId.
+ */
+GeisInstance
+geis_xcb_create_instance(GeisXcb xcb, uint32_t window_id)
+{
+  GeisInstance instance = geis_instance_new(window_id);
+  if (!instance)
+  {
+    geis_error("failure to create GeisInstance");
+  }
+  else
+  {
+    geis_instance_table_add(xcb->instance_table, instance);
+  }
+  return instance;
+}
+
+
+/**
+ * Gets the file description on which events will appear.
+ */
 int
-geis_xcb_fd(GeisXcb *xcb)
+geis_xcb_fd(GeisXcb xcb)
 {
   return xcb->fd;
 }
 
 
+/**
+ * Dispatches events.
+ */
 void
-geis_xcb_dispatch(GeisInstance instance)
+geis_xcb_dispatch(GeisXcb xcb)
 {
-  GeisXcb *xcb = instance->xcb;
   if (xcb->connection)
   {
     const xcb_query_extension_reply_t *extension_info;
@@ -708,7 +763,7 @@
     {
       xcb_gesture_notify_event_t *gesture_event = NULL;
       if (event->response_type != GenericEvent) {
-	geis_warning("warning: Received non-generic event type: %d\n",
+	geis_warning("received non-generic event type: %d\n",
 	             event->response_type);
 	continue;
       }
@@ -716,19 +771,29 @@
       gesture_event = (xcb_gesture_notify_event_t*)event;
       if (gesture_event->extension != extension_info->major_opcode)
       {
-	geis_warning("warning: Received non-gesture extension event: %d\n",
+	geis_warning("received non-gesture extension event: %d\n",
 	             gesture_event->extension);
 	continue;
       }
 
       if (gesture_event->event_type != XCB_GESTURE_NOTIFY)
       {
-	geis_warning("warning: Received unrecognized gesture event type: %d\n",
+	geis_warning("received unrecognized gesture event type: %d\n",
 	             gesture_event->event_type);
 	continue;
       }
 
-      geis_xcb_dispatch_gesture(instance, gesture_event);
+      GeisInstance instance = geis_instance_table_get(xcb->instance_table,
+                                                      gesture_event->event);
+      if (!instance)
+      {
+	geis_error("no instance found for window_id 0x%08.8x\n",
+	           gesture_event->event);
+      }
+      else
+      {
+	geis_xcb_dispatch_gesture(instance, gesture_event);
+      }
 
       event = xcb_poll_for_event(xcb->connection);
     }
@@ -737,9 +802,10 @@
 
 
 void
-geis_xcb_free(GeisXcb* xcb)
+geis_xcb_free(GeisXcb xcb)
 {
   xcb_disconnect(xcb->connection);
+  XCloseDisplay(xcb->display);
 }
 
 
@@ -782,7 +848,8 @@
 
 
 static GeisStatus
-geis_xcb_verify_event_selection(GeisXcb  *xcb,
+geis_xcb_verify_event_selection(GeisXcb   xcb,
+                                uint32_t  window_id,
                                 uint16_t  device_id,
                                 uint32_t  mask_len,
                                 uint32_t *mask)
@@ -792,13 +859,12 @@
   xcb_gesture_get_selected_events_cookie_t  events_cookie;
   xcb_gesture_get_selected_events_reply_t  *events_reply = NULL;
   xcb_gesture_event_mask_iterator_t         event_mask_it;
-  uint32_t                                  masks_len_reply = 0;
   uint32_t                                  mask_len_reply = 0;
   uint32_t                                 *mask_reply = NULL;
   int                                       device_is_found = 0;
 
   events_cookie = xcb_gesture_get_selected_events(xcb->connection,
-                                                  xcb->win_info->window_id);
+                                                  window_id);
   events_reply = xcb_gesture_get_selected_events_reply(xcb->connection,
                                                        events_cookie,
                                                        &error);
@@ -849,17 +915,31 @@
 
 
 GeisStatus
-geis_xcb_subscribe(GeisInstance   instance,
+geis_xcb_subscribe(GeisXcb        xcb,
+                   GeisInstance   instance,
                    uint16_t       device_id,
                    const char   **gesture_list)
 {
-  GeisStatus result = GEIS_UNKNOWN_ERROR;
-  uint32_t mask_len = 1;
-  uint32_t *mask = 0;
+  GeisStatus            result = GEIS_UNKNOWN_ERROR;
+  uint32_t              mask_len = 1;
+  uint32_t             *mask = 0;
+  const char          **g;
+  xcb_generic_error_t  *error;
+  xcb_void_cookie_t     select_cookie;
+  xcb_window_t          window_id = geis_instance_get_window_id(instance);
 
-  xcb_generic_error_t *error;
-  xcb_void_cookie_t select_cookie;
-  GeisXcb *xcb = instance->xcb;
+  if (gesture_list == GEIS_ALL_GESTURES)
+  {
+    geis_debug("subscribing device %d for the all gestures\n", device_id);
+  }
+  else
+  {
+    geis_debug("subscribing device %d for the following gestures:\n", device_id);
+    for (g = gesture_list; *g; ++g)
+    {
+      geis_debug("\t\"%s\"\n", *g);
+    }
+  }
 
   geis_xcb_map_gestures_to_mask(gesture_list, &mask, &mask_len);
   if (!mask)
@@ -869,18 +949,18 @@
   }
 
   select_cookie = xcb_gesture_select_events_checked(xcb->connection,
-                                                    xcb->win_info->window_id,
+                                                    window_id,
                                                     device_id,
                                                     mask_len,
                                                     mask);
   error = xcb_request_check(xcb->connection, select_cookie);
   if (error)
   {
-    geis_error("failed to select events\n");
+    geis_error("failed to select events for window 0x%08x\n", window_id);
     goto done;
   }
 
-  result = geis_xcb_verify_event_selection(xcb, device_id, mask_len, mask);
+  result = geis_xcb_verify_event_selection(xcb, window_id, device_id, mask_len, mask);
   if (result == GEIS_STATUS_SUCCESS)
   {
     geis_xcb_dispatch_gesture_type(instance, gesture_list);
@@ -891,3 +971,34 @@
 really_done:
   return result;
 }
+
+
+GeisStatus
+geis_xcb_input_devices(GeisXcb xcb)
+{
+  int i;
+  int ndevices;
+  XIDeviceInfo *devices;
+  XIDeviceInfo *device;
+
+  devices = XIQueryDevice(xcb->display, XIAllDevices, &ndevices);
+  for (i = 0; i < ndevices; i++)
+  {
+      device = &devices[i];
+#if 0
+      switch(device->use)
+      {
+	 case XIMasterPointer: printf("master pointer\n"); break;
+	 case XIMasterKeyboard: printf("master keyboard\n"); break;
+	 case XISlavePointer: printf("slave pointer\n"); break;
+	 case XISlaveKeyboard: printf("slave keyboard\n"); break;
+	 case XIFloatingSlave: printf("floating slave\n"); break;
+      }
+#endif
+  }
+  XIFreeDeviceInfo(devices);
+
+  return GEIS_STATUS_SUCCESS;
+}
+
+

=== modified file 'libutouch-geis-xcb/geis_xcb.h'
--- libutouch-geis-xcb/geis_xcb.h	2010-08-24 17:08:41 +0000
+++ libutouch-geis-xcb/geis_xcb.h	2010-08-30 20:28:40 +0000
@@ -4,18 +4,18 @@
  * Copyright 2010 Canonical Ltd.
  *
  * This library is free software; you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License as published by the Free Software
- * Foundation; either version 3 of the License, or (at your option) any later
- * version.
+ * 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.
+ * 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
+ * along with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  */
 #ifndef GEIS_XCB_H_
 #define GEIS_XCB_H_
@@ -23,18 +23,23 @@
 #include "geis_config.h"
 #include <geis/geis.h>
 
-typedef struct _GeisXcb GeisXcb;
-
-GeisXcb *geis_xcb_get(GeisXcbWinInfo *win_info);
-
-GeisStatus geis_xcb_subscribe(GeisInstance instance,
-			      uint16_t     device_id,
+typedef struct _GeisXcb *GeisXcb;
+
+GeisXcb geis_xcb_new(GeisXcbWinInfo *win_info);
+
+GeisInstance geis_xcb_create_instance(GeisXcb xcb, uint32_t window_id);
+
+GeisStatus geis_xcb_input_devices(GeisXcb xcb);
+
+GeisStatus geis_xcb_subscribe(GeisXcb      xcb,
+                              GeisInstance instance,
+                              uint16_t     device_id,
                               const char **gesture_list);
 
-int geis_xcb_fd(GeisXcb* xcb);
-
-void geis_xcb_dispatch(GeisInstance instance);
-
-void geis_xcb_free(GeisXcb *xcb);
+int geis_xcb_fd(GeisXcb xcb);
+
+void geis_xcb_dispatch(GeisXcb xcb);
+
+void geis_xcb_free(GeisXcb xcb);
 
 #endif /* GEIS_XCB_H_ */

=== modified file 'testsuite/geistest/geistest.c'
--- testsuite/geistest/geistest.c	2010-08-24 17:59:37 +0000
+++ testsuite/geistest/geistest.c	2010-08-30 20:28:40 +0000
@@ -23,6 +23,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/select.h>
+#include <unistd.h>
+#include <xcb/xcb.h>
 
 
 static void
@@ -51,6 +53,24 @@
 
 
 static void
+input_device_added(void *cookie, GeisInputDeviceId device_id, void *attrs)
+{
+}
+
+
+static void
+input_device_changed(void *cookie, GeisInputDeviceId device_id, void *attrs)
+{
+}
+
+
+static void
+input_device_removed(void *cookie, GeisInputDeviceId device_id, void *attrs)
+{
+}
+
+
+static void
 gesture_added(void            *cookie,
 	      GeisGestureType  gesture_type,
 	      GeisGestureId    gesture_id,
@@ -116,6 +136,12 @@
 }
 
 
+GeisInputFuncs input_funcs = {
+  input_device_added,
+  input_device_changed,
+  input_device_removed
+};
+
 GeisGestureFuncs gesture_funcs = {
   gesture_added,
   gesture_removed,
@@ -128,22 +154,33 @@
 int
 parse_opts(int argc, char* argv[], uint32_t *window_id)
 {
-  if (argc != 2)
-    return 0;
-
-  *window_id = strtol(argv[1], NULL, 0);
+  int opt;
+
+  while ((opt = getopt(argc, argv, "w:")) != -1)
+  {
+    switch (opt)
+    {
+      case 'w':
+	*window_id = strtol(optarg, NULL, 0);
+	break;
+
+      default:
+      	return 0;
+    }
+  }
+
   return 1;
 }
 
 
-int
-main(int argc, char* argv[])
+static GeisInstance
+subscribe_window(uint32_t window_id)
 {
   GeisStatus status = GEIS_UNKNOWN_ERROR;
   GeisXcbWinInfo xcb_win_info = {
     .display_name  = NULL,
     .screenp       = NULL,
-    .window_id     = 0x296
+    .window_id     = window_id
   };
   GeisWinInfo win_info = {
     GEIS_XCB_FULL_WINDOW,
@@ -151,51 +188,177 @@
   };
   GeisInstance instance;
 
-  if (!parse_opts(argc, argv, &xcb_win_info.window_id))
-  {
-    fprintf(stderr, "usage: %s windowid\n", argv[0]);
-    return -1;
-  }
-
   status = geis_init(&win_info, &instance);
   if (status != GEIS_STATUS_SUCCESS)
   {
     fprintf(stderr, "error in geis_init\n");
-    return 1;
-  }
-
-  status = geis_configuration_supported(instance, GEIS_CONFIG_UNIX_FD);
-  if (status != GEIS_STATUS_SUCCESS)
-  {
-    fprintf(stderr, "GEIS does not support Unix fd\n");
-    return 1;
-  }
-
-  int fd = -1;
-  status = geis_configuration_get_value(instance, GEIS_CONFIG_UNIX_FD, &fd);
-  if (status != GEIS_STATUS_SUCCESS)
-  {
-    fprintf(stderr, "error retrieving GEIS fd\n");
-    return 1;
-  }
-
-  const char *gestures[] =
-  {
-    GEIS_GESTURE_TYPE_ROTATE2,
-    GEIS_GESTURE_TYPE_DRAG3,
-    GEIS_GESTURE_TYPE_ROTATE3,
-    0
-  };
+    return NULL;
+  }
+
+  status = geis_input_devices(instance, &input_funcs, NULL);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    fprintf(stderr, "error subscribing to input devices\n");
+    return NULL;
+  }
 
   status = geis_subscribe(instance,
                           GEIS_ALL_INPUT_DEVICES,
-                          gestures,
+                          GEIS_ALL_GESTURES,
                           &gesture_funcs,
                           NULL);
   if (status != GEIS_STATUS_SUCCESS)
   {
     fprintf(stderr, "error subscribing to gestures\n");
-    return 1;
+    return NULL;
+  }
+
+  return instance;
+}
+
+
+static size_t
+subscribe_windows_preorder(xcb_connection_t *xcb,
+                           xcb_window_t      window,
+                           size_t            instance_table_size,
+                           GeisInstance    **instance_table)
+{
+  ++instance_table_size;
+  GeisInstance  *new_instance_table;
+  new_instance_table = realloc(*instance_table,
+                               instance_table_size * sizeof(GeisInstance));
+  new_instance_table[instance_table_size-1] = subscribe_window(window);
+  if (!new_instance_table[instance_table_size-1])
+  {
+    fprintf(stderr, "error creating geis instance for window 0x%08x\n", window);
+    free(new_instance_table);
+    instance_table_size = 0;
+    goto error_exit;
+  }
+
+  xcb_generic_error_t *error;
+  xcb_query_tree_cookie_t tree_cookie = xcb_query_tree(xcb, window);
+  xcb_query_tree_reply_t *tree_reply = xcb_query_tree_reply(xcb,
+                                                            tree_cookie,
+                                                            &error);
+  if (!tree_reply)
+  {
+    fprintf(stderr, "failed to query tree for window 0x%x\n", window);
+    goto error_exit;
+  }
+
+  int num_children = xcb_query_tree_children_length(tree_reply);
+  if (num_children <= 0)
+    goto tree_exit;
+
+  xcb_window_t *children = xcb_query_tree_children(tree_reply);
+  if (!children)
+  {
+    fprintf(stderr, "failed to retrieve children of window 0x%x\n", window);
+    goto tree_exit;
+  }
+
+  int i;
+  for (i = 0; i < num_children; i++)
+  {
+    instance_table_size = subscribe_windows_preorder(xcb,
+                                                     children[i],
+                                                     instance_table_size,
+                                                     &new_instance_table);
+    if (instance_table_size == 0)
+      break;
+  }
+  
+tree_exit:
+  free(tree_reply);
+error_exit:
+  *instance_table = new_instance_table;
+  return instance_table_size;
+}
+
+
+static size_t
+subscribe_all_windows(GeisInstance **instance_table)
+{
+  int instance_table_size = 0;
+
+  xcb_connection_t *xcb = xcb_connect(NULL, NULL);
+  if (!xcb) {
+    fprintf(stderr, "error connecting to X server\n");
+    return -1;
+  }
+
+  const xcb_setup_t *setup = xcb_get_setup(xcb);
+  if (!setup)
+  {
+    fprintf(stderr, "error getting xcb setup\n");
+    return -1;
+  }
+
+  xcb_screen_iterator_t screen = xcb_setup_roots_iterator(setup);
+  while (screen.rem)
+  {
+    instance_table_size = subscribe_windows_preorder(xcb,
+                                                     screen.data->root,
+                                                     instance_table_size,
+                                                     instance_table);
+
+    xcb_screen_next(&screen);
+  }
+
+  xcb_disconnect(xcb);
+  return instance_table_size;
+}
+
+int
+main(int argc, char* argv[])
+{
+  int result = -1;
+  uint32_t      window_id = 0;
+  int           fd = -1;
+  GeisStatus    status = GEIS_UNKNOWN_ERROR;
+  GeisInstance *instance_table = NULL;
+  size_t        instance_table_size = 0;
+
+  if (!parse_opts(argc, argv, &window_id))
+  {
+    fprintf(stderr, "usage: %s windowid\n", argv[0]);
+    return -1;
+  }
+
+  if (window_id != 0)
+  {
+    instance_table_size = 1;
+    instance_table = calloc(instance_table_size, sizeof(GeisInstance));
+    instance_table[0] = subscribe_window(window_id);
+    if (!instance_table[0])
+    {
+      fprintf(stderr, "can not continue, exiting....\n");
+      goto error_exit;
+    }
+  }
+  else
+  {
+    instance_table_size = subscribe_all_windows(&instance_table);
+    if (instance_table_size == 0)
+    {
+      fprintf(stderr, "can not continue, exiting....\n");
+      goto error_exit;
+    }
+  }
+
+  status = geis_configuration_supported(instance_table[0], GEIS_CONFIG_UNIX_FD);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    fprintf(stderr, "GEIS does not support Unix fd\n");
+    goto fail_exit;
+  }
+
+  status = geis_configuration_get_value(instance_table[0], GEIS_CONFIG_UNIX_FD, &fd);
+  if (status != GEIS_STATUS_SUCCESS)
+  {
+    fprintf(stderr, "error retrieving GEIS fd\n");
+    goto fail_exit;
   }
 
   while(1)
@@ -212,10 +375,24 @@
 
     if (FD_ISSET(fd, &read_fds))
     {
-      geis_event_dispatch(instance);
-    }
-  }
-
-  geis_finish(instance);
+      geis_event_dispatch(instance_table[0]);
+    }
+  }
+
+fail_exit:
+  {
+    int i;
+    for (i = 0; i < instance_table_size; ++i)
+    {
+      geis_finish(instance_table[i]);
+    }
+  }
+
+error_exit:
+  if (instance_table_size > 0)
+  {
+    free(instance_table);
+  }
+  return result;
 }