Reformat all the *.[ch] files with clang-format

I ran this on each directory with C files:

  clang-format -i *.[ch]

"-i" is the in-place option.

I also adjusted the order of #includes for some files which failed to
build after that:

Clang-format reorders blocks of #include directives alphabetically,
but they can be grouped and separated by blank lines.  If there is a
blank line between blocks, like

  #include "zork.h"

  #include "bar.h"
  #include "foo.h"

then it will not put zork.h after the other two.  The last two header
files will be sorted alphabetically.

We can adjust the formatting of chunks of code by hand with comments
like these:

  /* clang-format off */

     this code {
       is, formatted, by, hand;
     }

  /* clang-format on */

See https://clang.llvm.org/docs/ClangFormat.html for the general
manual and https://clang.llvm.org/docs/ClangFormatStyleOptions.html
for the style options and the comments described above.

18 files changed, 1972 insertions, 1894 deletions

diff --git a/registryd/de-marshaller.c b/registryd/de-marshaller.c
index f1094846..8c65bfe7 100644
--- a/registryd/de-marshaller.c
+++ b/registryd/de-marshaller.c
@@ -20,85 +20,93 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <stdlib.h>
-#include <glib.h>
-#include <glib-object.h>
 #include <dbus/dbus.h>
+#include <glib-object.h>
+#include <glib.h>
+#include <stdlib.h>
 
 #include "de-types.h"
 
-dbus_bool_t spi_dbus_message_iter_get_struct(DBusMessageIter *iter, ...)
+dbus_bool_t
+spi_dbus_message_iter_get_struct (DBusMessageIter *iter, ...)
 {
   va_list args;
   DBusMessageIter iter_struct;
   int type;
   void *ptr;
 
-  dbus_message_iter_recurse(iter, &iter_struct);
-  va_start(args, iter);
+  dbus_message_iter_recurse (iter, &iter_struct);
+  va_start (args, iter);
   for (;;)
-  {
-    type = va_arg(args, int);
-    if (type == DBUS_TYPE_INVALID) break;
-    if (type != dbus_message_iter_get_arg_type(&iter_struct))
     {
-      va_end(args);
-      return FALSE;
+      type = va_arg (args, int);
+      if (type == DBUS_TYPE_INVALID)
+        break;
+      if (type != dbus_message_iter_get_arg_type (&iter_struct))
+        {
+          va_end (args);
+          return FALSE;
+        }
+      ptr = va_arg (args, void *);
+      dbus_message_iter_get_basic (&iter_struct, ptr);
+      dbus_message_iter_next (&iter_struct);
     }
-    ptr = va_arg(args, void *);
-    dbus_message_iter_get_basic(&iter_struct, ptr);
-    dbus_message_iter_next(&iter_struct);
-  }
-  dbus_message_iter_next(iter);
-  va_end(args);
+  dbus_message_iter_next (iter);
+  va_end (args);
   return TRUE;
 }
 
-dbus_bool_t spi_dbus_message_iter_append_struct(DBusMessageIter *iter, ...)
+dbus_bool_t
+spi_dbus_message_iter_append_struct (DBusMessageIter *iter, ...)
 {
   va_list args;
   DBusMessageIter iter_struct;
   int type;
   void *ptr;
 
-  if (!dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &iter_struct)) return FALSE;
-  va_start(args, iter);
-  for (;;)
-  {
-    type = va_arg(args, int);
-    if (type == DBUS_TYPE_INVALID) break;
-    ptr = va_arg(args, void *);
-    dbus_message_iter_append_basic(&iter_struct, type, ptr);
-  }
-  if (!dbus_message_iter_close_container(iter, &iter_struct))
-  {
-    va_end(args);
+  if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL, &iter_struct))
     return FALSE;
-  }
-  va_end(args);
+  va_start (args, iter);
+  for (;;)
+    {
+      type = va_arg (args, int);
+      if (type == DBUS_TYPE_INVALID)
+        break;
+      ptr = va_arg (args, void *);
+      dbus_message_iter_append_basic (&iter_struct, type, ptr);
+    }
+  if (!dbus_message_iter_close_container (iter, &iter_struct))
+    {
+      va_end (args);
+      return FALSE;
+    }
+  va_end (args);
   return TRUE;
 }
 
-dbus_bool_t spi_dbus_marshal_deviceEvent(DBusMessage *message, const Accessibility_DeviceEvent *e)
+dbus_bool_t
+spi_dbus_marshal_deviceEvent (DBusMessage *message, const Accessibility_DeviceEvent *e)
 {
   DBusMessageIter iter;
 
-  if (!message) return FALSE;
-  dbus_message_iter_init_append(message, &iter);
-  return spi_dbus_message_iter_append_struct(&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_UINT32, &e->hw_code, DBUS_TYPE_UINT32, &e->modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID);
+  if (!message)
+    return FALSE;
+  dbus_message_iter_init_append (message, &iter);
+  return spi_dbus_message_iter_append_struct (&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_UINT32, &e->hw_code, DBUS_TYPE_UINT32, &e->modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID);
 }
 
-dbus_bool_t spi_dbus_demarshal_deviceEvent(DBusMessage *message, Accessibility_DeviceEvent *e)
+dbus_bool_t
+spi_dbus_demarshal_deviceEvent (DBusMessage *message, Accessibility_DeviceEvent *e)
 {
   DBusMessageIter iter;
   dbus_uint16_t hw_code;
   dbus_uint16_t modifiers;
 
-  dbus_message_iter_init(message, &iter);
-  if (spi_dbus_message_iter_get_struct(&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_INT32, &e->hw_code, DBUS_TYPE_INT32, &e->modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID))
+  dbus_message_iter_init (message, &iter);
+  if (spi_dbus_message_iter_get_struct (&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_INT32, &e->hw_code, DBUS_TYPE_INT32, &e->modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID))
     return TRUE;
   /* TODO: Perhaps remove the below code for 2.1 */
-  if (!spi_dbus_message_iter_get_struct(&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_INT16, &hw_code, DBUS_TYPE_INT16, &modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID))
+  if (!spi_dbus_message_iter_get_struct (&iter, DBUS_TYPE_UINT32, &e->type, DBUS_TYPE_INT32, &e->id, DBUS_TYPE_INT16, &hw_code, DBUS_TYPE_INT16, &modifiers, DBUS_TYPE_INT32, &e->timestamp, DBUS_TYPE_STRING, &e->event_string, DBUS_TYPE_BOOLEAN, &e->is_text, DBUS_TYPE_INVALID))
     return FALSE;
   e->hw_code = hw_code;
   e->modifiers = modifiers;
diff --git a/registryd/de-marshaller.h b/registryd/de-marshaller.h
index 93eaa423..ddaf1360 100644
--- a/registryd/de-marshaller.h
+++ b/registryd/de-marshaller.h
@@ -29,9 +29,9 @@
 
 #include "de-types.h"
 
-dbus_bool_t spi_dbus_message_iter_get_struct(DBusMessageIter *iter, ...);
-dbus_bool_t spi_dbus_message_iter_append_struct(DBusMessageIter *iter, ...);
-dbus_bool_t spi_dbus_marshal_deviceEvent(DBusMessage *message, const Accessibility_DeviceEvent *e);
-dbus_bool_t spi_dbus_demarshal_deviceEvent(DBusMessage *message, Accessibility_DeviceEvent *e);
+dbus_bool_t spi_dbus_message_iter_get_struct (DBusMessageIter *iter, ...);
+dbus_bool_t spi_dbus_message_iter_append_struct (DBusMessageIter *iter, ...);
+dbus_bool_t spi_dbus_marshal_deviceEvent (DBusMessage *message, const Accessibility_DeviceEvent *e);
+dbus_bool_t spi_dbus_demarshal_deviceEvent (DBusMessage *message, Accessibility_DeviceEvent *e);
 
 #endif /* SPI_DE_MARSHALLER_H_ */
diff --git a/registryd/de-types.h b/registryd/de-types.h
index d26cc90f..656aded1 100644
--- a/registryd/de-types.h
+++ b/registryd/de-types.h
@@ -29,45 +29,51 @@
 
 typedef unsigned long Accessibility_ControllerEventMask;
 
-typedef enum {
-    Accessibility_KEY_PRESSED_EVENT,
-    Accessibility_KEY_RELEASED_EVENT,
-    Accessibility_BUTTON_PRESSED_EVENT,
-    Accessibility_BUTTON_RELEASED_EVENT,
+typedef enum
+{
+  Accessibility_KEY_PRESSED_EVENT,
+  Accessibility_KEY_RELEASED_EVENT,
+  Accessibility_BUTTON_PRESSED_EVENT,
+  Accessibility_BUTTON_RELEASED_EVENT,
 } Accessibility_EventType;
 
-typedef enum {
-    Accessibility_KEY_PRESSED,
-    Accessibility_KEY_RELEASED,
+typedef enum
+{
+  Accessibility_KEY_PRESSED,
+  Accessibility_KEY_RELEASED,
 } Accessibility_KeyEventType;
 
-typedef enum {
-    Accessibility_KEY_PRESS,
-    Accessibility_KEY_RELEASE,
-    Accessibility_KEY_PRESSRELEASE,
-    Accessibility_KEY_SYM,
-    Accessibility_KEY_STRING,
-    Accessibility_KEY_LOCKMODIFIERS,
-    Accessibility_KEY_UNLOCKMODIFIERS,
+typedef enum
+{
+  Accessibility_KEY_PRESS,
+  Accessibility_KEY_RELEASE,
+  Accessibility_KEY_PRESSRELEASE,
+  Accessibility_KEY_SYM,
+  Accessibility_KEY_STRING,
+  Accessibility_KEY_LOCKMODIFIERS,
+  Accessibility_KEY_UNLOCKMODIFIERS,
 } Accessibility_KeySynthType;
 
-typedef struct {
+typedef struct
+{
   Accessibility_EventType type;
   dbus_uint32_t id;
   dbus_uint32_t hw_code;
   dbus_uint32_t modifiers;
   dbus_uint32_t timestamp;
-  char * event_string;
+  char *event_string;
   dbus_bool_t is_text;
 } Accessibility_DeviceEvent;
 
-typedef struct {
+typedef struct
+{
   dbus_bool_t synchronous;
   dbus_bool_t preemptive;
   dbus_bool_t global;
 } Accessibility_EventListenerMode;
 
-typedef struct {
+typedef struct
+{
   dbus_int32_t keycode;
   dbus_int32_t keysym;
   char *keystring;
diff --git a/registryd/deviceeventcontroller-x11.c b/registryd/deviceeventcontroller-x11.c
index 689191f7..d5cae611 100644
--- a/registryd/deviceeventcontroller-x11.c
+++ b/registryd/deviceeventcontroller-x11.c
@@ -25,13 +25,13 @@
 
 #include <config.h>
 
-#undef  SPI_XKB_DEBUG
-#undef  SPI_DEBUG
-#undef  SPI_KEYEVENT_DEBUG
+#undef SPI_XKB_DEBUG
+#undef SPI_DEBUG
+#undef SPI_KEYEVENT_DEBUG
 
-#include <string.h>
 #include <ctype.h>
 #include <stdio.h>
+#include <string.h>
 #include <sys/time.h>
 
 #define XK_MISCELLANY
@@ -42,49 +42,50 @@
 
 #include <dbus/dbus.h>
 
-#include "paths.h"
-#include "keymasks.h"
-#include "de-types.h"
 #include "de-marshaller.h"
+#include "de-types.h"
 #include "display.h"
 #include "event-source.h"
+#include "keymasks.h"
+#include "paths.h"
 
 #include "deviceeventcontroller.h"
+
 #include "deviceeventcontroller-x11.h"
 #include "reentrant-list.h"
 
 static void spi_dec_x11_emit_modifier_event (SpiDEController *controller,
-			     guint prev_mask,
-			     guint current_mask);
+                                             guint prev_mask,
+                                             guint current_mask);
 
 #define CHECK_RELEASE_DELAY 20
-#define BIT(c, x)       (c[x/8]&(1<<(x%8)))
+#define BIT(c, x) (c[x / 8] & (1 << (x % 8)))
 static guint check_release_handler = 0;
 static Accessibility_DeviceEvent pressed_event;
 static void wait_for_release_event (XEvent *event, SpiDEController *controller);
 
 static int spi_error_code = 0;
-typedef struct {
-    gint x;
-    gint y;
+typedef struct
+{
+  gint x;
+  gint y;
 } SpiPoint;
-static SpiPoint last_mouse_pos_static = {0, 0}; 
+static SpiPoint last_mouse_pos_static = { 0, 0 };
 static SpiPoint *last_mouse_pos = &last_mouse_pos_static;
 static unsigned int mouse_mask_state = 0;
 static unsigned int mouse_button_mask =
-  Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask;
+    Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask;
 static unsigned int key_modifier_mask =
-  Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask | ShiftMask | LockMask | ControlMask | SPI_KEYMASK_NUMLOCK;
+    Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask | ShiftMask | LockMask | ControlMask | SPI_KEYMASK_NUMLOCK;
 extern unsigned int _numlock_physical_mask;
 
-static XModifierKeymap* xmkeymap = NULL;
-
+static XModifierKeymap *xmkeymap = NULL;
 
 static int (*x_default_error_handler) (Display *display, XErrorEvent *error_event);
 
-static void     spi_controller_register_with_devices          (SpiDEController           *controller);
-static gboolean spi_device_event_controller_forward_key_event (SpiDEController           *controller,
-							       const XEvent              *event);
+static void spi_controller_register_with_devices (SpiDEController *controller);
+static gboolean spi_device_event_controller_forward_key_event (SpiDEController *controller,
+                                                               const XEvent *event);
 
 static SpiDEController *saved_controller;
 
@@ -99,66 +100,76 @@ static SpiDEController *saved_controller;
 static SpiDEControllerPrivate *
 spi_device_event_controller_get_instance_private (SpiDEController *controller)
 {
-        return g_type_instance_get_private ((GTypeInstance *) controller, SPI_DEVICE_EVENT_CONTROLLER_TYPE);
+  return g_type_instance_get_private ((GTypeInstance *) controller, SPI_DEVICE_EVENT_CONTROLLER_TYPE);
 }
 
 static unsigned int
 keysym_mod_mask (KeySym keysym, KeyCode keycode)
 {
-	/* we really should use XKB and look directly at the keymap */
-	/* this is very inelegant */
-	Display *display = spi_get_display ();
-	unsigned int mods_rtn = 0;
-	unsigned int retval = 0;
-	KeySym sym_rtn;
-
-	if (XkbLookupKeySym (display, keycode, 0, &mods_rtn, &sym_rtn) &&
-	    (sym_rtn == keysym)) {
-		retval = 0;
-	}
-	else if (XkbLookupKeySym (display, keycode, ShiftMask, &mods_rtn, &sym_rtn) &&
-		 (sym_rtn == keysym)) {
-		retval = ShiftMask;
-	}
-	else if (XkbLookupKeySym (display, keycode, Mod2Mask, &mods_rtn, &sym_rtn) &&
-		 (sym_rtn == keysym)) {
-		retval = Mod2Mask;
-	}
-	else if (XkbLookupKeySym (display, keycode, Mod3Mask, &mods_rtn, &sym_rtn) &&
-		 (sym_rtn == keysym)) {
-		retval = Mod3Mask;
-	}
-	else if (XkbLookupKeySym (display, keycode, Mod4Mask, &mods_rtn, &sym_rtn) &&
-		 (sym_rtn == keysym)) {
-		retval = Mod4Mask;
-	}
-	else if (XkbLookupKeySym (display, keycode, Mod5Mask, &mods_rtn, &sym_rtn) &&
-		 (sym_rtn == keysym)) {
-		retval = Mod5Mask;
-	}
-	else if (XkbLookupKeySym (display, keycode, 
-				  ShiftMask | Mod2Mask, &mods_rtn, &sym_rtn) &&
-		 (sym_rtn == keysym)) {
-		retval = (Mod2Mask | ShiftMask);
-	}
-	else if (XkbLookupKeySym (display, keycode, 
-				  ShiftMask | Mod3Mask, &mods_rtn, &sym_rtn) &&
-		 (sym_rtn == keysym)) {
-		retval = (Mod3Mask | ShiftMask);
-	}
-	else if (XkbLookupKeySym (display, keycode, 
-				  ShiftMask | Mod4Mask, &mods_rtn, &sym_rtn) &&
-		 (sym_rtn == keysym)) {
-		retval = (Mod4Mask | ShiftMask);
-	}
-	else if (XkbLookupKeySym (display, keycode,
-				  ShiftMask | Mod5Mask, &mods_rtn, &sym_rtn) &&
-		 (sym_rtn == keysym)) {
-		retval = (Mod5Mask | ShiftMask);
-	}
-	else
-		retval = 0xFFFF;
-	return retval;
+  /* we really should use XKB and look directly at the keymap */
+  /* this is very inelegant */
+  Display *display = spi_get_display ();
+  unsigned int mods_rtn = 0;
+  unsigned int retval = 0;
+  KeySym sym_rtn;
+
+  if (XkbLookupKeySym (display, keycode, 0, &mods_rtn, &sym_rtn) &&
+      (sym_rtn == keysym))
+    {
+      retval = 0;
+    }
+  else if (XkbLookupKeySym (display, keycode, ShiftMask, &mods_rtn, &sym_rtn) &&
+           (sym_rtn == keysym))
+    {
+      retval = ShiftMask;
+    }
+  else if (XkbLookupKeySym (display, keycode, Mod2Mask, &mods_rtn, &sym_rtn) &&
+           (sym_rtn == keysym))
+    {
+      retval = Mod2Mask;
+    }
+  else if (XkbLookupKeySym (display, keycode, Mod3Mask, &mods_rtn, &sym_rtn) &&
+           (sym_rtn == keysym))
+    {
+      retval = Mod3Mask;
+    }
+  else if (XkbLookupKeySym (display, keycode, Mod4Mask, &mods_rtn, &sym_rtn) &&
+           (sym_rtn == keysym))
+    {
+      retval = Mod4Mask;
+    }
+  else if (XkbLookupKeySym (display, keycode, Mod5Mask, &mods_rtn, &sym_rtn) &&
+           (sym_rtn == keysym))
+    {
+      retval = Mod5Mask;
+    }
+  else if (XkbLookupKeySym (display, keycode,
+                            ShiftMask | Mod2Mask, &mods_rtn, &sym_rtn) &&
+           (sym_rtn == keysym))
+    {
+      retval = (Mod2Mask | ShiftMask);
+    }
+  else if (XkbLookupKeySym (display, keycode,
+                            ShiftMask | Mod3Mask, &mods_rtn, &sym_rtn) &&
+           (sym_rtn == keysym))
+    {
+      retval = (Mod3Mask | ShiftMask);
+    }
+  else if (XkbLookupKeySym (display, keycode,
+                            ShiftMask | Mod4Mask, &mods_rtn, &sym_rtn) &&
+           (sym_rtn == keysym))
+    {
+      retval = (Mod4Mask | ShiftMask);
+    }
+  else if (XkbLookupKeySym (display, keycode,
+                            ShiftMask | Mod5Mask, &mods_rtn, &sym_rtn) &&
+           (sym_rtn == keysym))
+    {
+      retval = (Mod5Mask | ShiftMask);
+    }
+  else
+    retval = 0xFFFF;
+  return retval;
 }
 
 static gboolean
@@ -176,17 +187,17 @@ replace_map_keysym (SpiDEControllerPrivate *priv, KeyCode keycode, KeySym keysym
   if (desc && desc->map)
     {
       gint offset = desc->map->key_sym_map[keycode].offset;
-      desc->map->syms[offset] = keysym; 
+      desc->map->syms[offset] = keysym;
     }
   else
     {
       fprintf (stderr, "Error changing key map: empty server structure\n");
-    }		
+    }
   XkbSetMap (dpy, XkbAllMapComponentsMask, desc);
   /**
-   *  FIXME: the use of XkbChangeMap, and the reuse of the priv->xkb_desc structure, 
+   *  FIXME: the use of XkbChangeMap, and the reuse of the priv->xkb_desc structure,
    * would be far preferable.
-   * HOWEVER it does not seem to work using XFree 4.3. 
+   * HOWEVER it does not seem to work using XFree 4.3.
    **/
   /*	    XkbChangeMap (dpy, priv->xkb_desc, priv->changes); */
   XFlush (dpy);
@@ -210,126 +221,127 @@ spi_dec_reset_reserved (gpointer data)
 
 static gint
 spi_dec_x11_get_keycode (SpiDEController *controller,
-                          gint keysym,
-                          gchar *key_str,
-                          gboolean fix,
-                          guint *modmask)
+                         gint keysym,
+                         gchar *key_str,
+                         gboolean fix,
+                         guint *modmask)
 {
-	KeyCode keycode = 0;
+  KeyCode keycode = 0;
   if (key_str && key_str[0])
-		keysym = XStringToKeysym(key_str);
-	keycode = XKeysymToKeycode (spi_get_display (), (KeySym) keysym);
-	if (!keycode && fix)
-	{
-          SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
-		/* if there's no keycode available, fix it */
-		if (replace_map_keysym (priv, priv->reserved_keycode, keysym))
-		{
-			keycode = priv->reserved_keycode;
-			/* 
-			 * queue a timer to restore the old keycode.  Ugly, but required 
-			 * due to races / asynchronous X delivery.   
-			 * Long-term fix is to extend the X keymap here instead of replace entries.
-			 */
-			priv->reserved_reset_timeout = g_timeout_add (500, spi_dec_reset_reserved, priv);
-			g_source_set_name_by_id (priv->reserved_reset_timeout, "[at-spi2-core] spi_dec_reset_reserved");
-		}		
-		if (modmask)
-			*modmask = 0;
-		return keycode;
-	}
-	if (modmask) 
-		*modmask = keysym_mod_mask (keysym, keycode);
-	return keycode;
+    keysym = XStringToKeysym (key_str);
+  keycode = XKeysymToKeycode (spi_get_display (), (KeySym) keysym);
+  if (!keycode && fix)
+    {
+      SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
+      /* if there's no keycode available, fix it */
+      if (replace_map_keysym (priv, priv->reserved_keycode, keysym))
+        {
+          keycode = priv->reserved_keycode;
+          /*
+           * queue a timer to restore the old keycode.  Ugly, but required
+           * due to races / asynchronous X delivery.
+           * Long-term fix is to extend the X keymap here instead of replace entries.
+           */
+          priv->reserved_reset_timeout = g_timeout_add (500, spi_dec_reset_reserved, priv);
+          g_source_set_name_by_id (priv->reserved_reset_timeout, "[at-spi2-core] spi_dec_reset_reserved");
+        }
+      if (modmask)
+        *modmask = 0;
+      return keycode;
+    }
+  if (modmask)
+    *modmask = keysym_mod_mask (keysym, keycode);
+  return keycode;
 }
 
 static gboolean
 spi_dec_button_update_and_emit (SpiDEController *controller,
-				guint mask_return)
+                                guint mask_return)
 {
   gchar event_detail[3];
 
   if ((mask_return & mouse_button_mask) !=
-      (mouse_mask_state & mouse_button_mask)) 
+      (mouse_mask_state & mouse_button_mask))
     {
       int button_number = 0;
       gboolean is_down = False;
-      
+
       if (!(mask_return & Button1Mask) &&
-	  (mouse_mask_state & Button1Mask)) 
-	{
-	  mouse_mask_state &= ~Button1Mask;
-	  button_number = 1;
-	} 
+          (mouse_mask_state & Button1Mask))
+        {
+          mouse_mask_state &= ~Button1Mask;
+          button_number = 1;
+        }
       else if ((mask_return & Button1Mask) &&
-	       !(mouse_mask_state & Button1Mask)) 
-	{
-	  mouse_mask_state |= Button1Mask;
-	  button_number = 1;
-	  is_down = True;
-	} 
+               !(mouse_mask_state & Button1Mask))
+        {
+          mouse_mask_state |= Button1Mask;
+          button_number = 1;
+          is_down = True;
+        }
       else if (!(mask_return & Button2Mask) &&
-	       (mouse_mask_state & Button2Mask)) 
-	{
-	  mouse_mask_state &= ~Button2Mask;
-	  button_number = 2;
-	} 
+               (mouse_mask_state & Button2Mask))
+        {
+          mouse_mask_state &= ~Button2Mask;
+          button_number = 2;
+        }
       else if ((mask_return & Button2Mask) &&
-	       !(mouse_mask_state & Button2Mask)) 
-	{
-	  mouse_mask_state |= Button2Mask;
-	  button_number = 2;
-	  is_down = True;
-	} 
+               !(mouse_mask_state & Button2Mask))
+        {
+          mouse_mask_state |= Button2Mask;
+          button_number = 2;
+          is_down = True;
+        }
       else if (!(mask_return & Button3Mask) &&
-	       (mouse_mask_state & Button3Mask)) 
-	{
-	  mouse_mask_state &= ~Button3Mask;
-	  button_number = 3;
-	} 
+               (mouse_mask_state & Button3Mask))
+        {
+          mouse_mask_state &= ~Button3Mask;
+          button_number = 3;
+        }
       else if ((mask_return & Button3Mask) &&
-	       !(mouse_mask_state & Button3Mask)) 
-	{
-	  mouse_mask_state |= Button3Mask;
-	  button_number = 3;
-	  is_down = True;
-	} 
+               !(mouse_mask_state & Button3Mask))
+        {
+          mouse_mask_state |= Button3Mask;
+          button_number = 3;
+          is_down = True;
+        }
       else if (!(mask_return & Button4Mask) &&
-	       (mouse_mask_state & Button4Mask)) 
-	{
-	  mouse_mask_state &= ~Button4Mask;
-	  button_number = 4;
-	} 
+               (mouse_mask_state & Button4Mask))
+        {
+          mouse_mask_state &= ~Button4Mask;
+          button_number = 4;
+        }
       else if ((mask_return & Button4Mask) &&
-	       !(mouse_mask_state & Button4Mask)) 
-	{
-	  mouse_mask_state |= Button4Mask;
-	  button_number = 4;
-	  is_down = True;
-	} 
+               !(mouse_mask_state & Button4Mask))
+        {
+          mouse_mask_state |= Button4Mask;
+          button_number = 4;
+          is_down = True;
+        }
       else if (!(mask_return & Button5Mask) &&
-	       (mouse_mask_state & Button5Mask)) 
-	{
-	  mouse_mask_state &= ~Button5Mask;
-	  button_number = 5;
-	}
+               (mouse_mask_state & Button5Mask))
+        {
+          mouse_mask_state &= ~Button5Mask;
+          button_number = 5;
+        }
       else if ((mask_return & Button5Mask) &&
-	       !(mouse_mask_state & Button5Mask)) 
-	{
-	  mouse_mask_state |= Button5Mask;
-	  button_number = 5;
-	  is_down = True;
-	}
-      if (button_number) {
-#ifdef SPI_DEBUG		  
-	fprintf (stderr, "Button %d %s\n",
-		 button_number, (is_down) ? "Pressed" : "Released");
+               !(mouse_mask_state & Button5Mask))
+        {
+          mouse_mask_state |= Button5Mask;
+          button_number = 5;
+          is_down = True;
+        }
+      if (button_number)
+        {
+#ifdef SPI_DEBUG
+          fprintf (stderr, "Button %d %s\n",
+                   button_number, (is_down) ? "Pressed" : "Released");
 #endif
-	snprintf (event_detail, 3, "%d%c", button_number,
-		  (is_down) ? 'p' : 'r');
-        dbus_uint32_t x = last_mouse_pos->x, y = last_mouse_pos->y;
-        spi_dec_dbus_emit(controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Button", event_detail, x, y);
-      }
+          snprintf (event_detail, 3, "%d%c", button_number,
+                    (is_down) ? 'p' : 'r');
+          dbus_uint32_t x = last_mouse_pos->x, y = last_mouse_pos->y;
+          spi_dec_dbus_emit (controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Button", event_detail, x, y);
+        }
       return TRUE;
     }
   else
@@ -339,10 +351,12 @@ spi_dec_button_update_and_emit (SpiDEController *controller,
 }
 
 static guint
-spi_dec_x11_mouse_check (SpiDEController *controller, 
-		     int *x, int *y, gboolean *moved)
+spi_dec_x11_mouse_check (SpiDEController *controller,
+                         int *x,
+                         int *y,
+                         gboolean *moved)
 {
-  int win_x_return,win_y_return;
+  int win_x_return, win_y_return;
   unsigned int mask_return;
   Window root_return, child_return;
   Display *display = spi_get_display ();
@@ -352,30 +366,31 @@ spi_dec_x11_mouse_check (SpiDEController *controller,
       return 0;
     }
 
-  XQueryPointer(display, DefaultRootWindow (display),
-                &root_return, &child_return,
-                x, y,
-                &win_x_return, &win_y_return, &mask_return);
-  /* 
+  XQueryPointer (display, DefaultRootWindow (display),
+                 &root_return, &child_return,
+                 x, y,
+                 &win_x_return, &win_y_return, &mask_return);
+  /*
    * Since many clients grab the pointer, and X goes an automatic
    * pointer grab on mouse-down, we often must detect mouse button events
-   * by polling rather than via a button grab. 
-   * The while loop (rather than if) is used since it's possible that 
+   * by polling rather than via a button grab.
+   * The while loop (rather than if) is used since it's possible that
    * multiple buttons have changed state since we last checked.
    */
-  if (mask_return != mouse_mask_state) 
+  if (mask_return != mouse_mask_state)
     {
-      while (spi_dec_button_update_and_emit (controller, mask_return));
+      while (spi_dec_button_update_and_emit (controller, mask_return))
+        ;
     }
 
-  if (*x != last_mouse_pos->x || *y != last_mouse_pos->y) 
+  if (*x != last_mouse_pos->x || *y != last_mouse_pos->y)
     {
       // TODO: combine these two signals?
       dbus_uint32_t ix = *x, iy = *y;
-      spi_dec_dbus_emit(controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Abs", "", ix, iy);
+      spi_dec_dbus_emit (controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Abs", "", ix, iy);
       ix -= last_mouse_pos->x;
       iy -= last_mouse_pos->y;
-      spi_dec_dbus_emit(controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Rel", "", ix, iy);
+      spi_dec_dbus_emit (controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Rel", "", ix, iy);
       last_mouse_pos->x = *x;
       last_mouse_pos->y = *y;
       *moved = True;
@@ -392,13 +407,13 @@ spi_dec_x11_mouse_check (SpiDEController *controller,
 static int
 spi_dec_ungrab_mouse (gpointer data)
 {
-	Display *display = spi_get_display ();
-	if (display)
-	  {
-	    XUngrabButton (spi_get_display (), AnyButton, AnyModifier,
-			   XDefaultRootWindow (spi_get_display ()));
-	  }
-	return FALSE;
+  Display *display = spi_get_display ();
+  if (display)
+    {
+      XUngrabButton (spi_get_display (), AnyButton, AnyModifier,
+                     XDefaultRootWindow (spi_get_display ()));
+    }
+  return FALSE;
 }
 #endif
 
@@ -411,14 +426,15 @@ spi_dec_init_mouse_listener (SpiDEController *dec)
   if (display)
     {
       if (XGrabButton (display, AnyButton, AnyModifier,
-		       spi_get_root_window (),
-		       True, ButtonPressMask | ButtonReleaseMask,
-		       GrabModeSync, GrabModeAsync, None, None) != Success) {
+                       spi_get_root_window (),
+                       True, ButtonPressMask | ButtonReleaseMask,
+                       GrabModeSync, GrabModeAsync, None, None) != Success)
+        {
 #ifdef SPI_DEBUG
-	fprintf (stderr, "WARNING: could not grab mouse buttons!\n");
+          fprintf (stderr, "WARNING: could not grab mouse buttons!\n");
 #endif
-	;
-      }
+          ;
+        }
       XSync (display, False);
 #ifdef SPI_DEBUG
       fprintf (stderr, "mouse buttons grabbed\n");
@@ -436,63 +452,63 @@ spi_dec_clear_unlatch_pending (SpiDEController *controller)
 
 static void
 spi_device_event_controller_forward_mouse_event (SpiDEController *controller,
-						 XEvent *xevent)
+                                                 XEvent *xevent)
 {
   gchar event_detail[3];
   XButtonEvent *xbutton_event = (XButtonEvent *) xevent;
   dbus_uint32_t ix, iy;
 
   int button = xbutton_event->button;
-  
+
   unsigned int mouse_button_state = xbutton_event->state;
 
   switch (button)
     {
     case 1:
-	    mouse_button_state |= Button1Mask;
-	    break;
+      mouse_button_state |= Button1Mask;
+      break;
     case 2:
-	    mouse_button_state |= Button2Mask;
-	    break;
+      mouse_button_state |= Button2Mask;
+      break;
     case 3:
-	    mouse_button_state |= Button3Mask;
-	    break;
+      mouse_button_state |= Button3Mask;
+      break;
     case 4:
-	    mouse_button_state |= Button4Mask;
-	    break;
+      mouse_button_state |= Button4Mask;
+      break;
     case 5:
-	    mouse_button_state |= Button5Mask;
-	    break;
+      mouse_button_state |= Button5Mask;
+      break;
     }
 
   last_mouse_pos->x = ((XButtonEvent *) xevent)->x_root;
   last_mouse_pos->y = ((XButtonEvent *) xevent)->y_root;
 
-#ifdef SPI_DEBUG  
+#ifdef SPI_DEBUG
   fprintf (stderr, "mouse button %d %s (%x)\n",
-	   xbutton_event->button, 
-	   (xevent->type == ButtonPress) ? "Press" : "Release",
-	   mouse_button_state);
+           xbutton_event->button,
+           (xevent->type == ButtonPress) ? "Press" : "Release",
+           mouse_button_state);
 #endif
   snprintf (event_detail, 3, "%d%c", button,
-	    (xevent->type == ButtonPress) ? 'p' : 'r');
+            (xevent->type == ButtonPress) ? 'p' : 'r');
 
-  if ((mouse_button_state & mouse_button_mask) != 
-       (mouse_mask_state & mouse_button_mask))
-    { 
+  if ((mouse_button_state & mouse_button_mask) !=
+      (mouse_mask_state & mouse_button_mask))
+    {
       if ((mouse_mask_state & key_modifier_mask) !=
-	  (mouse_button_state & key_modifier_mask))
-	spi_dec_x11_emit_modifier_event (controller, 
-				     mouse_mask_state, mouse_button_state);
+          (mouse_button_state & key_modifier_mask))
+        spi_dec_x11_emit_modifier_event (controller,
+                                         mouse_mask_state, mouse_button_state);
       mouse_mask_state = mouse_button_state;
       ix = last_mouse_pos->x;
       iy = last_mouse_pos->y;
-      spi_dec_dbus_emit(controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Button", event_detail, ix, iy);
+      spi_dec_dbus_emit (controller, SPI_DBUS_INTERFACE_EVENT_MOUSE, "Button", event_detail, ix, iy);
     }
 
   XAllowEvents (spi_get_display (),
-		ReplayPointer,
-		CurrentTime);
+                ReplayPointer,
+                CurrentTime);
 }
 
 static void
@@ -512,7 +528,7 @@ global_filter_fn (XEvent *xevent, void *data)
           gboolean is_consumed;
 
           is_consumed =
-            spi_device_event_controller_forward_key_event (controller, xevent);
+              spi_device_event_controller_forward_key_event (controller, xevent);
 
           if (is_consumed)
             {
@@ -527,10 +543,10 @@ global_filter_fn (XEvent *xevent, void *data)
               for (i = 0; i < n_events; i++)
                 {
                   XNextEvent (display, &next_event);
-		  if (next_event.type != KeyPress &&
-		      next_event.type != KeyRelease)
-			g_warning ("Unexpected event type %d in queue", next_event.type);
-                 }
+                  if (next_event.type != KeyPress &&
+                      next_event.type != KeyRelease)
+                    g_warning ("Unexpected event type %d in queue", next_event.type);
+                }
 
               XAllowEvents (display, AsyncKeyboard, CurrentTime);
               if (n_events)
@@ -552,92 +568,91 @@ global_filter_fn (XEvent *xevent, void *data)
     }
   if (xevent->type == priv->xkb_base_event_code)
     {
-      XkbAnyEvent * xkb_ev = (XkbAnyEvent *) xevent;
+      XkbAnyEvent *xkb_ev = (XkbAnyEvent *) xevent;
       /* ugly but probably necessary...*/
       XSynchronize (display, TRUE);
 
       if (xkb_ev->xkb_type == XkbStateNotify)
         {
-	  XkbStateNotifyEvent *xkb_snev =
-		  (XkbStateNotifyEvent *) xkb_ev;
-	  /* check the mouse, to catch mouse events grabbed by
-	   * another client; in case we should revert this XKB delatch 
-	   */
-	  if (!priv->pending_xkb_mod_relatch_mask)
-	    {
-	      int x, y;
-	      gboolean moved;
-	      spi_dec_x11_mouse_check (controller, &x, &y, &moved);
-	    }
-	  /* we check again, since the previous call may have 
-	     changed this flag */
-	  if (priv->pending_xkb_mod_relatch_mask)
-	    {
-	      unsigned int feedback_mask;
+          XkbStateNotifyEvent *xkb_snev =
+              (XkbStateNotifyEvent *) xkb_ev;
+          /* check the mouse, to catch mouse events grabbed by
+           * another client; in case we should revert this XKB delatch
+           */
+          if (!priv->pending_xkb_mod_relatch_mask)
+            {
+              int x, y;
+              gboolean moved;
+              spi_dec_x11_mouse_check (controller, &x, &y, &moved);
+            }
+          /* we check again, since the previous call may have
+             changed this flag */
+          if (priv->pending_xkb_mod_relatch_mask)
+            {
+              unsigned int feedback_mask;
 #ifdef SPI_XKB_DEBUG
-	      fprintf (stderr, "relatching %x\n",
-		       priv->pending_xkb_mod_relatch_mask);
+              fprintf (stderr, "relatching %x\n",
+                       priv->pending_xkb_mod_relatch_mask);
 #endif
-	      /* temporarily turn off the latch bell, if it's on */
-	      XkbGetControls (display,
-			      XkbAccessXFeedbackMask,
-			      priv->xkb_desc);
-	      feedback_mask = priv->xkb_desc->ctrls->ax_options;
-	      if (feedback_mask & XkbAX_StickyKeysFBMask)
-	      {
-	        XkbControlsChangesRec changes = {XkbAccessXFeedbackMask,
-						 0, False};      
-	        priv->xkb_desc->ctrls->ax_options
-			      &= ~(XkbAX_StickyKeysFBMask);
-	        XkbChangeControls (display, priv->xkb_desc, &changes);
-	      }
-	      /* TODO: account for lock as well as latch */
-	      XkbLatchModifiers (display,
-				 XkbUseCoreKbd,
-				 priv->pending_xkb_mod_relatch_mask,
-				 priv->pending_xkb_mod_relatch_mask);
-	      if (feedback_mask & XkbAX_StickyKeysFBMask)
-	      {	
-	        XkbControlsChangesRec changes = {XkbAccessXFeedbackMask,
-						 0, False};      
-		priv->xkb_desc->ctrls->ax_options = feedback_mask;
-		XkbChangeControls (display, priv->xkb_desc, &changes);
-	      }
+              /* temporarily turn off the latch bell, if it's on */
+              XkbGetControls (display,
+                              XkbAccessXFeedbackMask,
+                              priv->xkb_desc);
+              feedback_mask = priv->xkb_desc->ctrls->ax_options;
+              if (feedback_mask & XkbAX_StickyKeysFBMask)
+                {
+                  XkbControlsChangesRec changes = { XkbAccessXFeedbackMask,
+                                                    0, False };
+                  priv->xkb_desc->ctrls->ax_options &= ~(XkbAX_StickyKeysFBMask);
+                  XkbChangeControls (display, priv->xkb_desc, &changes);
+                }
+              /* TODO: account for lock as well as latch */
+              XkbLatchModifiers (display,
+                                 XkbUseCoreKbd,
+                                 priv->pending_xkb_mod_relatch_mask,
+                                 priv->pending_xkb_mod_relatch_mask);
+              if (feedback_mask & XkbAX_StickyKeysFBMask)
+                {
+                  XkbControlsChangesRec changes = { XkbAccessXFeedbackMask,
+                                                    0, False };
+                  priv->xkb_desc->ctrls->ax_options = feedback_mask;
+                  XkbChangeControls (display, priv->xkb_desc, &changes);
+                }
 #ifdef SPI_XKB_DEBUG
-	      fprintf (stderr, "relatched %x\n",
-		       priv->pending_xkb_mod_relatch_mask);
+              fprintf (stderr, "relatched %x\n",
+                       priv->pending_xkb_mod_relatch_mask);
 #endif
-	      priv->pending_xkb_mod_relatch_mask = 0;
-	    }
-	  else
-	    {
-	      priv->xkb_latch_mask = xkb_snev->latched_mods;
-	    }
-	}
+              priv->pending_xkb_mod_relatch_mask = 0;
+            }
+          else
+            {
+              priv->xkb_latch_mask = xkb_snev->latched_mods;
+            }
+        }
       XSynchronize (display, FALSE);
     }
-  
+
   return;
 }
 
 static gboolean
 spi_clear_error_state (void)
 {
-	gboolean retval = spi_error_code != 0;
-	spi_error_code = 0;
-	return retval;
+  gboolean retval = spi_error_code != 0;
+  spi_error_code = 0;
+  return retval;
 }
 
 static int
 _spi_controller_device_error_handler (Display *display, XErrorEvent *error)
 {
-  if (error->error_code == BadAccess) 
-    {  
+  if (error->error_code == BadAccess)
+    {
       g_message ("Could not complete key grab: grab already in use.\n");
       spi_error_code = BadAccess;
       return 0;
     }
-  else 
+  else
     {
       return (*x_default_error_handler) (display, error);
     }
@@ -649,7 +664,7 @@ spi_controller_register_with_devices (SpiDEController *controller)
   SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
   int event_base, error_base, major_version, minor_version;
 
-  if (XTestQueryExtension (spi_get_display(), &event_base, &error_base, &major_version, &minor_version))
+  if (XTestQueryExtension (spi_get_display (), &event_base, &error_base, &major_version, &minor_version))
     {
       XTestGrabControl (spi_get_display (), True);
     }
@@ -659,71 +674,71 @@ spi_controller_register_with_devices (SpiDEController *controller)
   /* register with: (translated) keystroke handler */
 
   priv->have_xkb = XkbQueryExtension (spi_get_display (),
-				      &priv->xkb_major_extension_opcode,
-				      &priv->xkb_base_event_code,
-				      &priv->xkb_base_error_code, NULL, NULL);
+                                      &priv->xkb_major_extension_opcode,
+                                      &priv->xkb_base_event_code,
+                                      &priv->xkb_base_error_code, NULL, NULL);
   if (priv->have_xkb)
     {
       gint i;
       guint64 reserved = 0;
       priv->xkb_desc = XkbGetMap (spi_get_display (), XkbKeySymsMask, XkbUseCoreKbd);
       XkbSelectEvents (spi_get_display (),
-		       XkbUseCoreKbd,
-		       XkbStateNotifyMask, XkbStateNotifyMask);	    
-      _numlock_physical_mask = XkbKeysymToModifiers (spi_get_display (), 
-						     XK_Num_Lock);
+                       XkbUseCoreKbd,
+                       XkbStateNotifyMask, XkbStateNotifyMask);
+      _numlock_physical_mask = XkbKeysymToModifiers (spi_get_display (),
+                                                     XK_Num_Lock);
       for (i = priv->xkb_desc->max_key_code; i >= priv->xkb_desc->min_key_code; --i)
-      {
-	  if (priv->xkb_desc->map->key_sym_map[i].kt_index[0] == XkbOneLevelIndex)
-	  { 
-	      if (XkbKeycodeToKeysym (spi_get_display (), i, 0, 0) != 0)
-	      {
-		  /* don't use this one if there's a grab client! */
-
-		  /* Runtime errors are generated from these functions,
-		   * that are then quashed. Equivalent to:
-		   * try
-		   *   {Blah}
-		   * except
-		   *   {;}
-		   */
-
-		  spi_x_error_trap ();
-		  XGrabKey (spi_get_display (), i, 0, 
-			    spi_get_root_window (),
-			    TRUE,
-			    GrabModeSync, GrabModeSync);
-		  XSync (spi_get_display (), TRUE);
-		  XUngrabKey (spi_get_display (), i, 0, 
-			      spi_get_root_window ());
-		  if (!spi_x_error_release ())
-		  {
-		      reserved = i;
-		      break;
-		  }
-	      }
-	  }
-      }
-      if (reserved) 
-      {
-	  priv->reserved_keycode = reserved;
-	  priv->reserved_keysym = XkbKeycodeToKeysym (spi_get_display (), reserved, 0, 0);
-      }
+        {
+          if (priv->xkb_desc->map->key_sym_map[i].kt_index[0] == XkbOneLevelIndex)
+            {
+              if (XkbKeycodeToKeysym (spi_get_display (), i, 0, 0) != 0)
+                {
+                  /* don't use this one if there's a grab client! */
+
+                  /* Runtime errors are generated from these functions,
+                   * that are then quashed. Equivalent to:
+                   * try
+                   *   {Blah}
+                   * except
+                   *   {;}
+                   */
+
+                  spi_x_error_trap ();
+                  XGrabKey (spi_get_display (), i, 0,
+                            spi_get_root_window (),
+                            TRUE,
+                            GrabModeSync, GrabModeSync);
+                  XSync (spi_get_display (), TRUE);
+                  XUngrabKey (spi_get_display (), i, 0,
+                              spi_get_root_window ());
+                  if (!spi_x_error_release ())
+                    {
+                      reserved = i;
+                      break;
+                    }
+                }
+            }
+        }
+      if (reserved)
+        {
+          priv->reserved_keycode = reserved;
+          priv->reserved_keysym = XkbKeycodeToKeysym (spi_get_display (), reserved, 0, 0);
+        }
       else
-      { 
-	  priv->reserved_keycode = XKeysymToKeycode (spi_get_display (), XK_numbersign);
-	  priv->reserved_keysym = XK_numbersign;
-      }
+        {
+          priv->reserved_keycode = XKeysymToKeycode (spi_get_display (), XK_numbersign);
+          priv->reserved_keysym = XK_numbersign;
+        }
 #ifdef SPI_RESERVED_DEBUG
       unsigned sym = 0;
       sym = XKeycodeToKeysym (spi_get_display (), reserved, 0);
       fprintf (stderr, "%x\n", sym);
-      fprintf (stderr, "setting the reserved keycode to %d (%s)\n", 
-	       reserved, 
-	       XKeysymToString (XKeycodeToKeysym (spi_get_display (),
-                                                            reserved, 0)));
+      fprintf (stderr, "setting the reserved keycode to %d (%s)\n",
+               reserved,
+               XKeysymToString (XKeycodeToKeysym (spi_get_display (),
+                                                  reserved, 0)));
 #endif
-    }	
+    }
 
   spi_set_filter (global_filter_fn, controller);
   spi_set_events (KeyPressMask | KeyReleaseMask);
@@ -737,11 +752,11 @@ spi_keystroke_from_x_key_event (XKeyEvent *x_key_event)
   Accessibility_DeviceEvent key_event;
   KeySym keysym;
   const int cbuf_bytes = 20;
-  char cbuf [21];
+  char cbuf[21];
   int nbytes;
 
-  nbytes = XLookupString (x_key_event, cbuf, cbuf_bytes, &keysym, NULL);  
-  key_event.id = (dbus_int32_t)(keysym);
+  nbytes = XLookupString (x_key_event, cbuf, cbuf_bytes, &keysym, NULL);
+  key_event.id = (dbus_int32_t) (keysym);
   key_event.hw_code = (dbus_int16_t) x_key_event->keycode;
   if (((XEvent *) x_key_event)->type == KeyPress)
     {
@@ -750,109 +765,109 @@ spi_keystroke_from_x_key_event (XKeyEvent *x_key_event)
   else
     {
       key_event.type = Accessibility_KEY_RELEASED_EVENT;
-    } 
-  key_event.modifiers = (dbus_uint16_t)(x_key_event->state);
+    }
+  key_event.modifiers = (dbus_uint16_t) (x_key_event->state);
   key_event.is_text = FALSE;
   switch (keysym)
     {
-      case ' ':
-        key_event.event_string = g_strdup ("space");
-        break;
-      case XK_Tab:
-        key_event.event_string = g_strdup ("Tab");
-	break;
-      case XK_BackSpace:
-        key_event.event_string = g_strdup ("Backspace");
-	break;
-      case XK_Return:
-        key_event.event_string = g_strdup ("Return");
-	break;
-      case XK_Home:
-        key_event.event_string = g_strdup ("Home");
-	break;
-      case XK_Page_Down:
-        key_event.event_string = g_strdup ("Page_Down");
-	break;
-      case XK_Page_Up:
-        key_event.event_string = g_strdup ("Page_Up");
-	break;
-      case XK_F1:
-        key_event.event_string = g_strdup ("F1");
-	break;
-      case XK_F2:
-        key_event.event_string = g_strdup ("F2");
-	break;
-      case XK_F3:
-        key_event.event_string = g_strdup ("F3");
-	break;
-      case XK_F4:
-        key_event.event_string = g_strdup ("F4");
-	break;
-      case XK_F5:
-        key_event.event_string = g_strdup ("F5");
-	break;
-      case XK_F6:
-        key_event.event_string = g_strdup ("F6");
-	break;
-      case XK_F7:
-        key_event.event_string = g_strdup ("F7");
-	break;
-      case XK_F8:
-        key_event.event_string = g_strdup ("F8");
-	break;
-      case XK_F9:
-        key_event.event_string = g_strdup ("F9");
-	break;
-      case XK_F10:
-        key_event.event_string = g_strdup ("F10");
-	break;
-      case XK_F11:
-        key_event.event_string = g_strdup ("F11");
-	break;
-      case XK_F12:
-        key_event.event_string = g_strdup ("F12");
-	break;
-      case XK_End:
-        key_event.event_string = g_strdup ("End");
-	break;
-      case XK_Escape:
-        key_event.event_string = g_strdup ("Escape");
-	break;
-      case XK_Up:
-        key_event.event_string = g_strdup ("Up");
-	break;
-      case XK_Down:
-        key_event.event_string = g_strdup ("Down");
-	break;
-      case XK_Left:
-        key_event.event_string = g_strdup ("Left");
-	break;
-      case XK_Right:
-        key_event.event_string = g_strdup ("Right");
-	break;
-      default:
-        if (nbytes > 0)
-          {
-	    gunichar c;
-	    cbuf[nbytes] = '\0'; /* OK since length is cbuf_bytes+1 */
-            key_event.event_string = g_strdup (cbuf);
-	    c = keysym2ucs (keysym);
-	    if (c > 0 && !g_unichar_iscntrl (c))
-	      {
-	        key_event.is_text = TRUE; 
-		/* incorrect for some composed chars? */
-	      }
-          }
-        else
-          {
-            key_event.event_string = g_strdup ("");
-          }
+    case ' ':
+      key_event.event_string = g_strdup ("space");
+      break;
+    case XK_Tab:
+      key_event.event_string = g_strdup ("Tab");
+      break;
+    case XK_BackSpace:
+      key_event.event_string = g_strdup ("Backspace");
+      break;
+    case XK_Return:
+      key_event.event_string = g_strdup ("Return");
+      break;
+    case XK_Home:
+      key_event.event_string = g_strdup ("Home");
+      break;
+    case XK_Page_Down:
+      key_event.event_string = g_strdup ("Page_Down");
+      break;
+    case XK_Page_Up:
+      key_event.event_string = g_strdup ("Page_Up");
+      break;
+    case XK_F1:
+      key_event.event_string = g_strdup ("F1");
+      break;
+    case XK_F2:
+      key_event.event_string = g_strdup ("F2");
+      break;
+    case XK_F3:
+      key_event.event_string = g_strdup ("F3");
+      break;
+    case XK_F4:
+      key_event.event_string = g_strdup ("F4");
+      break;
+    case XK_F5:
+      key_event.event_string = g_strdup ("F5");
+      break;
+    case XK_F6:
+      key_event.event_string = g_strdup ("F6");
+      break;
+    case XK_F7:
+      key_event.event_string = g_strdup ("F7");
+      break;
+    case XK_F8:
+      key_event.event_string = g_strdup ("F8");
+      break;
+    case XK_F9:
+      key_event.event_string = g_strdup ("F9");
+      break;
+    case XK_F10:
+      key_event.event_string = g_strdup ("F10");
+      break;
+    case XK_F11:
+      key_event.event_string = g_strdup ("F11");
+      break;
+    case XK_F12:
+      key_event.event_string = g_strdup ("F12");
+      break;
+    case XK_End:
+      key_event.event_string = g_strdup ("End");
+      break;
+    case XK_Escape:
+      key_event.event_string = g_strdup ("Escape");
+      break;
+    case XK_Up:
+      key_event.event_string = g_strdup ("Up");
+      break;
+    case XK_Down:
+      key_event.event_string = g_strdup ("Down");
+      break;
+    case XK_Left:
+      key_event.event_string = g_strdup ("Left");
+      break;
+    case XK_Right:
+      key_event.event_string = g_strdup ("Right");
+      break;
+    default:
+      if (nbytes > 0)
+        {
+          gunichar c;
+          cbuf[nbytes] = '\0'; /* OK since length is cbuf_bytes+1 */
+          key_event.event_string = g_strdup (cbuf);
+          c = keysym2ucs (keysym);
+          if (c > 0 && !g_unichar_iscntrl (c))
+            {
+              key_event.is_text = TRUE;
+              /* incorrect for some composed chars? */
+            }
+        }
+      else
+        {
+          key_event.event_string = g_strdup ("");
+        }
     }
 
   key_event.timestamp = (dbus_uint32_t) x_key_event->time;
 #ifdef SPI_KEYEVENT_DEBUG
   {
-    char *pressed_str  = "pressed";
+    char *pressed_str = "pressed";
     char *released_str = "released";
     char *state_ptr;
 
@@ -860,26 +875,25 @@ spi_keystroke_from_x_key_event (XKeyEvent *x_key_event)
       state_ptr = pressed_str;
     else
       state_ptr = released_str;
- 
+
     fprintf (stderr,
-	     "Key %lu %s (%c), modifiers %d; string=%s [%x] %s\n",
-	     (unsigned long) keysym,
-	     state_ptr,
-	     keysym ? (int) keysym : '*',
-	     (int) x_key_event->state,
-	     key_event.event_string,
-	     key_event.event_string[0],
-	     (key_event.is_text == TRUE) ? "(text)" : "(not text)");
+             "Key %lu %s (%c), modifiers %d; string=%s [%x] %s\n",
+             (unsigned long) keysym,
+             state_ptr,
+             keysym ? (int) keysym : '*',
+             (int) x_key_event->state,
+             key_event.event_string,
+             key_event.event_string[0],
+             (key_event.is_text == TRUE) ? "(text)" : "(not text)");
   }
 #endif
 #ifdef SPI_DEBUG
   fprintf (stderr, "%s%c\n",
-     (x_key_event->state & Mod1Mask)?"Alt-":"",
-     ((x_key_event->state & ShiftMask)^(x_key_event->state & LockMask))?
-     g_ascii_toupper (keysym) : g_ascii_tolower (keysym));
+           (x_key_event->state & Mod1Mask) ? "Alt-" : "",
+           ((x_key_event->state & ShiftMask) ^ (x_key_event->state & LockMask)) ? g_ascii_toupper (keysym) : g_ascii_tolower (keysym));
   fprintf (stderr, "serial: %x Time: %x\n", x_key_event->serial, x_key_event->time);
 #endif /* SPI_DEBUG */
-  return key_event;	
+  return key_event;
 }
 
 static gboolean
@@ -888,12 +902,12 @@ spi_dec_x11_grab_key (SpiDEController *controller,
                       Accessibility_ControllerEventMask mod_mask)
 {
   XGrabKey (spi_get_display (),
-	    key_val,
-	    mod_mask,
-	    spi_get_root_window (),
-	    True,
-	    GrabModeSync,
-	    GrabModeSync);
+            key_val,
+            mod_mask,
+            spi_get_root_window (),
+            True,
+            GrabModeSync,
+            GrabModeSync);
   XSync (spi_get_display (), False);
   return spi_clear_error_state ();
 }
@@ -904,9 +918,9 @@ spi_dec_x11_ungrab_key (SpiDEController *controller,
                         Accessibility_ControllerEventMask mod_mask)
 {
   XUngrabKey (spi_get_display (),
-	      key_val,
-	      mod_mask,
-	      spi_get_root_window ());
+              key_val,
+              mod_mask,
+              spi_get_root_window ());
 }
 
 static unsigned int
@@ -915,26 +929,26 @@ xkb_get_slowkeys_delay (SpiDEController *controller)
   unsigned int retval = 0;
   SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
 #ifdef HAVE_XKB
-#ifdef XKB_HAS_GET_SLOW_KEYS_DELAY	
+#ifdef XKB_HAS_GET_SLOW_KEYS_DELAY
   retval = XkbGetSlowKeysDelay (spi_get_display (),
-				XkbUseCoreKbd, &bounce_delay);
+                                XkbUseCoreKbd, &bounce_delay);
 #else
   if (!(priv->xkb_desc == (XkbDescPtr) BadAlloc || priv->xkb_desc == NULL))
     {
       Status s = XkbGetControls (spi_get_display (),
-				 XkbAllControlsMask, priv->xkb_desc);
+                                 XkbAllControlsMask, priv->xkb_desc);
       if (s == Success)
         {
-	 if (priv->xkb_desc->ctrls->enabled_ctrls & XkbSlowKeysMask)
-		 retval = priv->xkb_desc->ctrls->slow_keys_delay;
-	}
+          if (priv->xkb_desc->ctrls->enabled_ctrls & XkbSlowKeysMask)
+            retval = priv->xkb_desc->ctrls->slow_keys_delay;
+        }
     }
 #endif
 #endif
 #ifdef SPI_XKB_DEBUG
-	fprintf (stderr, "SlowKeys delay: %d\n", (int) retval);
+  fprintf (stderr, "SlowKeys delay: %d\n", (int) retval);
 #endif
-        return retval;
+  return retval;
 }
 
 static unsigned int
@@ -943,19 +957,19 @@ xkb_get_bouncekeys_delay (SpiDEController *controller)
   unsigned int retval = 0;
   SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
 #ifdef HAVE_XKB
-#ifdef XKB_HAS_GET_BOUNCE_KEYS_DELAY	
+#ifdef XKB_HAS_GET_BOUNCE_KEYS_DELAY
   retval = XkbGetBounceKeysDelay (spi_get_display (),
-				  XkbUseCoreKbd, &bounce_delay);
+                                  XkbUseCoreKbd, &bounce_delay);
 #else
   if (!(priv->xkb_desc == (XkbDescPtr) BadAlloc || priv->xkb_desc == NULL))
     {
       Status s = XkbGetControls (spi_get_display (),
-				 XkbAllControlsMask, priv->xkb_desc);
+                                 XkbAllControlsMask, priv->xkb_desc);
       if (s == Success)
         {
-	  if (priv->xkb_desc->ctrls->enabled_ctrls & XkbBounceKeysMask)
-		  retval = priv->xkb_desc->ctrls->debounce_delay;
-	}
+          if (priv->xkb_desc->ctrls->enabled_ctrls & XkbBounceKeysMask)
+            retval = priv->xkb_desc->ctrls->debounce_delay;
+        }
     }
 #endif
 #endif
@@ -969,210 +983,223 @@ static gboolean
 spi_dec_x11_synth_keycode_press (SpiDEController *controller,
                                  unsigned int keycode)
 {
-	unsigned int time = CurrentTime;
-	unsigned int bounce_delay;
-#ifdef THIS_IS_BROKEN 
-	unsigned int elapsed_msec;
-	struct timeval tv;
+  unsigned int time = CurrentTime;
+  unsigned int bounce_delay;
+#ifdef THIS_IS_BROKEN
+  unsigned int elapsed_msec;
+  struct timeval tv;
 #endif
-	SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
-
-	spi_x_error_trap ();
-	if (keycode == priv->last_release_keycode)
-	{
-		bounce_delay = xkb_get_bouncekeys_delay (controller); 
-                if (bounce_delay)
-		{
+  SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
+
+  spi_x_error_trap ();
+  if (keycode == priv->last_release_keycode)
+    {
+      bounce_delay = xkb_get_bouncekeys_delay (controller);
+      if (bounce_delay)
+        {
 #ifdef THIS_IS_BROKEN
-			gettimeofday (&tv, NULL);
-			elapsed_msec =
-				(tv.tv_sec - priv->last_release_time.tv_sec) * 1000
-				+ (tv.tv_usec - priv->last_release_time.tv_usec) / 1000;
-# ifdef SPI_XKB_DEBUG
-			fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec,
-				 (long) (tv.tv_usec - priv->last_release_time.tv_usec));
-# endif
-			if (elapsed_msec < bounce_delay)
-				time = bounce_delay - elapsed_msec + 1;
+          gettimeofday (&tv, NULL);
+          elapsed_msec =
+              (tv.tv_sec - priv->last_release_time.tv_sec) * 1000 + (tv.tv_usec - priv->last_release_time.tv_usec) / 1000;
+#ifdef SPI_XKB_DEBUG
+          fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec,
+                   (long) (tv.tv_usec - priv->last_release_time.tv_usec));
+#endif
+          if (elapsed_msec < bounce_delay)
+            time = bounce_delay - elapsed_msec + 1;
 #else
-			time = bounce_delay + 10;
-			/* fudge for broken XTest */
+          time = bounce_delay + 10;
+          /* fudge for broken XTest */
 #endif
-#ifdef SPI_XKB_DEBUG			
-			fprintf (stderr, "waiting %d ms\n", time);
+#ifdef SPI_XKB_DEBUG
+          fprintf (stderr, "waiting %d ms\n", time);
 #endif
-		}
-	}
-        XTestFakeKeyEvent (spi_get_display (), keycode, True, time);
-	priv->last_press_keycode = keycode;
-	XFlush (spi_get_display ());
-	XSync (spi_get_display (), False);
-	gettimeofday (&priv->last_press_time, NULL);
-	return TRUE;
+        }
+    }
+  XTestFakeKeyEvent (spi_get_display (), keycode, True, time);
+  priv->last_press_keycode = keycode;
+  XFlush (spi_get_display ());
+  XSync (spi_get_display (), False);
+  gettimeofday (&priv->last_press_time, NULL);
+  return TRUE;
 }
 
 static gboolean
 spi_dec_x11_synth_keycode_release (SpiDEController *controller,
-			   unsigned int keycode)
+                                   unsigned int keycode)
 {
-	unsigned int time = CurrentTime;
-	unsigned int slow_delay;
+  unsigned int time = CurrentTime;
+  unsigned int slow_delay;
 #ifdef THIS_IS_BROKEN_DUNNO_WHY
-	unsigned int elapsed_msec;
-	struct timeval tv;
+  unsigned int elapsed_msec;
+  struct timeval tv;
 #endif
-	SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
-
-	spi_x_error_trap ();
-	if (keycode == priv->last_press_keycode)
-	{
-		slow_delay = xkb_get_slowkeys_delay (controller);
-		if (slow_delay)
-		{
+  SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
+
+  spi_x_error_trap ();
+  if (keycode == priv->last_press_keycode)
+    {
+      slow_delay = xkb_get_slowkeys_delay (controller);
+      if (slow_delay)
+        {
 #ifdef THIS_IS_BROKEN_DUNNO_WHY
-			gettimeofday (&tv, NULL);
-			elapsed_msec =
-				(tv.tv_sec - priv->last_press_time.tv_sec) * 1000
-				+ (tv.tv_usec - priv->last_press_time.tv_usec) / 1000;
-# ifdef SPI_XKB_DEBUG
-			fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec,
-				 (long) (tv.tv_usec - priv->last_press_time.tv_usec));
-# endif
-			if (elapsed_msec < slow_delay)
-				time = slow_delay - elapsed_msec + 1;
+          gettimeofday (&tv, NULL);
+          elapsed_msec =
+              (tv.tv_sec - priv->last_press_time.tv_sec) * 1000 + (tv.tv_usec - priv->last_press_time.tv_usec) / 1000;
+#ifdef SPI_XKB_DEBUG
+          fprintf (stderr, "%d ms elapsed (%ld usec)\n", elapsed_msec,
+                   (long) (tv.tv_usec - priv->last_press_time.tv_usec));
+#endif
+          if (elapsed_msec < slow_delay)
+            time = slow_delay - elapsed_msec + 1;
 #else
-			time = slow_delay + 10;
-			/* our XTest seems broken, we have to add slop as above */
+          time = slow_delay + 10;
+          /* our XTest seems broken, we have to add slop as above */
 #endif
-#ifdef SPI_XKB_DEBUG			
-			fprintf (stderr, "waiting %d ms\n", time);
+#ifdef SPI_XKB_DEBUG
+          fprintf (stderr, "waiting %d ms\n", time);
 #endif
-		}
-	}
-        XTestFakeKeyEvent (spi_get_display (), keycode, False, time);
-	priv->last_release_keycode = keycode;
-	XSync (spi_get_display (), False);
-	gettimeofday (&priv->last_release_time, NULL);
-	return TRUE;
+        }
+    }
+  XTestFakeKeyEvent (spi_get_display (), keycode, False, time);
+  priv->last_release_keycode = keycode;
+  XSync (spi_get_display (), False);
+  gettimeofday (&priv->last_release_time, NULL);
+  return TRUE;
 }
 
 static gboolean
 spi_dec_x11_lock_modifiers (SpiDEController *controller, unsigned modifiers)
 {
-    SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
-    
-    if (priv->have_xkb) {
-        return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd, 
-                                  modifiers, modifiers);
-    } else {
-	int mod_index;
-	if (xmkeymap==NULL)
-	  xmkeymap = XGetModifierMapping(spi_get_display ());
-	for (mod_index=0;mod_index<8;mod_index++)
-	    if (modifiers & (1<<mod_index))
-	        spi_dec_x11_synth_keycode_press(controller, xmkeymap->modifiermap[mod_index]);
-	return TRUE;
+  SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
+
+  if (priv->have_xkb)
+    {
+      return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd,
+                               modifiers, modifiers);
+    }
+  else
+    {
+      int mod_index;
+      if (xmkeymap == NULL)
+        xmkeymap = XGetModifierMapping (spi_get_display ());
+      for (mod_index = 0; mod_index < 8; mod_index++)
+        if (modifiers & (1 << mod_index))
+          spi_dec_x11_synth_keycode_press (controller, xmkeymap->modifiermap[mod_index]);
+      return TRUE;
     }
 }
 
 static gboolean
 spi_dec_x11_unlock_modifiers (SpiDEController *controller, unsigned modifiers)
 {
-    SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
-    
-    if (priv->have_xkb) {
-        return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd, 
-                                  modifiers, 0);
-    } else {
-	int mod_index;
-	if (xmkeymap==NULL)
-	  xmkeymap = XGetModifierMapping(spi_get_display ());
-
-	for (mod_index=0;mod_index<8;mod_index++)
-	    if (modifiers & (1<<mod_index))
-	        spi_dec_x11_synth_keycode_release(controller, xmkeymap->modifiermap[mod_index]);
-	return TRUE;
+  SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
+
+  if (priv->have_xkb)
+    {
+      return XkbLockModifiers (spi_get_display (), XkbUseCoreKbd,
+                               modifiers, 0);
+    }
+  else
+    {
+      int mod_index;
+      if (xmkeymap == NULL)
+        xmkeymap = XGetModifierMapping (spi_get_display ());
+
+      for (mod_index = 0; mod_index < 8; mod_index++)
+        if (modifiers & (1 << mod_index))
+          spi_dec_x11_synth_keycode_release (controller, xmkeymap->modifiermap[mod_index]);
+      return TRUE;
     }
 }
 
 static KeySym
 keysym_for_unichar (SpiDEController *controller, gunichar unichar)
 {
-	return (KeySym) ucs2keysym ((long) unichar);
+  return (KeySym) ucs2keysym ((long) unichar);
 }
 
 static gboolean
 spi_dec_x11_synth_keystring (SpiDEController *controller, guint synth_type, gint keycode, const char *keystring)
 {
-	/* probably we need to create and inject an XIM handler eventually. */
-	/* for now, try to match the string to existing 
-	 * keycode+modifier states. 
-         */
-	KeySym *keysyms;
-	gint maxlen = 0;
-	gunichar unichar = 0;
-	gint i = 0;
-	gboolean retval = TRUE;
-	const gchar *c;
-	KeySym keysym;
-
-	if (!(keystring && *keystring && g_utf8_validate (keystring, -1, &c))) { 
-		retval = FALSE;
-	} 
-	else {
+  /* probably we need to create and inject an XIM handler eventually. */
+  /* for now, try to match the string to existing
+   * keycode+modifier states.
+   */
+  KeySym *keysyms;
+  gint maxlen = 0;
+  gunichar unichar = 0;
+  gint i = 0;
+  gboolean retval = TRUE;
+  const gchar *c;
+  KeySym keysym;
+
+  if (!(keystring && *keystring && g_utf8_validate (keystring, -1, &c)))
+    {
+      retval = FALSE;
+    }
+  else
+    {
 #ifdef SPI_DEBUG
-		fprintf (stderr, "[keystring synthesis attempted on %s]\n", keystring);
+      fprintf (stderr, "[keystring synthesis attempted on %s]\n", keystring);
 #endif
-		maxlen = strlen (keystring) + 1;
-		keysyms = g_new0 (KeySym, maxlen);
-
-		while (keystring && (unichar = g_utf8_get_char (keystring))) {
-			char bytes[6];
-			gint mbytes;
-			
-			mbytes = g_unichar_to_utf8 (unichar, bytes);
-			bytes[mbytes] = '\0';
+      maxlen = strlen (keystring) + 1;
+      keysyms = g_new0 (KeySym, maxlen);
+
+      while (keystring && (unichar = g_utf8_get_char (keystring)))
+        {
+          char bytes[6];
+          gint mbytes;
+
+          mbytes = g_unichar_to_utf8 (unichar, bytes);
+          bytes[mbytes] = '\0';
 #ifdef SPI_DEBUG
-		        fprintf (stderr, "[unichar %s]", bytes);
+          fprintf (stderr, "[unichar %s]", bytes);
 #endif
-			keysym = keysym_for_unichar (controller, unichar);
-			if (keysym == NoSymbol) {
+          keysym = keysym_for_unichar (controller, unichar);
+          if (keysym == NoSymbol)
+            {
 #ifdef SPI_DEBUG
-				fprintf (stderr, "no keysym for %s", bytes);
+              fprintf (stderr, "no keysym for %s", bytes);
 #endif
-				retval = FALSE;
-				break;
-			}
-			keysyms[i++] = keysym;
-			keystring = g_utf8_next_char (keystring); 
-		}
-		keysyms[i++] = 0;
-		XSynchronize (spi_get_display (), TRUE);
-		for (i = 0; keysyms[i]; ++i) {
-			if (!spi_dec_synth_keysym (controller, keysyms[i])) {
+              retval = FALSE;
+              break;
+            }
+          keysyms[i++] = keysym;
+          keystring = g_utf8_next_char (keystring);
+        }
+      keysyms[i++] = 0;
+      XSynchronize (spi_get_display (), TRUE);
+      for (i = 0; keysyms[i]; ++i)
+        {
+          if (!spi_dec_synth_keysym (controller, keysyms[i]))
+            {
 #ifdef SPI_DEBUG
-				fprintf (stderr, "could not synthesize %c\n",
-					 (int) keysyms[i]);
+              fprintf (stderr, "could not synthesize %c\n",
+                       (int) keysyms[i]);
 #endif
-				retval = FALSE;
-				break;
-			}
-		}
-		XSynchronize (spi_get_display (), FALSE);
-
-		g_free (keysyms);
-	}
-
-	if (synth_type == Accessibility_KEY_SYM) {
-		keysym = keycode;
-	}
-	else {
-		keysym = XkbKeycodeToKeysym (spi_get_display (), keycode, 0, 0);
-	}
-	if (XkbKeysymToModifiers (spi_get_display (), keysym) == 0)  {
-		spi_dec_clear_unlatch_pending (controller);
-	}
-	return retval;
+              retval = FALSE;
+              break;
+            }
+        }
+      XSynchronize (spi_get_display (), FALSE);
+
+      g_free (keysyms);
+    }
+
+  if (synth_type == Accessibility_KEY_SYM)
+    {
+      keysym = keycode;
+    }
+  else
+    {
+      keysym = XkbKeycodeToKeysym (spi_get_display (), keycode, 0, 0);
+    }
+  if (XkbKeysymToModifiers (spi_get_display (), keysym) == 0)
+    {
+      spi_dec_clear_unlatch_pending (controller);
+    }
+  return retval;
 }
 
 static void
@@ -1206,7 +1233,7 @@ spi_dec_x11_finalize (SpiDEController *controller)
 
 static gboolean
 spi_device_event_controller_forward_key_event (SpiDEController *controller,
-					       const XEvent    *event)
+                                               const XEvent *event)
 {
   SpiDEControllerPrivate *priv = spi_device_event_controller_get_instance_private (controller);
   Accessibility_DeviceEvent key_event;
@@ -1221,11 +1248,10 @@ spi_device_event_controller_forward_key_event (SpiDEController *controller,
 
   /* relay to listeners, and decide whether to consume it or not */
   ret = spi_controller_notify_keylisteners (controller, &key_event, TRUE);
-  g_free(key_event.event_string);
+  g_free (key_event.event_string);
   return ret;
 }
 
-
 static gboolean
 is_key_released (long code)
 {
@@ -1241,7 +1267,7 @@ static gboolean
 check_release (gpointer data)
 {
   gboolean released;
-  Accessibility_DeviceEvent *event = (Accessibility_DeviceEvent *)data;
+  Accessibility_DeviceEvent *event = (Accessibility_DeviceEvent *) data;
   KeyCode code = event->hw_code;
 
   released = is_key_released (code);
@@ -1256,8 +1282,8 @@ check_release (gpointer data)
 }
 
 static void
-wait_for_release_event (XEvent          *event,
-                                    SpiDEController *controller)
+wait_for_release_event (XEvent *event,
+                        SpiDEController *controller)
 {
   pressed_event = spi_keystroke_from_x_key_event ((XKeyEvent *) event);
   check_release_handler = g_timeout_add (CHECK_RELEASE_DELAY, check_release, &pressed_event);
@@ -1265,25 +1291,24 @@ wait_for_release_event (XEvent          *event,
 }
 
 static void
-spi_dec_x11_emit_modifier_event (SpiDEController *controller, guint prev_mask, 
-			     guint current_mask)
+spi_dec_x11_emit_modifier_event (SpiDEController *controller, guint prev_mask, guint current_mask)
 {
   dbus_uint32_t d1, d2;
 
 #ifdef SPI_XKB_DEBUG
-  fprintf (stderr, "MODIFIER CHANGE EVENT! %x to %x\n", 
-	   prev_mask, current_mask);
+  fprintf (stderr, "MODIFIER CHANGE EVENT! %x to %x\n",
+           prev_mask, current_mask);
 #endif
 
   /* set bits for the virtual modifiers like NUMLOCK */
-  if (prev_mask & _numlock_physical_mask) 
+  if (prev_mask & _numlock_physical_mask)
     prev_mask |= SPI_KEYMASK_NUMLOCK;
-  if (current_mask & _numlock_physical_mask) 
+  if (current_mask & _numlock_physical_mask)
     current_mask |= SPI_KEYMASK_NUMLOCK;
 
   d1 = prev_mask & key_modifier_mask;
   d2 = current_mask & key_modifier_mask;
-      spi_dec_dbus_emit(controller, SPI_DBUS_INTERFACE_EVENT_KEYBOARD, "Modifiers", "", d1, d2);
+  spi_dec_dbus_emit (controller, SPI_DBUS_INTERFACE_EVENT_KEYBOARD, "Modifiers", "", d1, d2);
 }
 
 static void
@@ -1298,53 +1323,53 @@ spi_dec_x11_generate_mouse_event (SpiDEController *controller,
 
   switch (eventName[0])
     {
-      case 'b':
-        switch (eventName[1])
-	  {
-	  /* TODO: check number of buttons before parsing */
-	  case '1':
-		    button = 1;
-		    break;
-	  case '2':
-		  button = 2;
-		  break;
-	  case '3':
-	          button = 3;
-	          break;
-	  case '4':
-	          button = 4;
-	          break;
-	  case '5':
-	          button = 5;
-	          break;
-	  default:
-		  err = TRUE;
-	  }
-	if (!err)
-	  {
-	    if (x != -1 && y != -1)
-	      {
-	        XTestFakeMotionEvent (display, DefaultScreen (display),
-				      x, y, 0);
-	      }
-	    XTestFakeButtonEvent (display, button, !(eventName[2] == 'r'), 0);
-	    if (eventName[2] == 'c')
-	      XTestFakeButtonEvent (display, button, FALSE, 1);
-	    else if (eventName[2] == 'd')
-	      {
-	      XTestFakeButtonEvent (display, button, FALSE, 1);
-	      XTestFakeButtonEvent (display, button, TRUE, 2);
-	      XTestFakeButtonEvent (display, button, FALSE, 3);
-	      }
-	  }
-	break;
-      case 'r': /* relative motion */ 
-	XTestFakeRelativeMotionEvent (display, x, y, 0);
-        break;
-      case 'a': /* absolute motion */
-	XTestFakeMotionEvent (display, DefaultScreen (display),
-			      x, y, 0);
-        break;
+    case 'b':
+      switch (eventName[1])
+        {
+        /* TODO: check number of buttons before parsing */
+        case '1':
+          button = 1;
+          break;
+        case '2':
+          button = 2;
+          break;
+        case '3':
+          button = 3;
+          break;
+        case '4':
+          button = 4;
+          break;
+        case '5':
+          button = 5;
+          break;
+        default:
+          err = TRUE;
+        }
+      if (!err)
+        {
+          if (x != -1 && y != -1)
+            {
+              XTestFakeMotionEvent (display, DefaultScreen (display),
+                                    x, y, 0);
+            }
+          XTestFakeButtonEvent (display, button, !(eventName[2] == 'r'), 0);
+          if (eventName[2] == 'c')
+            XTestFakeButtonEvent (display, button, FALSE, 1);
+          else if (eventName[2] == 'd')
+            {
+              XTestFakeButtonEvent (display, button, FALSE, 1);
+              XTestFakeButtonEvent (display, button, TRUE, 2);
+              XTestFakeButtonEvent (display, button, FALSE, 3);
+            }
+        }
+      break;
+    case 'r': /* relative motion */
+      XTestFakeRelativeMotionEvent (display, x, y, 0);
+      break;
+    case 'a': /* absolute motion */
+      XTestFakeMotionEvent (display, DefaultScreen (display),
+                            x, y, 0);
+      break;
     }
 }
 
diff --git a/registryd/deviceeventcontroller-x11.h b/registryd/deviceeventcontroller-x11.h
index e66799e4..a39b57d7 100644
--- a/registryd/deviceeventcontroller-x11.h
+++ b/registryd/deviceeventcontroller-x11.h
@@ -1,13 +1,14 @@
 #ifndef _DEVICEEVENTCONTROLLER_X11_H_
 #define _DEVICEEVENTCONTROLLER_X11_H_
 
-#include <glib.h>
+#include <X11/XKBlib.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/XTest.h>
-#include <X11/XKBlib.h>
+#include <glib.h>
 
-typedef struct {
+typedef struct
+{
   Display *xevie_display;
   unsigned int last_press_keycode;
   unsigned int last_release_keycode;
@@ -22,7 +23,7 @@ typedef struct {
   XkbDescPtr xkb_desc;
   KeyCode reserved_keycode;
   KeySym reserved_keysym;
-  guint  reserved_reset_timeout;
+  guint reserved_reset_timeout;
 } SpiDEControllerPrivate;
 
 #ifdef HAVE_X11
@@ -30,6 +31,6 @@ void spi_dec_setup_x11 (SpiDEControllerClass *klass);
 #endif
 
 long ucs2keysym (long ucs);
-long keysym2ucs(long keysym);
+long keysym2ucs (long keysym);
 
 #endif /* _DEVICEEVENTCONTROLLER_X11_H_ */
diff --git a/registryd/deviceeventcontroller.c b/registryd/deviceeventcontroller.c
index c5d7b9c5..466bae22 100644
--- a/registryd/deviceeventcontroller.c
+++ b/registryd/deviceeventcontroller.c
@@ -25,27 +25,27 @@
 
 #include "config.h"
 
-#undef  SPI_XKB_DEBUG
-#undef  SPI_DEBUG
-#undef  SPI_KEYEVENT_DEBUG
+#undef SPI_XKB_DEBUG
+#undef SPI_DEBUG
+#undef SPI_KEYEVENT_DEBUG
 
-#include <string.h>
 #include <ctype.h>
 #include <stdio.h>
+#include <string.h>
 #include <sys/time.h>
 
 #include <glib.h>
 
 #include <dbus/dbus.h>
 
-#include "paths.h"
-#include "de-types.h"
 #include "de-marshaller.h"
+#include "de-types.h"
 #include "keymasks.h"
+#include "paths.h"
 
 #include "deviceeventcontroller.h"
-#include "reentrant-list.h"
 #include "introspection.h"
+#include "reentrant-list.h"
 
 #ifdef HAVE_X11
 #include "deviceeventcontroller-x11.h"
@@ -59,43 +59,43 @@
  * Otherwise, there is no private data and so we use a dummy struct.
  * This is so that G_ADD_PRIVATE() will have a type to work with.
  */
-typedef struct {
+typedef struct
+{
   int _dummy;
 } SpiDEControllerPrivate;
 #endif
 
-typedef struct {
-    gint x;
-    gint y;
+typedef struct
+{
+  gint x;
+  gint y;
 } SpiPoint;
 
 static unsigned int key_modifier_mask =
-  SPI_KEYMASK_MOD1 | SPI_KEYMASK_MOD2 | SPI_KEYMASK_MOD3 | SPI_KEYMASK_MOD4 |
-  SPI_KEYMASK_MOD5 | SPI_KEYMASK_SHIFT | SPI_KEYMASK_SHIFTLOCK |
-  SPI_KEYMASK_CONTROL | SPI_KEYMASK_NUMLOCK;
+    SPI_KEYMASK_MOD1 | SPI_KEYMASK_MOD2 | SPI_KEYMASK_MOD3 | SPI_KEYMASK_MOD4 |
+    SPI_KEYMASK_MOD5 | SPI_KEYMASK_SHIFT | SPI_KEYMASK_SHIFTLOCK |
+    SPI_KEYMASK_CONTROL | SPI_KEYMASK_NUMLOCK;
 unsigned int _numlock_physical_mask = SPI_KEYMASK_MOD2; /* a guess, will be reset */
 
-
-typedef struct {
-  guint                             ref_count : 30;
-  guint                             pending_add : 1;
-  guint                             pending_remove : 1;
+typedef struct
+{
+  guint ref_count : 30;
+  guint pending_add : 1;
+  guint pending_remove : 1;
 
   Accessibility_ControllerEventMask mod_mask;
-  dbus_uint32_t               key_val;  /* KeyCode */
+  dbus_uint32_t key_val; /* KeyCode */
 } DEControllerGrabMask;
 
-
-gboolean spi_controller_update_key_grabs               (SpiDEController           *controller,
-							       Accessibility_DeviceEvent *recv);
+gboolean spi_controller_update_key_grabs (SpiDEController *controller,
+                                          Accessibility_DeviceEvent *recv);
 
 static gboolean eventtype_seq_contains_event (dbus_uint32_t types,
-					      const Accessibility_DeviceEvent *event);
+                                              const Accessibility_DeviceEvent *event);
 static gboolean spi_dec_poll_mouse_moving (gpointer data);
 static gboolean spi_dec_poll_mouse_idle (gpointer data);
 
-G_DEFINE_TYPE_WITH_CODE(SpiDEController, spi_device_event_controller, G_TYPE_OBJECT,
-                        G_ADD_PRIVATE (SpiDEController))
+G_DEFINE_TYPE_WITH_CODE (SpiDEController, spi_device_event_controller, G_TYPE_OBJECT, G_ADD_PRIVATE (SpiDEController))
 
 static gint
 spi_dec_plat_get_keycode (SpiDEController *controller,
@@ -119,8 +119,10 @@ spi_dec_plat_get_keycode (SpiDEController *controller,
 }
 
 static guint
-spi_dec_plat_mouse_check (SpiDEController *controller, 
-		     int *x, int *y, gboolean *moved)
+spi_dec_plat_mouse_check (SpiDEController *controller,
+                          int *x,
+                          int *y,
+                          gboolean *moved)
 {
   SpiDEControllerClass *klass;
   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
@@ -158,7 +160,7 @@ spi_dec_plat_ungrab_key (SpiDEController *controller, guint key_val, Accessibili
 
 static gboolean
 spi_dec_plat_synth_keycode_press (SpiDEController *controller,
-			 unsigned int keycode)
+                                  unsigned int keycode)
 {
   SpiDEControllerClass *klass;
   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
@@ -170,7 +172,7 @@ spi_dec_plat_synth_keycode_press (SpiDEController *controller,
 
 static gboolean
 spi_dec_plat_synth_keycode_release (SpiDEController *controller,
-			   unsigned int keycode)
+                                    unsigned int keycode)
 {
   SpiDEControllerClass *klass;
   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
@@ -214,8 +216,7 @@ spi_dec_plat_synth_keystring (SpiDEController *controller, guint synth_type, gin
 }
 
 static void
-spi_dec_plat_emit_modifier_event (SpiDEController *controller, guint prev_mask, 
-			     guint current_mask)
+spi_dec_plat_emit_modifier_event (SpiDEController *controller, guint prev_mask, guint current_mask)
 {
   SpiDEControllerClass *klass;
   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
@@ -238,19 +239,19 @@ spi_dec_plat_generate_mouse_event (SpiDEController *controller,
 static DBusMessage *
 invalid_arguments_error (DBusMessage *message)
 {
-    DBusMessage *reply;
-    gchar       *errmsg;
-
-    errmsg= g_strdup_printf (
-            "Method \"%s\" with signature \"%s\" on interface \"%s\" was supplied with invalid arguments\n",
-            dbus_message_get_member (message),
-            dbus_message_get_signature (message),
-            dbus_message_get_interface (message));
-    reply = dbus_message_new_error (message,
-                                    DBUS_ERROR_INVALID_ARGS,
-                                    errmsg);
-    g_free (errmsg);
-    return reply;
+  DBusMessage *reply;
+  gchar *errmsg;
+
+  errmsg = g_strdup_printf (
+      "Method \"%s\" with signature \"%s\" on interface \"%s\" was supplied with invalid arguments\n",
+      dbus_message_get_member (message),
+      dbus_message_get_signature (message),
+      dbus_message_get_interface (message));
+  reply = dbus_message_new_error (message,
+                                  DBUS_ERROR_INVALID_ARGS,
+                                  errmsg);
+  g_free (errmsg);
+  return reply;
 }
 
 /* Private methods */
@@ -278,22 +279,23 @@ spi_dbus_remove_disconnect_match (DBusConnection *bus, const char *name)
 {
   char *match = g_strdup_printf ("interface=%s,member=NameOwnerChanged,arg0=%s", DBUS_INTERFACE_DBUS, name);
   if (match)
-  {
-    DBusError error;
-    dbus_error_init (&error);
-    dbus_bus_remove_match (bus, match, &error);
-    g_free (match);
-    if (dbus_error_is_set (&error))
-      {
-        dbus_error_free (&error);
-        return FALSE;
-      }
-    else
-      {
-        return TRUE;
-      }
-  }
-  else return FALSE;
+    {
+      DBusError error;
+      dbus_error_init (&error);
+      dbus_bus_remove_match (bus, match, &error);
+      g_free (match);
+      if (dbus_error_is_set (&error))
+        {
+          dbus_error_free (&error);
+          return FALSE;
+        }
+      else
+        {
+          return TRUE;
+        }
+    }
+  else
+    return FALSE;
 }
 
 static DEControllerGrabMask *
@@ -327,14 +329,13 @@ spi_grab_mask_compare_values (gconstpointer p1, gconstpointer p2)
       return 0;
     }
   else
-    { 
+    {
       return ((l1->mod_mask != l2->mod_mask) || (l1->key_val != l2->key_val));
     }
 }
 
 void
-spi_dec_dbus_emit (SpiDEController *controller, const char *interface,
-                   const char *name, const char *minor, int a1, int a2)
+spi_dec_dbus_emit (SpiDEController *controller, const char *interface, const char *name, const char *minor, int a1, int a2)
 {
   DBusMessage *signal = NULL;
   DBusMessageIter iter, iter_dict, iter_variant;
@@ -349,11 +350,11 @@ spi_dec_dbus_emit (SpiDEController *controller, const char *interface,
   dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &a1);
   dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &a2);
   dbus_message_iter_open_container (&iter, DBUS_TYPE_VARIANT, "i", &iter_variant);
-      dbus_message_iter_append_basic (&iter_variant, DBUS_TYPE_INT32, &nil);
+  dbus_message_iter_append_basic (&iter_variant, DBUS_TYPE_INT32, &nil);
   dbus_message_iter_close_container (&iter, &iter_variant);
 
   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{sv}", &iter_dict);
-    dbus_message_iter_close_container (&iter, &iter_dict);
+  dbus_message_iter_close_container (&iter, &iter_dict);
 
   dbus_connection_send (controller->bus, signal, NULL);
   dbus_message_unref (signal);
@@ -362,7 +363,7 @@ spi_dec_dbus_emit (SpiDEController *controller, const char *interface,
 static gboolean
 spi_dec_poll_mouse_moved (gpointer data)
 {
-  SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(data);
+  SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (data);
   int x, y;
   gboolean moved;
   guint mask_return;
@@ -382,7 +383,7 @@ spi_dec_poll_mouse_moved (gpointer data)
 static gboolean
 spi_dec_poll_mouse_idle (gpointer data)
 {
-  SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(data);
+  SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (data);
 
   if (!controller->have_mouse_event_listener)
     return FALSE;
@@ -393,14 +394,14 @@ spi_dec_poll_mouse_idle (gpointer data)
       guint id;
       id = g_timeout_add (20, spi_dec_poll_mouse_moving, controller);
       g_source_set_name_by_id (id, "[at-spi2-core] spi_dec_poll_mouse_moving");
-      return FALSE;	    
+      return FALSE;
     }
 }
 
 static gboolean
 spi_dec_poll_mouse_moving (gpointer data)
 {
-  SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER(data);
+  SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (data);
 
   if (!controller->have_mouse_event_listener)
     return FALSE;
@@ -417,10 +418,10 @@ spi_dec_poll_mouse_moving (gpointer data)
 
 /**
  * Eventually we can use this to make the marshalling of mask types
- * more sane, but for now we just use this to detect 
+ * more sane, but for now we just use this to detect
  * the use of 'virtual' masks such as numlock and convert them to
  * system-specific mask values (i.e. ModMask).
- * 
+ *
  **/
 static Accessibility_ControllerEventMask
 spi_dec_translate_mask (Accessibility_ControllerEventMask mask)
@@ -435,61 +436,62 @@ spi_dec_translate_mask (Accessibility_ControllerEventMask mask)
       tmp_mask = mask ^ SPI_KEYMASK_NUMLOCK;
       tmp_mask |= _numlock_physical_mask;
     }
- 
+
   return tmp_mask;
 }
 
 static DEControllerKeyListener *
 spi_dec_key_listener_new (const char *bus_name,
-			  const char *path,
-			  GSList *keys,
-			  const Accessibility_ControllerEventMask mask,
-			  const dbus_uint32_t types,
-			  const Accessibility_EventListenerMode  *mode)
+                          const char *path,
+                          GSList *keys,
+                          const Accessibility_ControllerEventMask mask,
+                          const dbus_uint32_t types,
+                          const Accessibility_EventListenerMode *mode)
 {
   DEControllerKeyListener *key_listener = g_new0 (DEControllerKeyListener, 1);
-  key_listener->listener.bus_name = g_strdup(bus_name);
-  key_listener->listener.path = g_strdup(path);
+  key_listener->listener.bus_name = g_strdup (bus_name);
+  key_listener->listener.path = g_strdup (path);
   key_listener->listener.type = SPI_DEVICE_TYPE_KBD;
   key_listener->keys = keys;
   key_listener->mask = spi_dec_translate_mask (mask);
   key_listener->listener.types = types;
   if (mode)
-  {
-    key_listener->mode = (Accessibility_EventListenerMode *) g_malloc(sizeof(Accessibility_EventListenerMode));
-    memcpy(key_listener->mode, mode, sizeof(*mode));
-  }
+    {
+      key_listener->mode = (Accessibility_EventListenerMode *) g_malloc (sizeof (Accessibility_EventListenerMode));
+      memcpy (key_listener->mode, mode, sizeof (*mode));
+    }
   else
     key_listener->mode = NULL;
 
 #ifdef SPI_DEBUG
   g_print ("new listener, with mask %x, is_global %d, keys %p (%d)\n",
-	   (unsigned int) key_listener->mask,
+           (unsigned int) key_listener->mask,
            (int) (mode ? mode->global : 0),
-	   (void *) key_listener->keys,
-	   (int) (key_listener->keys ? g_slist_length(key_listener->keys) : 0));
+           (void *) key_listener->keys,
+           (int) (key_listener->keys ? g_slist_length (key_listener->keys) : 0));
 #endif
 
-  return key_listener;	
+  return key_listener;
 }
 
-static GSList *keylist_clone (GSList *s)
+static GSList *
+keylist_clone (GSList *s)
 {
   GSList *d = NULL;
   GSList *l;
 
-  for (l = s; l; l = g_slist_next(l))
-  {
-    Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
-    if (kd)
+  for (l = s; l; l = g_slist_next (l))
     {
-      Accessibility_KeyDefinition *kds = (Accessibility_KeyDefinition *)l->data;
-      kd->keycode = kds->keycode;
-      kd->keysym = kds->keysym;
-      kd->keystring = g_strdup(kds->keystring);
-      d = g_slist_append(d, kd);
+      Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *) g_malloc (sizeof (Accessibility_KeyDefinition));
+      if (kd)
+        {
+          Accessibility_KeyDefinition *kds = (Accessibility_KeyDefinition *) l->data;
+          kd->keycode = kds->keycode;
+          kd->keysym = kds->keysym;
+          kd->keystring = g_strdup (kds->keystring);
+          d = g_slist_append (d, kd);
+        }
     }
-  }
   return d;
 }
 
@@ -504,33 +506,36 @@ spi_key_listener_clone (DEControllerKeyListener *key_listener)
   clone->mask = key_listener->mask;
   clone->listener.types = key_listener->listener.types;
   if (key_listener->mode)
-  {
-    clone->mode = (Accessibility_EventListenerMode *)g_malloc(sizeof(Accessibility_EventListenerMode));
-    if (clone->mode) memcpy(clone->mode, key_listener->mode, sizeof(Accessibility_EventListenerMode));
-  }
+    {
+      clone->mode = (Accessibility_EventListenerMode *) g_malloc (sizeof (Accessibility_EventListenerMode));
+      if (clone->mode)
+        memcpy (clone->mode, key_listener->mode, sizeof (Accessibility_EventListenerMode));
+    }
   else
     clone->mode = NULL;
   return clone;
 }
 
-static void keylist_free(GSList *keys)
+static void
+keylist_free (GSList *keys)
 {
   GSList *l;
 
-  for (l = keys; l; l = g_slist_next(l))
-  {
-    Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)l->data;
-    g_free(kd->keystring);
-    g_free(kd);
-  }
+  for (l = keys; l; l = g_slist_next (l))
+    {
+      Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *) l->data;
+      g_free (kd->keystring);
+      g_free (kd);
+    }
   g_slist_free (keys);
 }
 
 static void
 spi_key_listener_data_free (DEControllerKeyListener *key_listener)
 {
-  keylist_free(key_listener->keys);
-  if (key_listener->mode) g_free(key_listener->mode);
+  keylist_free (key_listener->keys);
+  if (key_listener->mode)
+    g_free (key_listener->mode);
   g_free (key_listener->listener.bus_name);
   g_free (key_listener->listener.path);
   g_free (key_listener);
@@ -543,25 +548,25 @@ spi_key_listener_clone_free (DEControllerKeyListener *clone)
 }
 
 static void
-spi_dec_listener_free (DEControllerListener    *listener)
+spi_dec_listener_free (DEControllerListener *listener)
 {
-  if (listener->type == SPI_DEVICE_TYPE_KBD) 
+  if (listener->type == SPI_DEVICE_TYPE_KBD)
     spi_key_listener_data_free ((DEControllerKeyListener *) listener);
   else
-  {
-    g_free (listener->bus_name);
-    g_free (listener->path);
-  }
+    {
+      g_free (listener->bus_name);
+      g_free (listener->path);
+    }
 }
 
 static void
-_register_keygrab (SpiDEController      *controller,
-		   DEControllerGrabMask *grab_mask)
+_register_keygrab (SpiDEController *controller,
+                   DEControllerGrabMask *grab_mask)
 {
   GList *l;
 
   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
-			  spi_grab_mask_compare_values);
+                          spi_grab_mask_compare_values);
   if (l)
     {
       DEControllerGrabMask *cur_mask = l->data;
@@ -570,24 +575,24 @@ _register_keygrab (SpiDEController      *controller,
       if (cur_mask->pending_remove)
         {
           cur_mask->pending_remove = FALSE;
-	}
+        }
     }
   else
     {
       controller->keygrabs_list =
-        g_list_prepend (controller->keygrabs_list,
-			spi_grab_mask_clone (grab_mask));
+          g_list_prepend (controller->keygrabs_list,
+                          spi_grab_mask_clone (grab_mask));
     }
 }
 
 static void
-_deregister_keygrab (SpiDEController      *controller,
-		     DEControllerGrabMask *grab_mask)
+_deregister_keygrab (SpiDEController *controller,
+                     DEControllerGrabMask *grab_mask)
 {
   GList *l;
 
   l = g_list_find_custom (controller->keygrabs_list, grab_mask,
-			  spi_grab_mask_compare_values);
+                          spi_grab_mask_compare_values);
 
   if (l)
     {
@@ -597,15 +602,15 @@ _deregister_keygrab (SpiDEController      *controller,
       if (cur_mask->ref_count <= 0)
         {
           cur_mask->pending_remove = TRUE;
-	}
+        }
     }
 }
 
 static void
-handle_keygrab (SpiDEController         *controller,
-		DEControllerKeyListener *key_listener,
-		void                   (*process_cb) (SpiDEController *controller,
-						      DEControllerGrabMask *grab_mask))
+handle_keygrab (SpiDEController *controller,
+                DEControllerKeyListener *key_listener,
+                void (*process_cb) (SpiDEController *controller,
+                                    DEControllerGrabMask *grab_mask))
 {
   DEControllerGrabMask grab_mask = { 0 };
 
@@ -622,30 +627,30 @@ handle_keygrab (SpiDEController         *controller,
     {
       GSList *l;
 
-      for (l = key_listener->keys; l; l = g_slist_next(l))
+      for (l = key_listener->keys; l; l = g_slist_next (l))
         {
-	  Accessibility_KeyDefinition *keydef = l->data;
-	  long key_val;
-	  key_val = spi_dec_plat_get_keycode (controller, keydef->keysym, keydef->keystring, FALSE, NULL);
-	  if (!key_val)
-	    key_val = keydef->keycode;
-	  grab_mask.key_val = key_val;
-	  process_cb (controller, &grab_mask);
-	}
+          Accessibility_KeyDefinition *keydef = l->data;
+          long key_val;
+          key_val = spi_dec_plat_get_keycode (controller, keydef->keysym, keydef->keystring, FALSE, NULL);
+          if (!key_val)
+            key_val = keydef->keycode;
+          grab_mask.key_val = key_val;
+          process_cb (controller, &grab_mask);
+        }
     }
 }
 
 static gboolean
-spi_controller_register_global_keygrabs (SpiDEController         *controller,
-					 DEControllerKeyListener *key_listener)
+spi_controller_register_global_keygrabs (SpiDEController *controller,
+                                         DEControllerKeyListener *key_listener)
 {
   handle_keygrab (controller, key_listener, _register_keygrab);
   return spi_controller_update_key_grabs (controller, NULL);
 }
 
 static void
-spi_controller_deregister_global_keygrabs (SpiDEController         *controller,
-					   DEControllerKeyListener *key_listener)
+spi_controller_deregister_global_keygrabs (SpiDEController *controller,
+                                           DEControllerKeyListener *key_listener)
 {
   handle_keygrab (controller, key_listener, _deregister_keygrab);
   spi_controller_update_key_grabs (controller, NULL);
@@ -672,49 +677,49 @@ append_keystroke_listener (DBusMessageIter *iter, DEControllerKeyListener *liste
   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &d_uint);
   if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY,
                                          "(iisi)", &iter_subarray))
-  {
-    dbus_message_iter_close_container (iter, &iter_struct);
-    return;
-  }
+    {
+      dbus_message_iter_close_container (iter, &iter_struct);
+      return;
+    }
   for (kl = listener->keys; kl; kl = kl->next)
-  {
-    Accessibility_KeyDefinition *kd = kl->data;
-    if (!dbus_message_iter_open_container (&iter_subarray, DBUS_TYPE_STRUCT,
-                                         NULL, &iter_substruct))
-      break;
-    dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keycode);
-    dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keysym);
-    dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_STRING, &kd->keystring);
-    dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->unused);
-    dbus_message_iter_close_container (&iter_subarray, &iter_substruct);
-  }
+    {
+      Accessibility_KeyDefinition *kd = kl->data;
+      if (!dbus_message_iter_open_container (&iter_subarray, DBUS_TYPE_STRUCT,
+                                             NULL, &iter_substruct))
+        break;
+      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keycode);
+      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->keysym);
+      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_STRING, &kd->keystring);
+      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_INT32, &kd->unused);
+      dbus_message_iter_close_container (&iter_subarray, &iter_substruct);
+    }
   dbus_message_iter_close_container (&iter_struct, &iter_subarray);
   d_uint = listener->mask;
   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_UINT32, &d_uint);
   if (dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_STRUCT,
-                                         NULL, &iter_substruct))
-  {
-    if (listener->mode)
-    {
-      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
-                                      &listener->mode->synchronous);
-      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
-                                      &listener->mode->preemptive);
-      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
-                                      &listener->mode->global);
-    }
-    else
-    {
-      dbus_bool_t dummy_val = FALSE;
-      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
-                                      &dummy_val);
-      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
-                                      &dummy_val);
-      dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
-                                      &dummy_val);
-    }
-    dbus_message_iter_close_container (&iter_struct, &iter_substruct);
-  }
+                                        NULL, &iter_substruct))
+    {
+      if (listener->mode)
+        {
+          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
+                                          &listener->mode->synchronous);
+          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
+                                          &listener->mode->preemptive);
+          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
+                                          &listener->mode->global);
+        }
+      else
+        {
+          dbus_bool_t dummy_val = FALSE;
+          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
+                                          &dummy_val);
+          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
+                                          &dummy_val);
+          dbus_message_iter_append_basic (&iter_substruct, DBUS_TYPE_BOOLEAN,
+                                          &dummy_val);
+        }
+      dbus_message_iter_close_container (&iter_struct, &iter_substruct);
+    }
   dbus_message_iter_close_container (iter, &iter_struct);
 }
 
@@ -726,8 +731,8 @@ notify_keystroke_listener (SpiDEController *controller,
   const char *path = SPI_DBUS_PATH_DEC;
   const char *interface = SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER;
   const char *name = (enable
-                      ? "KeystrokeListenerRegistered"
-                      : "KeystrokeListenerDeregistered");
+                          ? "KeystrokeListenerRegistered"
+                          : "KeystrokeListenerDeregistered");
   DBusMessage *signal;
   DBusMessageIter iter;
 
@@ -741,41 +746,42 @@ notify_keystroke_listener (SpiDEController *controller,
 }
 
 static gboolean
-spi_controller_register_device_listener (SpiDEController      *controller,
-					 DEControllerListener *listener)
+spi_controller_register_device_listener (SpiDEController *controller,
+                                         DEControllerListener *listener)
 {
   DEControllerKeyListener *key_listener;
   gboolean retval;
-  
-  switch (listener->type) {
-  case SPI_DEVICE_TYPE_KBD:
+
+  switch (listener->type)
+    {
+    case SPI_DEVICE_TYPE_KBD:
       key_listener = (DEControllerKeyListener *) listener;
 
       controller->key_listeners = g_list_prepend (controller->key_listeners,
-						  key_listener);
+                                                  key_listener);
       spi_dbus_add_disconnect_match (controller->bus, key_listener->listener.bus_name);
       if (key_listener->mode->global)
         {
-	  retval = spi_controller_register_global_keygrabs (controller, key_listener);
-	}
+          retval = spi_controller_register_global_keygrabs (controller, key_listener);
+        }
       else
-	  retval = TRUE;
+        retval = TRUE;
       if (retval)
-	notify_keystroke_listener (controller, key_listener, TRUE);
+        notify_keystroke_listener (controller, key_listener, TRUE);
       break;
-  default:
+    default:
       g_assert_not_reached ();
       break;
-  }
+    }
   return FALSE;
 }
 
 static void
 set_reply (DBusPendingCall *pending, void *user_data)
 {
-    void **replyptr = (void **)user_data;
+  void **replyptr = (void **) user_data;
 
-    *replyptr = dbus_pending_call_steal_reply (pending);
+  *replyptr = dbus_pending_call_steal_reply (pending);
 }
 
 static GSList *hung_processes = NULL;
@@ -791,15 +797,15 @@ reset_hung_process (DBusPendingCall *pending, void *data)
   dbus_pending_call_unref (pending);
 
   for (l = hung_processes; l; l = l->next)
-  {
-    if (!strcmp (l->data, dest))
     {
-      gpointer l_data = l->data;
-      hung_processes = g_slist_remove (hung_processes, l_data);
-      g_free (l_data);
-      break;
+      if (!strcmp (l->data, dest))
+        {
+          gpointer l_data = l->data;
+          hung_processes = g_slist_remove (hung_processes, l_data);
+          g_free (l_data);
+          break;
+        }
     }
-  }
 }
 
 static gint
@@ -817,15 +823,15 @@ reset_hung_process_from_ping (DBusPendingCall *pending, void *data)
   GSList *l;
 
   for (l = hung_processes; l; l = l->next)
-  {
-    if (!strcmp (l->data, data))
     {
-      gpointer l_data = l->data;
-      hung_processes = g_slist_remove (hung_processes, l_data);
-      g_free (l_data);
-      break;
+      if (!strcmp (l->data, data))
+        {
+          gpointer l_data = l->data;
+          hung_processes = g_slist_remove (hung_processes, l_data);
+          g_free (l_data);
+          break;
+        }
     }
-  }
   g_free (data);
   dbus_pending_call_unref (pending);
 }
@@ -833,97 +839,97 @@ reset_hung_process_from_ping (DBusPendingCall *pending, void *data)
 static DBusMessage *
 send_and_allow_reentry (DBusConnection *bus, DBusMessage *message, int timeout, DBusError *error)
 {
-    DBusPendingCall *pending;
-    DBusMessage *reply = NULL;
+  DBusPendingCall *pending;
+  DBusMessage *reply = NULL;
   struct timeval tv;
 
-    if (!dbus_connection_send_with_reply (bus, message, &pending, -1))
+  if (!dbus_connection_send_with_reply (bus, message, &pending, -1))
     {
-        return NULL;
+      return NULL;
     }
-    dbus_pending_call_set_notify (pending, set_reply, (void *)&reply, NULL);
-    gettimeofday (&tv, NULL);
-    while (!reply)
+  dbus_pending_call_set_notify (pending, set_reply, (void *) &reply, NULL);
+  gettimeofday (&tv, NULL);
+  while (!reply)
     {
       if (!dbus_connection_read_write_dispatch (bus, timeout) ||
           time_elapsed (&tv) > timeout)
-      {
-        const char *dest = dbus_message_get_destination (message);
-        GSList *l;
-        gchar *bus_name_dup;
-        dbus_message_ref (message);
-        dbus_pending_call_set_notify (pending, reset_hung_process, message,
-                                      (DBusFreeFunction) dbus_message_unref);
-        message = dbus_message_new_method_call (dest, "/",
-                                                "org.freedesktop.DBus.Peer",
-                                                "Ping");
-        if (!message)
-          return NULL;
-        dbus_connection_send_with_reply (bus, message, &pending, -1);
-        dbus_message_unref (message);
-        if (!pending)
-          return NULL;
-        bus_name_dup = g_strdup (dest);
-        dbus_pending_call_set_notify (pending, reset_hung_process_from_ping,
-                                      bus_name_dup, NULL);
-        for (l = hung_processes; l; l = l->next)
-          if (!strcmp (l->data, dest))
+        {
+          const char *dest = dbus_message_get_destination (message);
+          GSList *l;
+          gchar *bus_name_dup;
+          dbus_message_ref (message);
+          dbus_pending_call_set_notify (pending, reset_hung_process, message,
+                                        (DBusFreeFunction) dbus_message_unref);
+          message = dbus_message_new_method_call (dest, "/",
+                                                  "org.freedesktop.DBus.Peer",
+                                                  "Ping");
+          if (!message)
+            return NULL;
+          dbus_connection_send_with_reply (bus, message, &pending, -1);
+          dbus_message_unref (message);
+          if (!pending)
             return NULL;
-        hung_processes = g_slist_prepend (hung_processes, g_strdup (dest));
-        return NULL;
-      }
+          bus_name_dup = g_strdup (dest);
+          dbus_pending_call_set_notify (pending, reset_hung_process_from_ping,
+                                        bus_name_dup, NULL);
+          for (l = hung_processes; l; l = l->next)
+            if (!strcmp (l->data, dest))
+              return NULL;
+          hung_processes = g_slist_prepend (hung_processes, g_strdup (dest));
+          return NULL;
+        }
     }
-    dbus_pending_call_unref (pending);
-    return reply;
+  dbus_pending_call_unref (pending);
+  return reply;
 }
 static gboolean
-Accessibility_DeviceEventListener_NotifyEvent(SpiDEController *controller,
-                                              DEControllerListener *listener,
-                                              const Accessibility_DeviceEvent *key_event)
-{
-  DBusMessage *message = dbus_message_new_method_call(listener->bus_name,
-                                                      listener->path,
-                                                      SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER,
-                                                      "NotifyEvent");
+Accessibility_DeviceEventListener_NotifyEvent (SpiDEController *controller,
+                                               DEControllerListener *listener,
+                                               const Accessibility_DeviceEvent *key_event)
+{
+  DBusMessage *message = dbus_message_new_method_call (listener->bus_name,
+                                                       listener->path,
+                                                       SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER,
+                                                       "NotifyEvent");
   dbus_bool_t consumed = FALSE;
   GSList *l;
   gboolean hung = FALSE;
 
   for (l = hung_processes; l; l = l->next)
-  {
-    if (!strcmp (l->data, listener->bus_name))
     {
-      dbus_message_set_no_reply (message, TRUE);
-      hung = TRUE;
-      break;
+      if (!strcmp (l->data, listener->bus_name))
+        {
+          dbus_message_set_no_reply (message, TRUE);
+          hung = TRUE;
+          break;
+        }
     }
-  }
-
-  if (spi_dbus_marshal_deviceEvent(message, key_event))
-  {
-    DBusMessage *reply;
 
-    if (hung)
+  if (spi_dbus_marshal_deviceEvent (message, key_event))
     {
-      dbus_connection_send (controller->bus, message, NULL);
-      dbus_message_unref (message);
-      return FALSE;
-    }
+      DBusMessage *reply;
 
-    reply = send_and_allow_reentry (controller->bus, message, 3000, NULL);
-    if (reply)
-    {
-      dbus_message_get_args(reply, NULL, DBUS_TYPE_BOOLEAN, &consumed, DBUS_TYPE_INVALID);
-      dbus_message_unref(reply);
+      if (hung)
+        {
+          dbus_connection_send (controller->bus, message, NULL);
+          dbus_message_unref (message);
+          return FALSE;
+        }
+
+      reply = send_and_allow_reentry (controller->bus, message, 3000, NULL);
+      if (reply)
+        {
+          dbus_message_get_args (reply, NULL, DBUS_TYPE_BOOLEAN, &consumed, DBUS_TYPE_INVALID);
+          dbus_message_unref (reply);
+        }
     }
-  }
-  dbus_message_unref(message);
+  dbus_message_unref (message);
   return consumed;
 }
 
 static gboolean
-key_set_contains_key (GSList                          *key_set,
-			  const Accessibility_DeviceEvent *key_event)
+key_set_contains_key (GSList *key_set,
+                      const Accessibility_DeviceEvent *key_event)
 {
   gint i;
   gint len;
@@ -938,40 +944,40 @@ key_set_contains_key (GSList                          *key_set,
     }
 
   len = g_slist_length (key_set);
-  
+
   if (len == 0) /* special case, means "all keys/any key" */
     {
 #ifdef SPI_DEBUG
-      g_print ("anykey\n");	    
+      g_print ("anykey\n");
 #endif
       return TRUE;
     }
 
-  for (l = key_set,i = 0; l; l = g_slist_next(l),i++)
+  for (l = key_set, i = 0; l; l = g_slist_next (l), i++)
     {
       Accessibility_KeyDefinition *kd = l->data;
-#ifdef SPI_KEYEVENT_DEBUG	    
+#ifdef SPI_KEYEVENT_DEBUG
       g_print ("key_set[%d] event = %d, code = %d; key_event %d, code %d, string %s\n",
-                i,
-                (int) kd->keysym,
-                (int) kd->keycode,
-                (int) key_event->id,
-                (int) key_event->hw_code,
-                key_event->event_string); 
+               i,
+               (int) kd->keysym,
+               (int) kd->keycode,
+               (int) key_event->id,
+               (int) key_event->hw_code,
+               key_event->event_string);
 #endif
       if (kd->keysym == (dbus_uint32_t) key_event->id)
         {
           return TRUE;
-	}
+        }
       if (kd->keycode == (dbus_uint32_t) key_event->hw_code)
         {
           return TRUE;
-	}
+        }
       if (key_event->event_string && key_event->event_string[0] &&
-	  !strcmp (kd->keystring, key_event->event_string))
+          !strcmp (kd->keystring, key_event->event_string))
         {
           return TRUE;
-	}
+        }
     }
 
   return FALSE;
@@ -979,7 +985,7 @@ key_set_contains_key (GSList                          *key_set,
 
 static gboolean
 eventtype_seq_contains_event (dbus_uint32_t types,
-				  const Accessibility_DeviceEvent *event)
+                              const Accessibility_DeviceEvent *event)
 {
   if (types == 0) /* special case, means "all events/any event" */
     {
@@ -991,12 +997,12 @@ eventtype_seq_contains_event (dbus_uint32_t types,
 
 static gboolean
 spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event,
-				DEControllerKeyListener         *listener,
-				dbus_bool_t                    is_system_global)
+                                DEControllerKeyListener *listener,
+                                dbus_bool_t is_system_global)
 {
   if (((key_event->modifiers & 0xFF) == (dbus_uint16_t) (listener->mask & 0xFF)) &&
-       key_set_contains_key (listener->keys, key_event) &&
-       eventtype_seq_contains_event (listener->listener.types, key_event) && 
+      key_set_contains_key (listener->keys, key_event) &&
+      eventtype_seq_contains_event (listener->listener.types, key_event) &&
       (is_system_global == listener->mode->global))
     {
       return TRUE;
@@ -1008,13 +1014,13 @@ spi_key_event_matches_listener (const Accessibility_DeviceEvent *key_event,
 }
 
 gboolean
-spi_controller_notify_keylisteners (SpiDEController                 *controller,
-				    Accessibility_DeviceEvent       *key_event,
-				    dbus_bool_t                    is_system_global)
+spi_controller_notify_keylisteners (SpiDEController *controller,
+                                    Accessibility_DeviceEvent *key_event,
+                                    dbus_bool_t is_system_global)
 {
-  GList   *l;
-  GSList  *notify = NULL, *l2;
-  GList  **key_listeners = &controller->key_listeners;
+  GList *l;
+  GSList *notify = NULL, *l2;
+  GList **key_listeners = &controller->key_listeners;
   gboolean is_consumed;
 
   if (!key_listeners)
@@ -1024,18 +1030,18 @@ spi_controller_notify_keylisteners (SpiDEController                 *controller,
 
   /* set the NUMLOCK event mask bit if appropriate: see bug #143702 */
   if (key_event->modifiers & _numlock_physical_mask)
-      key_event->modifiers |= SPI_KEYMASK_NUMLOCK;
+    key_event->modifiers |= SPI_KEYMASK_NUMLOCK;
 
   for (l = *key_listeners; l; l = l->next)
     {
-       DEControllerKeyListener *key_listener = l->data;
+      DEControllerKeyListener *key_listener = l->data;
 
-       if (spi_key_event_matches_listener (key_event, key_listener, is_system_global))
-         {
-	   /* we clone (don't dup) the listener, to avoid refcount inc. */
-	   notify = g_slist_prepend (notify,
-				     spi_key_listener_clone (key_listener));
-         }
+      if (spi_key_event_matches_listener (key_event, key_listener, is_system_global))
+        {
+          /* we clone (don't dup) the listener, to avoid refcount inc. */
+          notify = g_slist_prepend (notify,
+                                    spi_key_listener_clone (key_listener));
+        }
     }
 
 #ifdef SPI_KEYEVENT_DEBUG
@@ -1048,17 +1054,17 @@ spi_controller_notify_keylisteners (SpiDEController                 *controller,
   is_consumed = FALSE;
   for (l2 = notify; l2 && !is_consumed; l2 = l2->next)
     {
-      DEControllerKeyListener *key_listener = l2->data;	    
+      DEControllerKeyListener *key_listener = l2->data;
 
       is_consumed = Accessibility_DeviceEventListener_NotifyEvent (controller, &key_listener->listener, key_event) &&
-	            key_listener->mode->preemptive;
+                    key_listener->mode->preemptive;
 
       spi_key_listener_clone_free (key_listener);
     }
 
   for (; l2; l2 = l2->next)
     {
-      DEControllerKeyListener *key_listener = l2->data;	    
+      DEControllerKeyListener *key_listener = l2->data;
       spi_key_listener_clone_free (key_listener);
       /* clone doesn't have its own ref, so don't use spi_dec_listener_free */
     }
@@ -1066,19 +1072,20 @@ spi_controller_notify_keylisteners (SpiDEController                 *controller,
   g_slist_free (notify);
 
 #ifdef SPI_DEBUG
-  if (is_consumed) g_message ("consumed\n");
+  if (is_consumed)
+    g_message ("consumed\n");
 #endif
   return is_consumed;
 }
 
 gboolean
-spi_controller_update_key_grabs (SpiDEController           *controller,
-				 Accessibility_DeviceEvent *recv)
+spi_controller_update_key_grabs (SpiDEController *controller,
+                                 Accessibility_DeviceEvent *recv)
 {
   GList *l, *next;
-  gboolean   update_failed = FALSE;
+  gboolean update_failed = FALSE;
   long keycode = 0;
-  
+
   g_return_val_if_fail (controller != NULL, FALSE);
 
   /*
@@ -1101,16 +1108,16 @@ spi_controller_update_key_grabs (SpiDEController           *controller,
       next = l->next;
 
       re_issue_grab = recv &&
-	      (recv->modifiers & grab_mask->mod_mask) &&
-	      (grab_mask->key_val == keycode);
+                      (recv->modifiers & grab_mask->mod_mask) &&
+                      (grab_mask->key_val == keycode);
 
 #ifdef SPI_DEBUG
       fprintf (stderr, "mask=%lx %lx (%c%c) %s\n",
-	       (long int) grab_mask->key_val,
-	       (long int) grab_mask->mod_mask,
-	       grab_mask->pending_add ? '+' : '.',
-	       grab_mask->pending_remove ? '-' : '.',
-	       re_issue_grab ? "re-issue": "");
+               (long int) grab_mask->key_val,
+               (long int) grab_mask->mod_mask,
+               grab_mask->pending_add ? '+' : '.',
+               grab_mask->pending_remove ? '-' : '.',
+               re_issue_grab ? "re-issue" : "");
 #endif
 
       do_remove = FALSE;
@@ -1118,32 +1125,34 @@ spi_controller_update_key_grabs (SpiDEController           *controller,
       if (grab_mask->pending_add && grab_mask->pending_remove)
         {
           do_remove = TRUE;
-	}
+        }
       else if (grab_mask->pending_remove)
         {
 #ifdef SPI_DEBUG
-      fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask);
+          fprintf (stderr, "ungrabbing, mask=%x\n", grab_mask->mod_mask);
 #endif
-	  spi_dec_plat_ungrab_key (controller,
-		               grab_mask->key_val,
-		               grab_mask->mod_mask);
+          spi_dec_plat_ungrab_key (controller,
+                                   grab_mask->key_val,
+                                   grab_mask->mod_mask);
 
           do_remove = TRUE;
-	}
+        }
       else if (grab_mask->pending_add || re_issue_grab)
         {
 
 #ifdef SPI_DEBUG
-	  fprintf (stderr, "grab %d with mask %x\n", grab_mask->key_val, grab_mask->mod_mask);
+          fprintf (stderr, "grab %d with mask %x\n", grab_mask->key_val, grab_mask->mod_mask);
 #endif
-	  update_failed = spi_dec_plat_grab_key (controller,
-		                               grab_mask->key_val,
-		                               grab_mask->mod_mask);
-	  if (update_failed) {
-		  while (grab_mask->ref_count > 0) --grab_mask->ref_count;
-		  do_remove = TRUE;
-	  }
-	}
+          update_failed = spi_dec_plat_grab_key (controller,
+                                                 grab_mask->key_val,
+                                                 grab_mask->mod_mask);
+          if (update_failed)
+            {
+              while (grab_mask->ref_count > 0)
+                --grab_mask->ref_count;
+              do_remove = TRUE;
+            }
+        }
 
       grab_mask->pending_add = FALSE;
       grab_mask->pending_remove = FALSE;
@@ -1152,15 +1161,14 @@ spi_controller_update_key_grabs (SpiDEController           *controller,
         {
           g_assert (grab_mask->ref_count <= 0);
 
-	  controller->keygrabs_list = g_list_delete_link (
-	    controller->keygrabs_list, l);
+          controller->keygrabs_list = g_list_delete_link (
+              controller->keygrabs_list, l);
 
-	  spi_grab_mask_free (grab_mask);
-	}
-
-    } 
+          spi_grab_mask_free (grab_mask);
+        }
+    }
 
-  return ! update_failed;
+  return !update_failed;
 }
 
 /*
@@ -1170,13 +1178,13 @@ static void
 spi_device_event_controller_object_finalize (GObject *object)
 {
   SpiDEController *controller;
-  GObjectClass *parent_class = G_OBJECT_CLASS(spi_device_event_controller_parent_class);
+  GObjectClass *parent_class = G_OBJECT_CLASS (spi_device_event_controller_parent_class);
   SpiDEControllerClass *klass;
 
   controller = SPI_DEVICE_EVENT_CONTROLLER (object);
   klass = SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS (controller);
 #ifdef SPI_DEBUG
-  fprintf(stderr, "spi_device_event_controller_object_finalize called\n");
+  fprintf (stderr, "spi_device_event_controller_object_finalize called\n");
 #endif
   if (klass->plat.finalize)
     klass->plat.finalize (controller);
@@ -1197,68 +1205,69 @@ impl_register_keystroke_listener (DBusMessage *message, SpiDEController *control
   GSList *keys = NULL;
   dbus_int32_t mask, types;
   Accessibility_EventListenerMode *mode;
- dbus_bool_t ret;
+  dbus_bool_t ret;
   DBusMessage *reply = NULL;
   char *keystring;
 
   if (strcmp (dbus_message_get_signature (message), "oa(iisi)uu(bbb)") != 0)
     return invalid_arguments_error (message);
 
-  dbus_message_iter_init(message, &iter);
-  dbus_message_iter_get_basic(&iter, &path);
-  dbus_message_iter_next(&iter);
-  dbus_message_iter_recurse(&iter, &iter_array);
-  while (dbus_message_iter_get_arg_type(&iter_array) != DBUS_TYPE_INVALID)
-  {
-    Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
-    if (!spi_dbus_message_iter_get_struct(&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID))
+  dbus_message_iter_init (message, &iter);
+  dbus_message_iter_get_basic (&iter, &path);
+  dbus_message_iter_next (&iter);
+  dbus_message_iter_recurse (&iter, &iter_array);
+  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)
     {
-      g_free(kd);
-      break;
+      Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *) g_malloc (sizeof (Accessibility_KeyDefinition));
+      if (!spi_dbus_message_iter_get_struct (&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID))
+        {
+          g_free (kd);
+          break;
+        }
+      kd->keystring = g_strdup (keystring);
+      keys = g_slist_append (keys, kd);
     }
-    kd->keystring = g_strdup (keystring);
-    keys = g_slist_append(keys, kd);
-  }
-  dbus_message_iter_next(&iter);
-  dbus_message_iter_get_basic(&iter, &mask);
-  dbus_message_iter_next(&iter);
-  dbus_message_iter_get_basic(&iter, &types);
-  dbus_message_iter_next(&iter);
-  mode = (Accessibility_EventListenerMode *)g_malloc(sizeof(Accessibility_EventListenerMode));
+  dbus_message_iter_next (&iter);
+  dbus_message_iter_get_basic (&iter, &mask);
+  dbus_message_iter_next (&iter);
+  dbus_message_iter_get_basic (&iter, &types);
+  dbus_message_iter_next (&iter);
+  mode = (Accessibility_EventListenerMode *) g_malloc (sizeof (Accessibility_EventListenerMode));
   if (mode)
-  {
-    spi_dbus_message_iter_get_struct(&iter, DBUS_TYPE_BOOLEAN, &mode->synchronous, DBUS_TYPE_BOOLEAN, &mode->preemptive, DBUS_TYPE_BOOLEAN, &mode->global, DBUS_TYPE_INVALID);
-  }
+    {
+      spi_dbus_message_iter_get_struct (&iter, DBUS_TYPE_BOOLEAN, &mode->synchronous, DBUS_TYPE_BOOLEAN, &mode->preemptive, DBUS_TYPE_BOOLEAN, &mode->global, DBUS_TYPE_INVALID);
+    }
 #ifdef SPI_DEBUG
   fprintf (stderr, "registering keystroke listener %s:%s with maskVal %lu\n",
-	   dbus_message_get_sender(message), path, (unsigned long) mask);
+           dbus_message_get_sender (message), path, (unsigned long) mask);
 #endif
-  dec_listener = spi_dec_key_listener_new (dbus_message_get_sender(message), path, keys, mask, types, mode);
+  dec_listener = spi_dec_key_listener_new (dbus_message_get_sender (message), path, keys, mask, types, mode);
   g_free (mode);
   ret = spi_controller_register_device_listener (
-	  controller, (DEControllerListener *) dec_listener);
+      controller, (DEControllerListener *) dec_listener);
   reply = dbus_message_new_method_return (message);
   if (reply)
-  {
-    dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
-  }
+    {
+      dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
+    }
   return reply;
 }
 
-typedef struct {
-	DBusConnection *bus;
-	DEControllerListener    *listener;
+typedef struct
+{
+  DBusConnection *bus;
+  DEControllerListener *listener;
 } RemoveListenerClosure;
 
 static SpiReEntrantContinue
-remove_listener_cb (GList * const *list,
-		    gpointer       user_data)
+remove_listener_cb (GList *const *list,
+                    gpointer user_data)
 {
-  DEControllerListener  *listener = (*list)->data;
+  DEControllerListener *listener = (*list)->data;
   RemoveListenerClosure *ctx = user_data;
 
-  if (!strcmp(ctx->listener->bus_name, listener->bus_name) &&
-      !strcmp(ctx->listener->path, listener->path))
+  if (!strcmp (ctx->listener->bus_name, listener->bus_name) &&
+      !strcmp (ctx->listener->path, listener->path))
     {
       spi_re_entrant_list_delete_link (list);
       spi_dbus_remove_disconnect_match (ctx->bus, listener->bus_name);
@@ -1269,30 +1278,30 @@ remove_listener_cb (GList * const *list,
 }
 
 static SpiReEntrantContinue
-copy_key_listener_cb (GList * const *list,
-		      gpointer       user_data)
+copy_key_listener_cb (GList *const *list,
+                      gpointer user_data)
 {
-  DEControllerKeyListener  *key_listener = (*list)->data;
-  RemoveListenerClosure    *ctx = user_data;
+  DEControllerKeyListener *key_listener = (*list)->data;
+  RemoveListenerClosure *ctx = user_data;
 
-  if (!strcmp(ctx->listener->bus_name, key_listener->listener.bus_name) &&
-      !strcmp(ctx->listener->path, key_listener->listener.path))
+  if (!strcmp (ctx->listener->bus_name, key_listener->listener.bus_name) &&
+      !strcmp (ctx->listener->path, key_listener->listener.path))
     {
       /* TODO: FIXME aggregate keys in case the listener is registered twice */
-      DEControllerKeyListener *ctx_key_listener = 
-	(DEControllerKeyListener *) ctx->listener; 
-      keylist_free (ctx_key_listener->keys);	    
-      ctx_key_listener->keys = keylist_clone(key_listener->keys);
+      DEControllerKeyListener *ctx_key_listener =
+          (DEControllerKeyListener *) ctx->listener;
+      keylist_free (ctx_key_listener->keys);
+      ctx_key_listener->keys = keylist_clone (key_listener->keys);
     }
 
   return SPI_RE_ENTRANT_CONTINUE;
 }
 
 static void
-spi_deregister_controller_key_listener (SpiDEController            *controller,
-					DEControllerKeyListener    *key_listener)
+spi_deregister_controller_key_listener (SpiDEController *controller,
+                                        DEControllerKeyListener *key_listener)
 {
-  RemoveListenerClosure  ctx;
+  RemoveListenerClosure ctx;
 
   ctx.bus = controller->bus;
   ctx.listener = (DEControllerListener *) spi_key_listener_clone (key_listener);
@@ -1300,16 +1309,16 @@ spi_deregister_controller_key_listener (SpiDEController            *controller,
   notify_keystroke_listener (controller, key_listener, FALSE);
 
   /* special case, copy keyset from existing controller list entry */
-  if (g_slist_length(key_listener->keys) == 0)
+  if (g_slist_length (key_listener->keys) == 0)
     {
       spi_re_entrant_list_foreach (&controller->key_listeners,
-				  copy_key_listener_cb, &ctx);
+                                   copy_key_listener_cb, &ctx);
     }
 
   spi_controller_deregister_global_keygrabs (controller, key_listener);
 
   spi_re_entrant_list_foreach (&controller->key_listeners,
-				remove_listener_cb, &ctx);
+                               remove_listener_cb, &ctx);
 
   spi_key_listener_clone_free ((DEControllerKeyListener *) ctx.listener);
 }
@@ -1320,16 +1329,16 @@ spi_remove_device_listeners (SpiDEController *controller, const char *bus_name)
   GList *l, *tmp;
 
   for (l = controller->key_listeners; l; l = tmp)
-  {
-    DEControllerKeyListener *key_listener = l->data;
-    tmp = l->next;
-    if (!strcmp (key_listener->listener.bus_name, bus_name))
     {
-      /* TODO: untangle the below line(s) */
-      spi_deregister_controller_key_listener (controller, key_listener);
-      tmp = controller->key_listeners;
+      DEControllerKeyListener *key_listener = l->data;
+      tmp = l->next;
+      if (!strcmp (key_listener->listener.bus_name, bus_name))
+        {
+          /* TODO: untangle the below line(s) */
+          spi_deregister_controller_key_listener (controller, key_listener);
+          tmp = controller->key_listeners;
+        }
     }
-  }
 }
 
 /*
@@ -1346,38 +1355,38 @@ impl_deregister_keystroke_listener (DBusMessage *message, SpiDEController *contr
   dbus_int32_t mask, type;
   DBusMessage *reply = NULL;
 
-  dbus_message_iter_init(message, &iter);
+  dbus_message_iter_init (message, &iter);
   if (strcmp (dbus_message_get_signature (message), "oa(iisi)uu") != 0)
-  {
-    g_warning ("Received DeregisterKeystrokeListener with strange signature '%s'", dbus_message_get_signature (message));
-    return invalid_arguments_error (message);
-  }
-
-  dbus_message_iter_get_basic(&iter, &path);
-  dbus_message_iter_next(&iter);
-  dbus_message_iter_recurse(&iter, &iter_array);
-  while (dbus_message_iter_get_arg_type(&iter_array) != DBUS_TYPE_INVALID)
-  {
-    Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *)g_malloc(sizeof(Accessibility_KeyDefinition));
-  char *keystring;
+    {
+      g_warning ("Received DeregisterKeystrokeListener with strange signature '%s'", dbus_message_get_signature (message));
+      return invalid_arguments_error (message);
+    }
 
-    if (!spi_dbus_message_iter_get_struct(&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID))
+  dbus_message_iter_get_basic (&iter, &path);
+  dbus_message_iter_next (&iter);
+  dbus_message_iter_recurse (&iter, &iter_array);
+  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)
     {
-      g_free(kd);
-      break;
+      Accessibility_KeyDefinition *kd = (Accessibility_KeyDefinition *) g_malloc (sizeof (Accessibility_KeyDefinition));
+      char *keystring;
+
+      if (!spi_dbus_message_iter_get_struct (&iter_array, DBUS_TYPE_INT32, &kd->keycode, DBUS_TYPE_INT32, &kd->keysym, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_INVALID))
+        {
+          g_free (kd);
+          break;
+        }
+      kd->keystring = g_strdup (keystring);
+      keys = g_slist_append (keys, kd);
     }
-    kd->keystring = g_strdup (keystring);
-    keys = g_slist_append(keys, kd);
-  }
-  dbus_message_iter_next(&iter);
-  dbus_message_iter_get_basic(&iter, &mask);
-  dbus_message_iter_next(&iter);
-  dbus_message_iter_get_basic(&iter, &type);
-  dbus_message_iter_next(&iter);
-  key_listener = spi_dec_key_listener_new (dbus_message_get_sender(message), path, keys, mask, type, NULL);
+  dbus_message_iter_next (&iter);
+  dbus_message_iter_get_basic (&iter, &mask);
+  dbus_message_iter_next (&iter);
+  dbus_message_iter_get_basic (&iter, &type);
+  dbus_message_iter_next (&iter);
+  key_listener = spi_dec_key_listener_new (dbus_message_get_sender (message), path, keys, mask, type, NULL);
 #ifdef SPI_DEREGISTER_DEBUG
   fprintf (stderr, "deregistering keystroke listener %p with maskVal %lu\n",
-	   (void *) l, (unsigned long) mask->value);
+           (void *) l, (unsigned long) mask->value);
 #endif
 
   spi_deregister_controller_key_listener (controller, key_listener);
@@ -1401,9 +1410,9 @@ impl_get_keystroke_listeners (DBusMessage *message, SpiDEController *controller)
   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
                                     "(souua(iisi)u(bbb))", &iter_array);
   for (l = controller->key_listeners; l; l = l->next)
-  {
-    append_keystroke_listener (&iter_array, l->data);
-  }
+    {
+      append_keystroke_listener (&iter_array, l->data);
+    }
   dbus_message_iter_close_container (&iter, &iter_array);
   return reply;
 }
@@ -1411,44 +1420,45 @@ impl_get_keystroke_listeners (DBusMessage *message, SpiDEController *controller)
 static unsigned
 get_modifier_state (SpiDEController *controller)
 {
-	spi_dec_poll_mouse_moved (controller);
-	return controller->mouse_mask_state;
+  spi_dec_poll_mouse_moved (controller);
+  return controller->mouse_mask_state;
 }
 
 gboolean
 spi_dec_synth_keysym (SpiDEController *controller, long keysym)
 {
-	long key_synth_code;
-	unsigned int modifiers, synth_mods, lock_mods;
+  long key_synth_code;
+  unsigned int modifiers, synth_mods, lock_mods;
 
-	key_synth_code = spi_dec_plat_get_keycode (controller, keysym, NULL, TRUE, &synth_mods);
+  key_synth_code = spi_dec_plat_get_keycode (controller, keysym, NULL, TRUE, &synth_mods);
 
-	if ((key_synth_code == 0) || (synth_mods == 0xFF)) return FALSE;
+  if ((key_synth_code == 0) || (synth_mods == 0xFF))
+    return FALSE;
 
-	/* TODO: set the modifiers accordingly! */
-	modifiers = get_modifier_state (controller);
-	/* side-effect; we may unset mousebutton modifiers here! */
+  /* TODO: set the modifiers accordingly! */
+  modifiers = get_modifier_state (controller);
+  /* side-effect; we may unset mousebutton modifiers here! */
 
-	lock_mods = 0;
-	if (synth_mods != modifiers) {
-		lock_mods = synth_mods & ~modifiers;
-		spi_dec_plat_lock_modifiers (controller, lock_mods);
-		if (modifiers & SPI_KEYMASK_SHIFTLOCK)
-			spi_dec_plat_unlock_modifiers (controller, SPI_KEYMASK_SHIFTLOCK);
-	}
-	spi_dec_plat_synth_keycode_press (controller, key_synth_code);
-	spi_dec_plat_synth_keycode_release (controller, key_synth_code);
+  lock_mods = 0;
+  if (synth_mods != modifiers)
+    {
+      lock_mods = synth_mods & ~modifiers;
+      spi_dec_plat_lock_modifiers (controller, lock_mods);
+      if (modifiers & SPI_KEYMASK_SHIFTLOCK)
+        spi_dec_plat_unlock_modifiers (controller, SPI_KEYMASK_SHIFTLOCK);
+    }
+  spi_dec_plat_synth_keycode_press (controller, key_synth_code);
+  spi_dec_plat_synth_keycode_release (controller, key_synth_code);
 
-	if (synth_mods != modifiers) {
-		spi_dec_plat_unlock_modifiers (controller, lock_mods);
-		if (modifiers & SPI_KEYMASK_SHIFTLOCK)
-			spi_dec_plat_lock_modifiers (controller, SPI_KEYMASK_SHIFTLOCK);
-	}
-	return TRUE;
+  if (synth_mods != modifiers)
+    {
+      spi_dec_plat_unlock_modifiers (controller, lock_mods);
+      if (modifiers & SPI_KEYMASK_SHIFTLOCK)
+        spi_dec_plat_lock_modifiers (controller, SPI_KEYMASK_SHIFTLOCK);
+    }
+  return TRUE;
 }
 
-
-
 /*
  * DBus Accessibility::DEController::RegisterKeystrokeListener
  *     method implementation
@@ -1461,14 +1471,14 @@ impl_generate_keyboard_event (DBusMessage *message, SpiDEController *controller)
   dbus_uint32_t synth_type;
   DBusMessage *reply = NULL;
 
-  if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &keycode, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_UINT32, &synth_type, DBUS_TYPE_INVALID))
-  {
-    return invalid_arguments_error (message);
-  }
+  if (!dbus_message_get_args (message, NULL, DBUS_TYPE_INT32, &keycode, DBUS_TYPE_STRING, &keystring, DBUS_TYPE_UINT32, &synth_type, DBUS_TYPE_INVALID))
+    {
+      return invalid_arguments_error (message);
+    }
 
 #ifdef SPI_DEBUG
-	fprintf (stderr, "synthesizing keystroke %ld, type %d\n",
-		 (long) keycode, (int) synth_type);
+  fprintf (stderr, "synthesizing keystroke %ld, type %d\n",
+           (long) keycode, (int) synth_type);
 #endif
   /* TODO: hide/wrap/remove X dependency */
 
@@ -1476,39 +1486,39 @@ impl_generate_keyboard_event (DBusMessage *message, SpiDEController *controller)
    * TODO: when initializing, query for XTest extension before using,
    * and fall back to XSendEvent() if XTest is not available.
    */
-  
+
   switch (synth_type)
     {
-      case Accessibility_KEY_PRESS:
-	      spi_dec_plat_synth_keycode_press (controller, keycode);
-	      break;
-      case Accessibility_KEY_PRESSRELEASE:
-	      spi_dec_plat_synth_keycode_press (controller, keycode);
-      case Accessibility_KEY_RELEASE:
-	      spi_dec_plat_synth_keycode_release (controller, keycode);
-	      break;
-      case Accessibility_KEY_SYM:
-#ifdef SPI_XKB_DEBUG	      
-	      fprintf (stderr, "KeySym synthesis\n");
+    case Accessibility_KEY_PRESS:
+      spi_dec_plat_synth_keycode_press (controller, keycode);
+      break;
+    case Accessibility_KEY_PRESSRELEASE:
+      spi_dec_plat_synth_keycode_press (controller, keycode);
+    case Accessibility_KEY_RELEASE:
+      spi_dec_plat_synth_keycode_release (controller, keycode);
+      break;
+    case Accessibility_KEY_SYM:
+#ifdef SPI_XKB_DEBUG
+      fprintf (stderr, "KeySym synthesis\n");
 #endif
-	      /* 
-	       * note: we are using long for 'keycode'
-	       * in our arg list; it can contain either
-	       * a keycode or a keysym.
-	       */
-	      spi_dec_synth_keysym (controller, keycode);
-	      break;
-      case Accessibility_KEY_STRING:
-	      if (!spi_dec_plat_synth_keystring (controller, synth_type, keycode, keystring))
-		      fprintf (stderr, "Keystring synthesis failure, string=%s\n",
-			       keystring);
-	      break;
-      case Accessibility_KEY_LOCKMODIFIERS:
-	      spi_dec_plat_lock_modifiers (controller, keycode);
-	      break;
-      case Accessibility_KEY_UNLOCKMODIFIERS:
-	      spi_dec_plat_unlock_modifiers (controller, keycode);
-	      break;
+      /*
+       * note: we are using long for 'keycode'
+       * in our arg list; it can contain either
+       * a keycode or a keysym.
+       */
+      spi_dec_synth_keysym (controller, keycode);
+      break;
+    case Accessibility_KEY_STRING:
+      if (!spi_dec_plat_synth_keystring (controller, synth_type, keycode, keystring))
+        fprintf (stderr, "Keystring synthesis failure, string=%s\n",
+                 keystring);
+      break;
+    case Accessibility_KEY_LOCKMODIFIERS:
+      spi_dec_plat_lock_modifiers (controller, keycode);
+      break;
+    case Accessibility_KEY_UNLOCKMODIFIERS:
+      spi_dec_plat_unlock_modifiers (controller, keycode);
+      break;
     }
   reply = dbus_message_new_method_return (message);
   return reply;
@@ -1518,19 +1528,19 @@ impl_generate_keyboard_event (DBusMessage *message, SpiDEController *controller)
 static DBusMessage *
 impl_generate_mouse_event (DBusMessage *message, SpiDEController *controller)
 {
-  dbus_int32_t       x;
-  dbus_int32_t       y;
+  dbus_int32_t x;
+  dbus_int32_t y;
   char *eventName;
   DBusMessage *reply = NULL;
 
-  if (!dbus_message_get_args(message, NULL, DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32, &y, DBUS_TYPE_STRING, &eventName, DBUS_TYPE_INVALID))
-  {
-    return invalid_arguments_error (message);
-  }
+  if (!dbus_message_get_args (message, NULL, DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32, &y, DBUS_TYPE_STRING, &eventName, DBUS_TYPE_INVALID))
+    {
+      return invalid_arguments_error (message);
+    }
 
 #ifdef SPI_DEBUG
   fprintf (stderr, "generating mouse %s event at %ld, %ld\n",
-	   eventName, (long int) x, (long int) y);
+           eventName, (long int) x, (long int) y);
 #endif
   spi_dec_plat_generate_mouse_event (controller, x, y, eventName);
   reply = dbus_message_new_method_return (message);
@@ -1545,23 +1555,23 @@ impl_notify_listeners_sync (DBusMessage *message, SpiDEController *controller)
   dbus_bool_t ret;
   DBusMessage *reply = NULL;
 
-  if (!spi_dbus_demarshal_deviceEvent(message, &event))
-  {
-    return invalid_arguments_error (message);
-  }
+  if (!spi_dbus_demarshal_deviceEvent (message, &event))
+    {
+      return invalid_arguments_error (message);
+    }
 #ifdef SPI_DEBUG
   g_print ("notifylistening listeners synchronously: controller %p, event id %d\n",
-	   controller, (int) event.id);
+           controller, (int) event.id);
 #endif
   ret = spi_controller_notify_keylisteners (controller,
-					     (Accessibility_DeviceEvent *) 
-					     &event, FALSE) ?
-	  TRUE : FALSE; 
+                                            (Accessibility_DeviceEvent *) &event, FALSE)
+            ? TRUE
+            : FALSE;
   reply = dbus_message_new_method_return (message);
   if (reply)
-  {
-    dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
-  }
+    {
+      dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &ret, DBUS_TYPE_INVALID);
+    }
   return reply;
 }
 
@@ -1571,16 +1581,15 @@ impl_notify_listeners_async (DBusMessage *message, SpiDEController *controller)
   Accessibility_DeviceEvent event;
   DBusMessage *reply = NULL;
 
-  if (!spi_dbus_demarshal_deviceEvent(message, &event))
-  {
-    return invalid_arguments_error (message);
-  }
+  if (!spi_dbus_demarshal_deviceEvent (message, &event))
+    {
+      return invalid_arguments_error (message);
+    }
 #ifdef SPI_DEBUG
   g_print ("notifylistening listeners asynchronously: controller %p, event id %d\n",
-	   controller, (int) event.id);
+           controller, (int) event.id);
 #endif
-  spi_controller_notify_keylisteners (controller, (Accessibility_DeviceEvent *)
-				      &event, FALSE); 
+  spi_controller_notify_keylisteners (controller, (Accessibility_DeviceEvent *) &event, FALSE);
   reply = dbus_message_new_method_return (message);
   return reply;
 }
@@ -1588,7 +1597,7 @@ impl_notify_listeners_async (DBusMessage *message, SpiDEController *controller)
 static void
 spi_device_event_controller_class_init (SpiDEControllerClass *klass)
 {
-  GObjectClass * object_class = (GObjectClass *) klass;
+  GObjectClass *object_class = (GObjectClass *) klass;
 
   spi_device_event_controller_parent_class = g_type_class_peek_parent (klass);
 
@@ -1612,20 +1621,19 @@ spi_device_event_controller_init (SpiDEController *device_event_controller)
     klass->plat.init (device_event_controller);
 }
 
-
 /*---------------------------------------------------------------------------*/
 
 static const char *introspection_header =
-"<?xml version=\"1.0\"?>\n";
+    "<?xml version=\"1.0\"?>\n";
 
 static const char *introspection_node_element =
-"<node name=\"%s\">\n";
+    "<node name=\"%s\">\n";
 
 static const char *introspection_footer =
-"</node>";
+    "</node>";
 
 static DBusMessage *
-impl_Introspect (DBusMessage * message, SpiDEController *controller)
+impl_Introspect (DBusMessage *message, SpiDEController *controller)
 {
   GString *output;
   gchar *final;
@@ -1634,19 +1642,19 @@ impl_Introspect (DBusMessage * message, SpiDEController *controller)
 
   DBusMessage *reply;
 
-  output = g_string_new(introspection_header);
+  output = g_string_new (introspection_header);
 
-  g_string_append_printf(output, introspection_node_element, pathstr);
+  g_string_append_printf (output, introspection_node_element, pathstr);
 
   g_string_append (output, spi_org_a11y_atspi_DeviceEventController);
 
-  g_string_append(output, introspection_footer);
-  final = g_string_free(output, FALSE);
+  g_string_append (output, introspection_footer);
+  final = g_string_free (output, FALSE);
 
   reply = dbus_message_new_method_return (message);
-  dbus_message_append_args(reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);
+  dbus_message_append_args (reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);
 
-  g_free(final);
+  g_free (final);
   return reply;
 }
 
@@ -1655,39 +1663,39 @@ impl_Introspect (DBusMessage * message, SpiDEController *controller)
 static void
 handle_message (DBusMessage *message, SpiDEController *controller)
 {
-  const gchar *iface   = dbus_message_get_interface (message);
-  const gchar *member  = dbus_message_get_member (message);
+  const gchar *iface = dbus_message_get_interface (message);
+  const gchar *member = dbus_message_get_member (message);
   DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   DBusMessage *reply = NULL;
 
   if (!strcmp (iface, SPI_DBUS_INTERFACE_DEC))
     {
       result = DBUS_HANDLER_RESULT_HANDLED;
-      if      (!strcmp (member, "RegisterKeystrokeListener"))
-          reply = impl_register_keystroke_listener (message, controller);
+      if (!strcmp (member, "RegisterKeystrokeListener"))
+        reply = impl_register_keystroke_listener (message, controller);
       else if (!strcmp (member, "DeregisterKeystrokeListener"))
-          reply = impl_deregister_keystroke_listener (message, controller);
+        reply = impl_deregister_keystroke_listener (message, controller);
       else if (!strcmp (member, "GetKeystrokeListeners"))
-          reply = impl_get_keystroke_listeners (message, controller);
+        reply = impl_get_keystroke_listeners (message, controller);
       else if (!strcmp (member, "GenerateKeyboardEvent"))
-          reply = impl_generate_keyboard_event (message, controller);
+        reply = impl_generate_keyboard_event (message, controller);
       else if (!strcmp (member, "GenerateMouseEvent"))
-          reply = impl_generate_mouse_event (message, controller);
+        reply = impl_generate_mouse_event (message, controller);
       else if (!strcmp (member, "NotifyListenersSync"))
-          reply = impl_notify_listeners_sync (message, controller);
+        reply = impl_notify_listeners_sync (message, controller);
       else if (!strcmp (member, "NotifyListenersAsync"))
-          reply = impl_notify_listeners_async (message, controller);
+        reply = impl_notify_listeners_async (message, controller);
       else
-          result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     }
 
   if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))
     {
       result = DBUS_HANDLER_RESULT_HANDLED;
-      if      (!strcmp (member, "Introspect"))
-          reply = impl_Introspect (message, controller);
+      if (!strcmp (member, "Introspect"))
+        reply = impl_Introspect (message, controller);
       else
-          result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     }
 
   if (result == DBUS_HANDLER_RESULT_HANDLED)
@@ -1721,27 +1729,27 @@ static DBusHandlerResult
 handle_dec_method (DBusConnection *bus, DBusMessage *message, void *user_data)
 {
   SpiDEController *controller = SPI_DEVICE_EVENT_CONTROLLER (user_data);
-  const gchar *iface   = dbus_message_get_interface (message);
-  const gchar *member  = dbus_message_get_member (message);
-  const gint   type    = dbus_message_get_type (message);
+  const gchar *iface = dbus_message_get_interface (message);
+  const gchar *member = dbus_message_get_member (message);
+  const gint type = dbus_message_get_type (message);
 
   /* Check for basic reasons not to handle */
-  if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
+  if (type != DBUS_MESSAGE_TYPE_METHOD_CALL ||
       member == NULL ||
-      iface  == NULL)
-      return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+      iface == NULL)
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
   dbus_message_ref (message);
   g_queue_push_tail (controller->message_queue, message);
-  if (!controller->message_queue_idle) {
-    controller->message_queue_idle = g_idle_add (message_queue_dispatch, controller);
-    g_source_set_name_by_id (controller->message_queue_idle, "[at-spi2-core] message_queue_dispatch");
-  }
+  if (!controller->message_queue_idle)
+    {
+      controller->message_queue_idle = g_idle_add (message_queue_dispatch, controller);
+      g_source_set_name_by_id (controller->message_queue_idle, "[at-spi2-core] message_queue_dispatch");
+    }
   return DBUS_HANDLER_RESULT_HANDLED;
 }
 
-static DBusObjectPathVTable dec_vtable =
-{
+static DBusObjectPathVTable dec_vtable = {
   NULL,
   &handle_dec_method,
   NULL, NULL, NULL, NULL
diff --git a/registryd/deviceeventcontroller.h b/registryd/deviceeventcontroller.h
index a080a13e..a78148ce 100644
--- a/registryd/deviceeventcontroller.h
+++ b/registryd/deviceeventcontroller.h
@@ -28,19 +28,20 @@
 
 typedef struct _SpiDEController SpiDEController;
 
-#include "registry.h"
 #include "de-types.h"
+#include "registry.h"
 
 G_BEGIN_DECLS
 
-#define SPI_DEVICE_EVENT_CONTROLLER_TYPE        (spi_device_event_controller_get_type ())
-#define SPI_DEVICE_EVENT_CONTROLLER(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_DEVICE_EVENT_CONTROLLER_TYPE, SpiDEController))
-#define SPI_DEVICE_EVENT_CONTROLLER_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), SPI_DEVICE_EVENT_CONTROLLER_TYPE, SpiDEControllerClass))
-#define SPI_IS_DEVICE_EVENT_CONTROLLER(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), SPI_DEVICE_EVENT_CONTROLLER_TYPE))
+#define SPI_DEVICE_EVENT_CONTROLLER_TYPE (spi_device_event_controller_get_type ())
+#define SPI_DEVICE_EVENT_CONTROLLER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_DEVICE_EVENT_CONTROLLER_TYPE, SpiDEController))
+#define SPI_DEVICE_EVENT_CONTROLLER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SPI_DEVICE_EVENT_CONTROLLER_TYPE, SpiDEControllerClass))
+#define SPI_IS_DEVICE_EVENT_CONTROLLER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SPI_DEVICE_EVENT_CONTROLLER_TYPE))
 #define SPI_IS_DEVICE_EVENT_CONTROLLER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SPI_DEVICE_EVENT_CONTROLLER_TYPE))
 #define SPI_DEVICE_EVENT_CONTROLLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SPI_DEVICE_EVENT_CONTROLLER_TYPE, SpiDEControllerClass))
 
-struct _SpiDEController {
+struct _SpiDEController
+{
   GObject parent;
   DBusConnection *bus;
   GList *key_listeners;
@@ -53,24 +54,27 @@ struct _SpiDEController {
   gboolean have_mouse_event_listener;
 };
 
-typedef enum {
+typedef enum
+{
   SPI_DEVICE_TYPE_KBD,
   SPI_DEVICE_TYPE_LAST_DEFINED
 } SpiDeviceTypeCategory;
 
-typedef struct {
+typedef struct
+{
   char *bus_name;
   char *path;
   SpiDeviceTypeCategory type;
   gulong types;
 } DEControllerListener;
 
-typedef struct {
+typedef struct
+{
   DEControllerListener listener;
 
   GSList *keys;
   Accessibility_ControllerEventMask mask;
-  Accessibility_EventListenerMode  *mode;	
+  Accessibility_EventListenerMode *mode;
 } DEControllerKeyListener;
 
 typedef struct
@@ -81,22 +85,22 @@ typedef struct
                        gboolean fix,
                        guint *modmask);
 
-  guint (*mouse_check) (SpiDEController *controller, 
-	                gint *x,
-	                gint *y,
-	                gboolean *moved);
+  guint (*mouse_check) (SpiDEController *controller,
+                        gint *x,
+                        gint *y,
+                        gboolean *moved);
 
-  gboolean (*register_global_keygrabs) (SpiDEController         *controller,
-					DEControllerKeyListener *key_listener);
+  gboolean (*register_global_keygrabs) (SpiDEController *controller,
+                                        DEControllerKeyListener *key_listener);
 
-  void (*deregister_global_keygrabs) (SpiDEController         *controller,
-				      DEControllerKeyListener *key_listener);
+  void (*deregister_global_keygrabs) (SpiDEController *controller,
+                                      DEControllerKeyListener *key_listener);
 
   gboolean (*synth_keycode_press) (SpiDEController *controller,
-		                   guint keycode);
+                                   guint keycode);
 
   gboolean (*synth_keycode_release) (SpiDEController *controller,
-		                   guint keycode);
+                                     guint keycode);
 
   gboolean (*lock_modifiers) (SpiDEController *controller,
                               unsigned modifiers);
@@ -118,8 +122,8 @@ typedef struct
                       Accessibility_ControllerEventMask mod_mask);
 
   void (*emit_modifier_event) (SpiDEController *controller,
-			       guint prev_mask,
-			       guint current_mask);
+                               guint prev_mask,
+                               guint current_mask);
 
   void (*generate_mouse_event) (SpiDEController *controller,
                                 gint x,
@@ -130,12 +134,13 @@ typedef struct
   void (*finalize) (SpiDEController *controller);
 } SpiDEControllerPlat;
 
-typedef struct {
+typedef struct
+{
   GObjectClass parent_class;
   SpiDEControllerPlat plat;
 } SpiDEControllerClass;
 
-GType            spi_device_event_controller_get_type (void);
+GType spi_device_event_controller_get_type (void);
 
 void spi_device_event_controller_start_poll_mouse (SpiDEController *dec);
 void spi_device_event_controller_stop_poll_mouse (SpiDEController *dec);
@@ -145,16 +150,16 @@ void spi_remove_device_listeners (SpiDEController *controller, const char *bus_n
 SpiDEController *spi_registry_dec_new (DBusConnection *bus);
 
 gboolean
-spi_controller_notify_keylisteners (SpiDEController                 *controller,
-				    Accessibility_DeviceEvent       *key_event,
-				    dbus_bool_t                    is_system_global);
+spi_controller_notify_keylisteners (SpiDEController *controller,
+                                    Accessibility_DeviceEvent *key_event,
+                                    dbus_bool_t is_system_global);
 
-gboolean spi_controller_update_key_grabs               (SpiDEController           *controller,
-							       Accessibility_DeviceEvent *recv);
+gboolean spi_controller_update_key_grabs (SpiDEController *controller,
+                                          Accessibility_DeviceEvent *recv);
 
 gboolean spi_dec_synth_keysym (SpiDEController *controller, long keysym);
 
-void spi_dec_dbus_emit(SpiDEController *controller, const char *interface, const char *name, const char *minor, int a1, int a2);
+void spi_dec_dbus_emit (SpiDEController *controller, const char *interface, const char *name, const char *minor, int a1, int a2);
 
 G_END_DECLS
 
diff --git a/registryd/display.c b/registryd/display.c
index 011f2941..16e1c5da 100644
--- a/registryd/display.c
+++ b/registryd/display.c
@@ -22,10 +22,10 @@
 
 #include <glib.h>
 
+#include <X11/Xatom.h>
 #include <X11/Xlib.h>
-#include <X11/Xutil.h>
 #include <X11/Xos.h>
-#include <X11/Xatom.h>
+#include <X11/Xutil.h>
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -34,57 +34,63 @@
 
 static Display *default_display = NULL;
 
-Display *spi_set_display (const char *display_name)
+Display *
+spi_set_display (const char *display_name)
 {
-        /* 
-	 * TODO - Should we ever do anything different might need to
-         * close previous display.
-         */
-        default_display = XOpenDisplay (display_name);  
-        if (!default_display)
-        {
-                g_warning ("AT-SPI: Cannot open default display");
-                exit (1);
-        }
- return default_display;
+  /*
+   * TODO - Should we ever do anything different might need to
+   * close previous display.
+   */
+  default_display = XOpenDisplay (display_name);
+  if (!default_display)
+    {
+      g_warning ("AT-SPI: Cannot open default display");
+      exit (1);
+    }
+  return default_display;
 }
 
-Display *spi_get_display ()
+Display *
+spi_get_display ()
 {
-	if (!default_display)
-		spi_set_display (NULL);
+  if (!default_display)
+    spi_set_display (NULL);
 
-	return default_display;
+  return default_display;
 }
 
-Window spi_get_root_window ()
+Window
+spi_get_root_window ()
 {
-	if (!default_display)
-		spi_set_display (NULL);
+  if (!default_display)
+    spi_set_display (NULL);
 
-        return DefaultRootWindow (default_display);
+  return DefaultRootWindow (default_display);
 }
 
 static int (*old_x_error_handler) (Display *, XErrorEvent *);
 static int x_error_code;
 
-static int spi_x_error_handler (Display *display, XErrorEvent *error)
+static int
+spi_x_error_handler (Display *display, XErrorEvent *error)
 {
-	if (error->error_code)
-		x_error_code = error->error_code;
-	else
-		x_error_code = 0;
-  
-  	return 0;
+  if (error->error_code)
+    x_error_code = error->error_code;
+  else
+    x_error_code = 0;
+
+  return 0;
 }
 
-void spi_x_error_trap (void)
+void
+spi_x_error_trap (void)
 {
-	old_x_error_handler = XSetErrorHandler (spi_x_error_handler);
+  old_x_error_handler = XSetErrorHandler (spi_x_error_handler);
 }
 
-int spi_x_error_release (void)
+int
+spi_x_error_release (void)
 {
-	XSetErrorHandler (old_x_error_handler);
-	return x_error_code;
+  XSetErrorHandler (old_x_error_handler);
+  return x_error_code;
 }
diff --git a/registryd/event-source.c b/registryd/event-source.c
index ca4340c5..d73c9b67 100644
--- a/registryd/event-source.c
+++ b/registryd/event-source.c
@@ -24,36 +24,37 @@
 
 #include "event-source.h"
 
-typedef struct {
+typedef struct
+{
   GSource source;
-  
+
   Display *display;
-  GPollFD  event_poll_fd;
+  GPollFD event_poll_fd;
 } DisplaySource;
 
 /*---------------------------------------------------------------------------*/
 
-static void (*_spi_default_filter) (XEvent*, void*) = NULL;
-static void* _spi_default_filter_data = NULL;
+static void (*_spi_default_filter) (XEvent *, void *) = NULL;
+static void *_spi_default_filter_data = NULL;
 
 /*---------------------------------------------------------------------------*/
 
-static gboolean  
+static gboolean
 event_prepare (GSource *source, gint *timeout)
 {
-  Display *display = ((DisplaySource *)source)->display;
+  Display *display = ((DisplaySource *) source)->display;
   gboolean retval;
-  
+
   *timeout = -1;
   retval = XPending (display);
-  
+
   return retval;
 }
 
-static gboolean  
-event_check (GSource *source) 
+static gboolean
+event_check (GSource *source)
 {
-  DisplaySource *display_source = (DisplaySource*)source;
+  DisplaySource *display_source = (DisplaySource *) source;
   gboolean retval;
 
   if (display_source->event_poll_fd.revents & G_IO_IN)
@@ -64,12 +65,12 @@ event_check (GSource *source)
   return retval;
 }
 
-static gboolean  
-event_dispatch (GSource *source, GSourceFunc callback, gpointer  user_data)
+static gboolean
+event_dispatch (GSource *source, GSourceFunc callback, gpointer user_data)
 {
-  Display *display = ((DisplaySource*)source)->display;
+  Display *display = ((DisplaySource *) source)->display;
   XEvent xevent;
- 
+
   /* TODO - Should this be "if (XPending (display))"?
    *        The effect of this might be to run other main loop functions
    *        before dispatching the next XEvent.
@@ -79,19 +80,19 @@ event_dispatch (GSource *source, GSourceFunc callback, gpointer  user_data)
       XNextEvent (display, &xevent);
 
       switch (xevent.type)
-	{
-	case KeyPress:
-	case KeyRelease:
-	  break;
-	default:
-	  if (XFilterEvent (&xevent, None))
-	    continue;
-	}
-      
+        {
+        case KeyPress:
+        case KeyRelease:
+          break;
+        default:
+          if (XFilterEvent (&xevent, None))
+            continue;
+        }
+
       if (_spi_default_filter)
         {
           _spi_default_filter (&xevent, _spi_default_filter_data);
-        }  
+        }
     }
 
   return TRUE;
@@ -112,9 +113,9 @@ display_source_new (Display *display)
   GSource *source = g_source_new (&event_funcs, sizeof (DisplaySource));
   DisplaySource *display_source = (DisplaySource *) source;
   g_source_set_name (source, "[at-spi2-core] display_source_funcs");
-  
+
   display_source->display = display;
-  
+
   return source;
 }
 
@@ -122,7 +123,7 @@ display_source_new (Display *display)
 
 static DisplaySource *spi_display_source = NULL;
 
-void 
+void
 spi_events_init (Display *display)
 {
   GSource *source;
@@ -130,13 +131,13 @@ spi_events_init (Display *display)
   int connection_number = ConnectionNumber (display);
 
   source = display_source_new (display);
-  spi_display_source = (DisplaySource*) source;
+  spi_display_source = (DisplaySource *) source;
 
   g_source_set_priority (source, G_PRIORITY_DEFAULT);
-  
+
   spi_display_source->event_poll_fd.fd = connection_number;
   spi_display_source->event_poll_fd.events = G_IO_IN;
-  
+
   g_source_add_poll (source, &spi_display_source->event_poll_fd);
   g_source_set_can_recurse (source, TRUE);
   g_source_attach (source, NULL);
@@ -158,14 +159,14 @@ spi_set_events (long event_mask)
 {
   long xevent_mask = StructureNotifyMask | PropertyChangeMask;
   xevent_mask |= event_mask;
-      
-  XSelectInput (spi_display_source->display, 
+
+  XSelectInput (spi_display_source->display,
                 DefaultRootWindow (spi_display_source->display),
                 xevent_mask);
 }
 
 void
-spi_set_filter (void (*filter) (XEvent*, void*), void* data)
+spi_set_filter (void (*filter) (XEvent *, void *), void *data)
 {
   _spi_default_filter = filter;
   _spi_default_filter_data = data;
diff --git a/registryd/event-source.h b/registryd/event-source.h
index ad080f7d..1ddd34b7 100644
--- a/registryd/event-source.h
+++ b/registryd/event-source.h
@@ -28,6 +28,6 @@
 void spi_events_init (Display *display);
 void spi_events_uninit ();
 void spi_set_events (long event_mask);
-void spi_set_filter (void (*filter) (XEvent*, void*), void* data);
+void spi_set_filter (void (*filter) (XEvent *, void *), void *data);
 
 #endif /* SPI_EVENT_SOURCE_H_ */
diff --git a/registryd/keymasks.h b/registryd/keymasks.h
index 9f6c2c9f..1ee64b3d 100644
--- a/registryd/keymasks.h
+++ b/registryd/keymasks.h
@@ -31,21 +31,21 @@ G_BEGIN_DECLS
 typedef unsigned long SpiKeyMaskType;
 
 /* Values taken from Xlib.h */
-#define SPI_KEYMASK_ALT       (1<<3)  /* Mod1Mask */
-#define SPI_KEYMASK_MOD1      (1<<3)  /* Mod1Mask */
-#define SPI_KEYMASK_MOD2      (1<<4)  /* Mod2Mask */
-#define SPI_KEYMASK_MOD3      (1<<5)  /* Mod3Mask */
-#define SPI_KEYMASK_MOD4      (1<<6)  /* Mod4Mask */
-#define SPI_KEYMASK_MOD5      (1<<7)  /* Mod5Mask */
-#define SPI_KEYMASK_BUTTON1   (1L<<8)  /* Button1Mask */
-#define SPI_KEYMASK_BUTTON2   (1L<<9)  /* Button2Mask */
-#define SPI_KEYMASK_BUTTON3   (1L<<10)  /* Button3Mask */
-#define SPI_KEYMASK_BUTTON4   (1L<<11)  /* Button4Mask */
-#define SPI_KEYMASK_BUTTON5   (1L<<12)  /* Button5Mask */
-#define SPI_KEYMASK_CONTROL   (1<<2)  /* ControlMask */
-#define SPI_KEYMASK_SHIFT     (1<<0)  /* ShiftMask */
-#define SPI_KEYMASK_SHIFTLOCK (1<<1)  /* LockMask */
-#define SPI_KEYMASK_NUMLOCK   (1<<14)
+#define SPI_KEYMASK_ALT (1 << 3)       /* Mod1Mask */
+#define SPI_KEYMASK_MOD1 (1 << 3)      /* Mod1Mask */
+#define SPI_KEYMASK_MOD2 (1 << 4)      /* Mod2Mask */
+#define SPI_KEYMASK_MOD3 (1 << 5)      /* Mod3Mask */
+#define SPI_KEYMASK_MOD4 (1 << 6)      /* Mod4Mask */
+#define SPI_KEYMASK_MOD5 (1 << 7)      /* Mod5Mask */
+#define SPI_KEYMASK_BUTTON1 (1L << 8)  /* Button1Mask */
+#define SPI_KEYMASK_BUTTON2 (1L << 9)  /* Button2Mask */
+#define SPI_KEYMASK_BUTTON3 (1L << 10) /* Button3Mask */
+#define SPI_KEYMASK_BUTTON4 (1L << 11) /* Button4Mask */
+#define SPI_KEYMASK_BUTTON5 (1L << 12) /* Button5Mask */
+#define SPI_KEYMASK_CONTROL (1 << 2)   /* ControlMask */
+#define SPI_KEYMASK_SHIFT (1 << 0)     /* ShiftMask */
+#define SPI_KEYMASK_SHIFTLOCK (1 << 1) /* LockMask */
+#define SPI_KEYMASK_NUMLOCK (1 << 14)
 #define SPI_KEYMASK_UNMODIFIED 0
 
 G_END_DECLS
diff --git a/registryd/paths.h b/registryd/paths.h
index a505222a..b4e9ee80 100644
--- a/registryd/paths.h
+++ b/registryd/paths.h
@@ -24,30 +24,30 @@
 #ifndef SPI_PATHS_H_
 #define SPI_PATHS_H_
 
-#define SPI_DBUS_NAME_PREFIX                     "org.a11y.atspi."
-#define SPI_DBUS_PATH_PREFIX                     "/org/a11y/atspi/"
-#define SPI_DBUS_INTERFACE_PREFIX                "org.a11y.atspi."
+#define SPI_DBUS_NAME_PREFIX "org.a11y.atspi."
+#define SPI_DBUS_PATH_PREFIX "/org/a11y/atspi/"
+#define SPI_DBUS_INTERFACE_PREFIX "org.a11y.atspi."
 
-#define SPI_DBUS_PATH_NULL                       SPI_DBUS_PATH_PREFIX "null"
-#define SPI_DBUS_PATH_ROOT                       SPI_DBUS_PATH_PREFIX "accessible/root"
+#define SPI_DBUS_PATH_NULL SPI_DBUS_PATH_PREFIX "null"
+#define SPI_DBUS_PATH_ROOT SPI_DBUS_PATH_PREFIX "accessible/root"
 
-#define SPI_DBUS_NAME_REGISTRY                   SPI_DBUS_NAME_PREFIX "Registry"
-#define SPI_DBUS_INTERFACE_REGISTRY              SPI_DBUS_INTERFACE_PREFIX "Registry"
-#define SPI_DBUS_PATH_REGISTRY                       SPI_DBUS_PATH_PREFIX "registry"
+#define SPI_DBUS_NAME_REGISTRY SPI_DBUS_NAME_PREFIX "Registry"
+#define SPI_DBUS_INTERFACE_REGISTRY SPI_DBUS_INTERFACE_PREFIX "Registry"
+#define SPI_DBUS_PATH_REGISTRY SPI_DBUS_PATH_PREFIX "registry"
 
-#define SPI_DBUS_PATH_DEC                        SPI_DBUS_PATH_PREFIX "registry/deviceeventcontroller"
-#define SPI_DBUS_INTERFACE_DEC                   SPI_DBUS_INTERFACE_PREFIX "DeviceEventController"
+#define SPI_DBUS_PATH_DEC SPI_DBUS_PATH_PREFIX "registry/deviceeventcontroller"
+#define SPI_DBUS_INTERFACE_DEC SPI_DBUS_INTERFACE_PREFIX "DeviceEventController"
 #define SPI_DBUS_INTERFACE_DEVICE_EVENT_LISTENER SPI_DBUS_INTERFACE_PREFIX "DeviceEventListener"
 
-#define SPI_DBUS_PATH_CACHE                       SPI_DBUS_PATH_PREFIX "cache"
-#define SPI_DBUS_INTERFACE_CACHE                 SPI_DBUS_INTERFACE_PREFIX "Cache"
+#define SPI_DBUS_PATH_CACHE SPI_DBUS_PATH_PREFIX "cache"
+#define SPI_DBUS_INTERFACE_CACHE SPI_DBUS_INTERFACE_PREFIX "Cache"
 
-#define SPI_DBUS_INTERFACE_ACCESSIBLE            SPI_DBUS_INTERFACE_PREFIX "Accessible"
-#define SPI_DBUS_INTERFACE_APPLICATION            SPI_DBUS_INTERFACE_PREFIX "Application"
-#define SPI_DBUS_INTERFACE_COMPONENT             SPI_DBUS_INTERFACE_PREFIX "Component"
-#define SPI_DBUS_INTERFACE_EVENT_KEYBOARD        SPI_DBUS_INTERFACE_PREFIX "Keyboard"
-#define SPI_DBUS_INTERFACE_EVENT_MOUSE           SPI_DBUS_INTERFACE_PREFIX "Event.Mouse"
-#define SPI_DBUS_INTERFACE_EVENT_OBJECT          SPI_DBUS_INTERFACE_PREFIX "Event.Object"
-#define SPI_DBUS_INTERFACE_SOCKET                SPI_DBUS_INTERFACE_PREFIX "Socket"
+#define SPI_DBUS_INTERFACE_ACCESSIBLE SPI_DBUS_INTERFACE_PREFIX "Accessible"
+#define SPI_DBUS_INTERFACE_APPLICATION SPI_DBUS_INTERFACE_PREFIX "Application"
+#define SPI_DBUS_INTERFACE_COMPONENT SPI_DBUS_INTERFACE_PREFIX "Component"
+#define SPI_DBUS_INTERFACE_EVENT_KEYBOARD SPI_DBUS_INTERFACE_PREFIX "Keyboard"
+#define SPI_DBUS_INTERFACE_EVENT_MOUSE SPI_DBUS_INTERFACE_PREFIX "Event.Mouse"
+#define SPI_DBUS_INTERFACE_EVENT_OBJECT SPI_DBUS_INTERFACE_PREFIX "Event.Object"
+#define SPI_DBUS_INTERFACE_SOCKET SPI_DBUS_INTERFACE_PREFIX "Socket"
 
 #endif /* SPI_PATHS_H_ */
diff --git a/registryd/reentrant-list.c b/registryd/reentrant-list.c
index 2c08c42d..b723c76b 100644
--- a/registryd/reentrant-list.c
+++ b/registryd/reentrant-list.c
@@ -26,9 +26,10 @@
 
 #include "reentrant-list.h"
 
-typedef struct {
-	GList **list;
-	GList  *iterator;
+typedef struct
+{
+  GList **list;
+  GList *iterator;
 } Iteration;
 
 static GSList *working_list = NULL; /* of Iteration */
@@ -39,12 +40,12 @@ static GSList *working_list = NULL; /* of Iteration */
  * element.
  */
 void
-spi_re_entrant_list_delete_link (GList * const *element_ptr)
+spi_re_entrant_list_delete_link (GList *const *element_ptr)
 {
-  GSList    *l;
-  GList     *next;
-  GList     *element;
-  gboolean   first_item;
+  GSList *l;
+  GList *next;
+  GList *element;
+  gboolean first_item;
   GList *dummy G_GNUC_UNUSED;
 
   g_return_if_fail (element_ptr != NULL);
@@ -59,47 +60,48 @@ spi_re_entrant_list_delete_link (GList * const *element_ptr)
 
   for (l = working_list; l; l = l->next)
     {
-       Iteration *i = l->data;
+      Iteration *i = l->data;
 
-       if (i->iterator == element)
-         {
-           i->iterator = next;
-         }
+      if (i->iterator == element)
+        {
+          i->iterator = next;
+        }
 
-       if (first_item && *(i->list) == element)
-         {
-           *(i->list) = next;
-         }
+      if (first_item && *(i->list) == element)
+        {
+          *(i->list) = next;
+        }
     }
 
   g_list_free_1 (element);
 }
 
 void
-spi_re_entrant_list_foreach (GList         **list,
-			     SpiReEntrantFn  func,
-			     gpointer        user_data)
+spi_re_entrant_list_foreach (GList **list,
+                             SpiReEntrantFn func,
+                             gpointer user_data)
 {
-	Iteration i;
+  Iteration i;
 
-	if (!list || !*list)
-	  {
-            return;
-	  }
+  if (!list || !*list)
+    {
+      return;
+    }
 
-	i.list = list;
-	i.iterator = *list;
+  i.list = list;
+  i.iterator = *list;
 
-	working_list = g_slist_prepend (working_list, &i);
+  working_list = g_slist_prepend (working_list, &i);
 
-	while (i.iterator) {
-		GList *l = i.iterator;
+  while (i.iterator)
+    {
+      GList *l = i.iterator;
 
-		func (&i.iterator, user_data);
+      func (&i.iterator, user_data);
 
-		if (i.iterator == l)
-			i.iterator = i.iterator->next;
-	}
+      if (i.iterator == l)
+        i.iterator = i.iterator->next;
+    }
 
-	working_list = g_slist_remove (working_list, &i);
+  working_list = g_slist_remove (working_list, &i);
 }
diff --git a/registryd/reentrant-list.h b/registryd/reentrant-list.h
index e1241561..39f5527a 100644
--- a/registryd/reentrant-list.h
+++ b/registryd/reentrant-list.h
@@ -28,18 +28,19 @@
 
 G_BEGIN_DECLS
 
-typedef enum {
-	SPI_RE_ENTRANT_CONTINUE = 0,
-	SPI_RE_ENTRANT_TERMINATE
+typedef enum
+{
+  SPI_RE_ENTRANT_CONTINUE = 0,
+  SPI_RE_ENTRANT_TERMINATE
 } SpiReEntrantContinue;
 
-typedef SpiReEntrantContinue (*SpiReEntrantFn) (GList * const *list,
-						gpointer       user_data);
+typedef SpiReEntrantContinue (*SpiReEntrantFn) (GList *const *list,
+                                                gpointer user_data);
 
-void spi_re_entrant_list_delete_link (GList * const  *element_ptr);
-void spi_re_entrant_list_foreach     (GList         **list,
-				      SpiReEntrantFn  func,
-				      gpointer        user_data);
+void spi_re_entrant_list_delete_link (GList *const *element_ptr);
+void spi_re_entrant_list_foreach (GList **list,
+                                  SpiReEntrantFn func,
+                                  gpointer user_data);
 
 G_END_DECLS
 
diff --git a/registryd/registry-main.c b/registryd/registry-main.c
index f46886d2..7619c86a 100644
--- a/registryd/registry-main.c
+++ b/registryd/registry-main.c
@@ -21,38 +21,37 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <stdlib.h>
 #include <config.h>
-#include <string.h>
-#include <glib.h>
+#include <dlfcn.h>
 #include <gio/gio.h>
+#include <glib.h>
 #include <stdio.h>
-#include <dlfcn.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include <dbus/dbus.h>
 
+#include "atspi/atspi.h"
+#include "deviceeventcontroller.h"
 #include "paths.h"
 #include "registry.h"
-#include "deviceeventcontroller.h"
-#include "atspi/atspi.h"
 
 static GMainLoop *mainloop;
 static gchar *dbus_name = NULL;
 static gboolean use_gnome_session = FALSE;
 
-static GOptionEntry optentries[] =
-{
-  {"dbus-name", 0, 0, G_OPTION_ARG_STRING, &dbus_name, "Well-known name to register with D-Bus", NULL},
-  {"use-gnome-session", 0, 0, G_OPTION_ARG_NONE, &use_gnome_session, "Should register with gnome session manager", NULL},
-  {NULL}
+static GOptionEntry optentries[] = {
+  { "dbus-name", 0, 0, G_OPTION_ARG_STRING, &dbus_name, "Well-known name to register with D-Bus", NULL },
+  { "use-gnome-session", 0, 0, G_OPTION_ARG_NONE, &use_gnome_session, "Should register with gnome session manager", NULL },
+  { NULL }
 };
 
-static GDBusProxy      *sm_proxy = NULL;
-static char            *client_id = NULL;
-static GDBusProxy      *client_proxy = NULL;
+static GDBusProxy *sm_proxy = NULL;
+static char *client_id = NULL;
+static GDBusProxy *client_proxy = NULL;
 
-#define SM_DBUS_NAME      "org.gnome.SessionManager"
-#define SM_DBUS_PATH      "/org/gnome/SessionManager"
+#define SM_DBUS_NAME "org.gnome.SessionManager"
+#define SM_DBUS_PATH "/org/gnome/SessionManager"
 #define SM_DBUS_INTERFACE "org.gnome.SessionManager"
 
 #define SM_CLIENT_DBUS_INTERFACE "org.gnome.SessionManager.ClientPrivate"
@@ -61,71 +60,77 @@ static gboolean register_client (void);
 
 static void
 on_session_signal (GDBusProxy *proxy,
-                   gchar      *sender_name,
-                   gchar      *signal_name,
-                   GVariant   *parameters,
-                   gpointer    user_data)
+                   gchar *sender_name,
+                   gchar *signal_name,
+                   GVariant *parameters,
+                   gpointer user_data)
 {
-        if (g_strcmp0 (signal_name, "SessionOver") == 0) {
-                g_main_loop_quit (mainloop);
-        } else if (g_strcmp0 (signal_name, "SessionRunning") == 0) {
-                if (!register_client ())
-                        g_warning ("Unable to register client with session manager");
-        }
+  if (g_strcmp0 (signal_name, "SessionOver") == 0)
+    {
+      g_main_loop_quit (mainloop);
+    }
+  else if (g_strcmp0 (signal_name, "SessionRunning") == 0)
+    {
+      if (!register_client ())
+        g_warning ("Unable to register client with session manager");
+    }
 }
 
 static gboolean
 session_manager_connect (void)
 {
-        GVariant *res;
-        gboolean is_running;
-
-        sm_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION, 0, NULL,
-                                              SM_DBUS_NAME,
-                                              SM_DBUS_PATH,
-                                              SM_DBUS_INTERFACE, NULL, NULL);
-
-        res = g_dbus_proxy_call_sync (sm_proxy,
-                                 "IsSessionRunning", NULL,
-                                  0, 1000, NULL, NULL);
-
-        if (res) {
-                g_variant_get (res, "(b)", &is_running);
-                g_variant_unref (res);
-                if (is_running) {
-                        if (!register_client ())
-                                g_warning ("Unable to register client with session manager");
-                }
+  GVariant *res;
+  gboolean is_running;
+
+  sm_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION, 0, NULL,
+                                            SM_DBUS_NAME,
+                                            SM_DBUS_PATH,
+                                            SM_DBUS_INTERFACE, NULL, NULL);
+
+  res = g_dbus_proxy_call_sync (sm_proxy,
+                                "IsSessionRunning", NULL,
+                                0, 1000, NULL, NULL);
+
+  if (res)
+    {
+      g_variant_get (res, "(b)", &is_running);
+      g_variant_unref (res);
+      if (is_running)
+        {
+          if (!register_client ())
+            g_warning ("Unable to register client with session manager");
         }
+    }
 
-        g_signal_connect (G_OBJECT (sm_proxy), "g-signal",
-                          G_CALLBACK (on_session_signal), NULL);
+  g_signal_connect (G_OBJECT (sm_proxy), "g-signal",
+                    G_CALLBACK (on_session_signal), NULL);
 
-        return (sm_proxy != NULL);
+  return (sm_proxy != NULL);
 }
 
 static gboolean
 end_session_response (gboolean is_okay, const gchar *reason)
 {
-        GVariant *ret;
-        GError *error = NULL;
+  GVariant *ret;
+  GError *error = NULL;
 
-        if (!reason)
-                reason = "";
+  if (!reason)
+    reason = "";
 
-        ret = g_dbus_proxy_call_sync (client_proxy, "EndSessionResponse",
-                                      g_variant_new ("(bs)", is_okay, reason),
-                                      0, 1000, NULL, &error);
+  ret = g_dbus_proxy_call_sync (client_proxy, "EndSessionResponse",
+                                g_variant_new ("(bs)", is_okay, reason),
+                                0, 1000, NULL, &error);
 
-        if (!ret) {
-                g_warning ("Failed to send session response %s", error->message);
-                g_error_free (error);
-                return FALSE;
-        }
-        else
-                g_variant_unref (ret);
+  if (!ret)
+    {
+      g_warning ("Failed to send session response %s", error->message);
+      g_error_free (error);
+      return FALSE;
+    }
+  else
+    g_variant_unref (ret);
 
-        return TRUE;
+  return TRUE;
 }
 
 static void
@@ -135,73 +140,78 @@ client_proxy_signal_cb (GDBusProxy *proxy,
                         GVariant *parameters,
                         gpointer user_data)
 {
-        if (g_strcmp0 (signal_name, "QueryEndSession") == 0) {
-                g_debug ("Got QueryEndSession signal");
-                end_session_response (TRUE, NULL);
-        } else if (g_strcmp0 (signal_name, "EndSession") == 0) {
-                g_debug ("Got EndSession signal");
-                end_session_response (TRUE, NULL);
-                g_main_loop_quit (mainloop);
-        } else if (g_strcmp0 (signal_name, "Stop") == 0) {
-                g_debug ("Got Stop signal");
-                g_main_loop_quit (mainloop);
-        }
+  if (g_strcmp0 (signal_name, "QueryEndSession") == 0)
+    {
+      g_debug ("Got QueryEndSession signal");
+      end_session_response (TRUE, NULL);
+    }
+  else if (g_strcmp0 (signal_name, "EndSession") == 0)
+    {
+      g_debug ("Got EndSession signal");
+      end_session_response (TRUE, NULL);
+      g_main_loop_quit (mainloop);
+    }
+  else if (g_strcmp0 (signal_name, "Stop") == 0)
+    {
+      g_debug ("Got Stop signal");
+      g_main_loop_quit (mainloop);
+    }
 }
 
 static gboolean
 register_client (void)
 {
-        GError     *error;
-        GVariant *res;
-        const char *startup_id;
-        const char *app_id;
-
-        if (client_proxy)
-                return TRUE;
-
-        startup_id = g_getenv ("DESKTOP_AUTOSTART_ID");
-        if (!startup_id)
-                startup_id = "";
-        app_id = "at-spi-registryd.desktop";
-
-        error = NULL;
-        res = g_dbus_proxy_call_sync (sm_proxy,
-                                 "RegisterClient",
-                                      g_variant_new ("(ss)", app_id,
-                                                     startup_id),
-                                      0, 1000, NULL, &error);
-        if (! res) {
-                const char *message = (error && error->message ? error->message
-                                       : "no error");
-                g_warning ("Failed to register client: %s", message);
-                if (error)
-                  g_error_free (error);
-                return FALSE;
-        }
-        g_variant_get (res, "(o)", &client_id);
-        g_variant_unref (res);
+  GError *error;
+  GVariant *res;
+  const char *startup_id;
+  const char *app_id;
+
+  if (client_proxy)
+    return TRUE;
+
+  startup_id = g_getenv ("DESKTOP_AUTOSTART_ID");
+  if (!startup_id)
+    startup_id = "";
+  app_id = "at-spi-registryd.desktop";
+
+  error = NULL;
+  res = g_dbus_proxy_call_sync (sm_proxy,
+                                "RegisterClient",
+                                g_variant_new ("(ss)", app_id,
+                                               startup_id),
+                                0, 1000, NULL, &error);
+  if (!res)
+    {
+      const char *message = (error && error->message ? error->message
+                                                     : "no error");
+      g_warning ("Failed to register client: %s", message);
+      if (error)
+        g_error_free (error);
+      return FALSE;
+    }
+  g_variant_get (res, "(o)", &client_id);
+  g_variant_unref (res);
 
-        client_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION, 0, NULL,
-                                                  SM_DBUS_NAME,
-                                                  client_id,
-                                                  SM_CLIENT_DBUS_INTERFACE,
-                                                  NULL, NULL);
+  client_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION, 0, NULL,
+                                                SM_DBUS_NAME,
+                                                client_id,
+                                                SM_CLIENT_DBUS_INTERFACE,
+                                                NULL, NULL);
 
-        g_signal_connect (client_proxy, "g-signal",
-                          G_CALLBACK (client_proxy_signal_cb), NULL);
+  g_signal_connect (client_proxy, "g-signal",
+                    G_CALLBACK (client_proxy_signal_cb), NULL);
 
-        g_unsetenv ("DESKTOP_AUTOSTART_ID");
+  g_unsetenv ("DESKTOP_AUTOSTART_ID");
 
-        return TRUE;
+  return TRUE;
 }
 
 /*---------------------------------------------------------------------------*/
 
-
 /*---------------------------------------------------------------------------*/
 
 typedef GObject *(*gconf_client_get_default_t) ();
-typedef gboolean (*gconf_client_get_bool_t)(GObject *, const char *, void *);
+typedef gboolean (*gconf_client_get_bool_t) (GObject *, const char *, void *);
 
 int
 main (int argc, char **argv)
@@ -217,31 +227,31 @@ main (int argc, char **argv)
   int ret;
 
   /*Parse command options*/
-  opt = g_option_context_new(NULL);
-  g_option_context_add_main_entries(opt, optentries, NULL);
+  opt = g_option_context_new (NULL);
+  g_option_context_add_main_entries (opt, optentries, NULL);
 
-  if (!g_option_context_parse(opt, &argc, &argv, &err))
+  if (!g_option_context_parse (opt, &argc, &argv, &err))
     {
-      g_error("Option parsing failed: %s\n", err->message);
+      g_error ("Option parsing failed: %s\n", err->message);
       g_clear_error (&err);
     }
 
   if (dbus_name == NULL)
-      dbus_name = SPI_DBUS_NAME_REGISTRY;
+    dbus_name = SPI_DBUS_NAME_REGISTRY;
 
   bus = atspi_get_a11y_bus ();
   if (!bus)
-  {
-    return 0;
-  }
+    {
+      return 0;
+    }
 
   mainloop = g_main_loop_new (NULL, FALSE);
-  atspi_dbus_connection_setup_with_g_main(bus, NULL);
+  atspi_dbus_connection_setup_with_g_main (bus, NULL);
 
-  ret = dbus_bus_request_name(bus, dbus_name, DBUS_NAME_FLAG_DO_NOT_QUEUE, NULL);
+  ret = dbus_bus_request_name (bus, dbus_name, DBUS_NAME_FLAG_DO_NOT_QUEUE, NULL);
   if (ret == DBUS_REQUEST_NAME_REPLY_EXISTS)
     {
-      exit (0);	/* most likely already running */
+      exit (0); /* most likely already running */
     }
   else
     {
@@ -254,7 +264,7 @@ main (int argc, char **argv)
   if (use_gnome_session)
     {
       if (!session_manager_connect ())
-          g_warning ("Unable to connect to session manager");
+        g_warning ("Unable to connect to session manager");
     }
 
   g_main_loop_run (mainloop);
diff --git a/registryd/registry.c b/registryd/registry.c
index 6cb10f08..349e92ec 100644
--- a/registryd/registry.c
+++ b/registryd/registry.c
@@ -23,12 +23,12 @@
  */
 
 #include <config.h>
-#include <string.h>
 #include <ctype.h>
+#include <string.h>
 
+#include "introspection.h"
 #include "paths.h"
 #include "registry.h"
-#include "introspection.h"
 
 typedef struct
 {
@@ -74,7 +74,7 @@ spi_reference_free (SpiReference *ref)
 
 /*---------------------------------------------------------------------------*/
 
-G_DEFINE_TYPE(SpiRegistry, spi_registry, G_TYPE_OBJECT)
+G_DEFINE_TYPE (SpiRegistry, spi_registry, G_TYPE_OBJECT)
 
 static void
 spi_registry_finalize (GObject *object)
@@ -106,12 +106,12 @@ spi_registry_init (SpiRegistry *registry)
 /*---------------------------------------------------------------------------*/
 
 static dbus_bool_t
-return_v_string (DBusMessageIter * iter, const gchar * str)
+return_v_string (DBusMessageIter *iter, const gchar *str)
 {
   DBusMessageIter variant;
 
   if (!dbus_message_iter_open_container (iter, DBUS_TYPE_VARIANT, "s",
-                                    &variant))
+                                         &variant))
     return FALSE;
 
   dbus_message_iter_append_basic (&variant, DBUS_TYPE_STRING, &str);
@@ -120,12 +120,12 @@ return_v_string (DBusMessageIter * iter, const gchar * str)
 }
 
 static dbus_bool_t
-append_reference (DBusMessageIter * iter, SpiReference *ref)
+append_reference (DBusMessageIter *iter, SpiReference *ref)
 {
   DBusMessageIter iter_struct;
 
   if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL,
-                                    &iter_struct))
+                                         &iter_struct))
     return FALSE;
   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &ref->name);
   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH, &ref->path);
@@ -174,15 +174,15 @@ emit_children_changed (DBusConnection *bus,
   DBusMessageIter iter, iter_variant, iter_array;
   dbus_int32_t unused = 0;
 
-  sig = dbus_message_new_signal(SPI_DBUS_PATH_ROOT,
-                                SPI_DBUS_INTERFACE_EVENT_OBJECT,
-                                "ChildrenChanged");
+  sig = dbus_message_new_signal (SPI_DBUS_PATH_ROOT,
+                                 SPI_DBUS_INTERFACE_EVENT_OBJECT,
+                                 "ChildrenChanged");
 
-  dbus_message_iter_init_append(sig, &iter);
+  dbus_message_iter_init_append (sig, &iter);
 
-  dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &operation);
-  dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &index);
-  dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &unused);
+  dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &operation);
+  dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &index);
+  dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &unused);
 
   dbus_message_iter_open_container (&iter, DBUS_TYPE_VARIANT, "(so)",
                                     &iter_variant);
@@ -193,8 +193,8 @@ emit_children_changed (DBusConnection *bus,
                                     &iter_array);
   dbus_message_iter_close_container (&iter, &iter_array);
 
-  dbus_connection_send(bus, sig, NULL);
-  dbus_message_unref(sig);
+  dbus_connection_send (bus, sig, NULL);
+  dbus_message_unref (sig);
 }
 
 static void
@@ -256,11 +256,11 @@ event_is_subtype (gchar **needle, gchar **haystack)
 static gboolean
 needs_mouse_poll (char **event)
 {
-  if (g_strcmp0 (event [0], "Mouse") != 0)
+  if (g_strcmp0 (event[0], "Mouse") != 0)
     return FALSE;
-  if (!event [1] || !event [1][0])
+  if (!event[1] || !event[1][0])
     return TRUE;
-  return (g_strcmp0 (event [1], "Abs") == 0);
+  return (g_strcmp0 (event[1], "Abs") == 0);
 }
 
 static void
@@ -383,23 +383,24 @@ signal_filter (DBusConnection *bus, DBusMessage *message, void *user_data)
   SpiRegistry *reg = SPI_REGISTRY (user_data);
   guint res = DBUS_HANDLER_RESULT_HANDLED;
 
-  const gint   type    = dbus_message_get_type (message);
+  const gint type = dbus_message_get_type (message);
   const char *iface = dbus_message_get_interface (message);
   const char *member = dbus_message_get_member (message);
 
   if (type != DBUS_MESSAGE_TYPE_SIGNAL)
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
-  if (!g_strcmp0(iface, DBUS_INTERFACE_DBUS) &&
-      !g_strcmp0(member, "NameOwnerChanged"))
-      handle_disconnection (reg, message);
+  if (!g_strcmp0 (iface, DBUS_INTERFACE_DBUS) &&
+      !g_strcmp0 (member, "NameOwnerChanged"))
+    handle_disconnection (reg, message);
   else
-      res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+    res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
   return res;
 }
 
-typedef enum {
+typedef enum
+{
   DEMARSHAL_STATUS_SUCCESS,
   DEMARSHAL_STATUS_INVALID_SIGNATURE,
   DEMARSHAL_STATUS_INVALID_VALUE,
@@ -444,7 +445,7 @@ socket_embed (SpiRegistry *registry, SpiReference *app_root)
   return spi_reference_new (registry->bus_unique_name, SPI_DBUS_PATH_ROOT);
 }
 
-static DBusMessage*
+static DBusMessage *
 impl_Embed (DBusMessage *message, SpiRegistry *registry)
 {
   SpiReference *app_root = NULL;
@@ -468,7 +469,7 @@ impl_Embed (DBusMessage *message, SpiRegistry *registry)
   return reply;
 }
 
-static DBusMessage*
+static DBusMessage *
 impl_Unembed (DBusMessage *message, SpiRegistry *registry)
 {
   SpiReference *app_reference;
@@ -491,7 +492,7 @@ impl_Unembed (DBusMessage *message, SpiRegistry *registry)
 /*---------------------------------------------------------------------------*/
 
 static DBusMessage *
-impl_Contains (DBusMessage * message, SpiRegistry *registry)
+impl_Contains (DBusMessage *message, SpiRegistry *registry)
 {
   dbus_bool_t retval = FALSE;
   DBusMessage *reply;
@@ -503,7 +504,7 @@ impl_Contains (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetAccessibleAtPoint (DBusMessage * message, SpiRegistry *registry)
+impl_GetAccessibleAtPoint (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply = NULL;
   DBusMessageIter iter;
@@ -518,7 +519,7 @@ impl_GetAccessibleAtPoint (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetExtents (DBusMessage * message, SpiRegistry *registry)
+impl_GetExtents (DBusMessage *message, SpiRegistry *registry)
 {
   dbus_int32_t x = 0, y = 0, width = 1024, height = 768;
   DBusMessage *reply;
@@ -528,16 +529,16 @@ impl_GetExtents (DBusMessage * message, SpiRegistry *registry)
   dbus_message_iter_init_append (reply, &iter);
   dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL,
                                     &iter_struct);
-    dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &x);
-    dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &y);
-    dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &width);
-    dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &height);
+  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &x);
+  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &y);
+  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &width);
+  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &height);
   dbus_message_iter_close_container (&iter, &iter_struct);
   return reply;
 }
 
 static DBusMessage *
-impl_GetPosition (DBusMessage * message, SpiRegistry *registry)
+impl_GetPosition (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply;
   dbus_int32_t x = 0, y = 0;
@@ -549,7 +550,7 @@ impl_GetPosition (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetSize (DBusMessage * message, SpiRegistry *registry)
+impl_GetSize (DBusMessage *message, SpiRegistry *registry)
 {
   /* TODO - Get the screen size */
   DBusMessage *reply;
@@ -564,7 +565,7 @@ impl_GetSize (DBusMessage * message, SpiRegistry *registry)
 #define LAYER_WIDGET 3;
 
 static DBusMessage *
-impl_GetLayer (DBusMessage * message, SpiRegistry *registry)
+impl_GetLayer (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply;
   dbus_uint32_t rv = LAYER_WIDGET;
@@ -576,7 +577,7 @@ impl_GetLayer (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetMDIZOrder (DBusMessage * message, SpiRegistry *registry)
+impl_GetMDIZOrder (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply;
   dbus_int16_t rv = 0;
@@ -588,7 +589,7 @@ impl_GetMDIZOrder (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GrabFocus (DBusMessage * message, SpiRegistry *registry)
+impl_GrabFocus (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply;
   dbus_bool_t retval = FALSE;
@@ -600,7 +601,7 @@ impl_GrabFocus (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetAlpha (DBusMessage * message, SpiRegistry *registry)
+impl_GetAlpha (DBusMessage *message, SpiRegistry *registry)
 {
   double rv = 1.0;
   DBusMessage *reply;
@@ -615,21 +616,21 @@ impl_GetAlpha (DBusMessage * message, SpiRegistry *registry)
 /*---------------------------------------------------------------------------*/
 
 static dbus_bool_t
-impl_get_Name (DBusMessageIter * iter, SpiRegistry *registry)
+impl_get_Name (DBusMessageIter *iter, SpiRegistry *registry)
 {
   const gchar *name = "main";
   return return_v_string (iter, name);
 }
 
 static dbus_bool_t
-impl_get_Description (DBusMessageIter * iter, SpiRegistry *registry)
+impl_get_Description (DBusMessageIter *iter, SpiRegistry *registry)
 {
   const gchar *description = "";
   return return_v_string (iter, description);
 }
 
 static dbus_bool_t
-impl_get_Parent (DBusMessageIter * iter, SpiRegistry *registry)
+impl_get_Parent (DBusMessageIter *iter, SpiRegistry *registry)
 {
   DBusMessageIter iter_variant;
   SpiReference *null_ref = spi_reference_null ("");
@@ -643,7 +644,7 @@ impl_get_Parent (DBusMessageIter * iter, SpiRegistry *registry)
 }
 
 static dbus_bool_t
-impl_get_ChildCount (DBusMessageIter * iter, SpiRegistry *registry)
+impl_get_ChildCount (DBusMessageIter *iter, SpiRegistry *registry)
 {
   dbus_int32_t rv = registry->apps->len;
   dbus_bool_t result;
@@ -658,19 +659,19 @@ impl_get_ChildCount (DBusMessageIter * iter, SpiRegistry *registry)
 }
 
 static dbus_bool_t
-impl_get_ToolkitName (DBusMessageIter * iter, SpiRegistry *registry)
+impl_get_ToolkitName (DBusMessageIter *iter, SpiRegistry *registry)
 {
   return return_v_string (iter, "at-spi-registry");
 }
 
 static dbus_bool_t
-impl_get_ToolkitVersion (DBusMessageIter * iter, SpiRegistry *registry)
+impl_get_ToolkitVersion (DBusMessageIter *iter, SpiRegistry *registry)
 {
   return return_v_string (iter, "2.0");
 }
 
 static DBusMessage *
-impl_GetChildAtIndex (DBusMessage * message, SpiRegistry *registry)
+impl_GetChildAtIndex (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply;
   DBusMessageIter iter;
@@ -679,8 +680,7 @@ impl_GetChildAtIndex (DBusMessage * message, SpiRegistry *registry)
   dbus_int32_t i;
 
   dbus_error_init (&error);
-  if (!dbus_message_get_args 
-       (message, &error, DBUS_TYPE_INT32, &i, DBUS_TYPE_INVALID))
+  if (!dbus_message_get_args (message, &error, DBUS_TYPE_INT32, &i, DBUS_TYPE_INVALID))
     {
       return dbus_message_new_error (message, DBUS_ERROR_FAILED, "Invalid arguments");
     }
@@ -704,7 +704,7 @@ impl_GetChildAtIndex (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetChildren (DBusMessage * message, SpiRegistry *registry)
+impl_GetChildren (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply = NULL;
   DBusMessageIter iter, iter_array;
@@ -713,18 +713,18 @@ impl_GetChildren (DBusMessage * message, SpiRegistry *registry)
   reply = dbus_message_new_method_return (message);
 
   dbus_message_iter_init_append (reply, &iter);
-  dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(so)", &iter_array);
-  for (i=0; i < registry->apps->len; i++)
+  dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(so)", &iter_array);
+  for (i = 0; i < registry->apps->len; i++)
     {
       SpiReference *current = g_ptr_array_index (registry->apps, i);
       append_reference (&iter_array, current);
     }
-  dbus_message_iter_close_container(&iter, &iter_array);
+  dbus_message_iter_close_container (&iter, &iter_array);
   return reply;
 }
 
 static DBusMessage *
-impl_GetIndexInParent (DBusMessage * message, SpiRegistry *registry)
+impl_GetIndexInParent (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply;
   dbus_uint32_t rv = 0;
@@ -735,7 +735,7 @@ impl_GetIndexInParent (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetRelationSet (DBusMessage * message, SpiRegistry *registry)
+impl_GetRelationSet (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply;
   DBusMessageIter iter, iter_array;
@@ -749,10 +749,10 @@ impl_GetRelationSet (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetRole (DBusMessage * message, SpiRegistry *registry)
+impl_GetRole (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply;
-  dbus_uint32_t rv = 14;	/* TODO: Get DESKTOP_FRAME from somewhere */
+  dbus_uint32_t rv = 14; /* TODO: Get DESKTOP_FRAME from somewhere */
 
   reply = dbus_message_new_method_return (message);
   dbus_message_append_args (reply, DBUS_TYPE_UINT32, &rv, DBUS_TYPE_INVALID);
@@ -760,7 +760,7 @@ impl_GetRole (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetRoleName (DBusMessage * message, SpiRegistry *registry)
+impl_GetRoleName (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply;
   const char *role_name = "desktop frame";
@@ -772,7 +772,7 @@ impl_GetRoleName (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetLocalizedRoleName (DBusMessage * message, SpiRegistry *registry)
+impl_GetLocalizedRoleName (DBusMessage *message, SpiRegistry *registry)
 {
   /* FIXME - Localize this */
   DBusMessage *reply;
@@ -785,12 +785,12 @@ impl_GetLocalizedRoleName (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetState (DBusMessage * message, SpiRegistry *registry)
+impl_GetState (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply = NULL;
   DBusMessageIter iter, iter_array;
 
-  dbus_uint32_t states[2] = {0, 0};
+  dbus_uint32_t states[2] = { 0, 0 };
   guint count;
 
   reply = dbus_message_new_method_return (message);
@@ -807,7 +807,7 @@ impl_GetState (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetAttributes (DBusMessage * message, SpiRegistry *registry)
+impl_GetAttributes (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply = NULL;
   DBusMessageIter iter, array;
@@ -821,7 +821,7 @@ impl_GetAttributes (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetApplication (DBusMessage * message, SpiRegistry *registry)
+impl_GetApplication (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply = NULL;
   DBusMessageIter iter;
@@ -836,7 +836,7 @@ impl_GetApplication (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetInterfaces (DBusMessage * message, SpiRegistry *registry)
+impl_GetInterfaces (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply;
   DBusMessageIter iter, iter_array;
@@ -861,7 +861,7 @@ impl_GetInterfaces (DBusMessage * message, SpiRegistry *registry)
 }
 
 static DBusMessage *
-impl_GetItems (DBusMessage * message, SpiRegistry *registry)
+impl_GetItems (DBusMessage *message, SpiRegistry *registry)
 {
   DBusMessage *reply;
   DBusMessageIter iter, iter_array;
@@ -894,10 +894,10 @@ impl_RegisterEvent (DBusMessage *message, SpiRegistry *registry)
   if (strcmp (signature, "sas") != 0 &&
       strcmp (signature, "s") != 0 &&
       strcmp (signature, "sass") != 0)
-  {
-    g_warning ("got RegisterEvent with invalid signature '%s'", signature);
-    return NULL;
-  }
+    {
+      g_warning ("got RegisterEvent with invalid signature '%s'", signature);
+      return NULL;
+    }
 
   dbus_message_iter_init (message, &iter);
   dbus_message_iter_get_basic (&iter, &orig_name);
@@ -910,27 +910,27 @@ impl_RegisterEvent (DBusMessage *message, SpiRegistry *registry)
   evdata->data = data;
 
   if (dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_ARRAY)
-  {
-    dbus_message_iter_recurse (&iter, &iter_array);
-    while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)
     {
-      const char *property;
-      dbus_message_iter_get_basic (&iter_array, &property);
-      evdata->properties = g_slist_append (evdata->properties,
-                                           g_strdup (property));
-      dbus_message_iter_next (&iter_array);
+      dbus_message_iter_recurse (&iter, &iter_array);
+      while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)
+        {
+          const char *property;
+          dbus_message_iter_get_basic (&iter_array, &property);
+          evdata->properties = g_slist_append (evdata->properties,
+                                               g_strdup (property));
+          dbus_message_iter_next (&iter_array);
+        }
+      dbus_message_iter_next (&iter);
     }
-    dbus_message_iter_next (&iter);
-  }
 
   if (dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_STRING)
-  {
-    const char *app;
-    dbus_message_iter_get_basic (&iter, &app);
-    if (app[0])
-      evdata->app_bus_name = g_strdup (app);
-    dbus_message_iter_next (&iter);
-  }
+    {
+      const char *app;
+      dbus_message_iter_get_basic (&iter, &app);
+      if (app[0])
+        evdata->app_bus_name = g_strdup (app);
+      dbus_message_iter_next (&iter);
+    }
 
   registry->events = g_list_append (registry->events, evdata);
 
@@ -943,23 +943,23 @@ impl_RegisterEvent (DBusMessage *message, SpiRegistry *registry)
                                     SPI_DBUS_INTERFACE_REGISTRY,
                                     "EventListenerRegistered");
   if (signal)
-  {
-    GSList *ls = evdata->properties;
-    if (evdata->app_bus_name)
-      dbus_message_set_destination (message, evdata->app_bus_name);
-    dbus_message_iter_init_append (signal, &iter);
-    dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &sender);
-    dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &name);
-    dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &iter_array);
-    while (ls)
     {
-      dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_STRING, &ls->data);
-      ls = g_slist_next (ls);
+      GSList *ls = evdata->properties;
+      if (evdata->app_bus_name)
+        dbus_message_set_destination (message, evdata->app_bus_name);
+      dbus_message_iter_init_append (signal, &iter);
+      dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &sender);
+      dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &name);
+      dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &iter_array);
+      while (ls)
+        {
+          dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_STRING, &ls->data);
+          ls = g_slist_next (ls);
+        }
+      dbus_message_iter_close_container (&iter, &iter_array);
+      dbus_connection_send (registry->bus, signal, NULL);
+      dbus_message_unref (signal);
     }
-    dbus_message_iter_close_container (&iter, &iter_array);
-    dbus_connection_send (registry->bus, signal, NULL);
-    dbus_message_unref (signal);
-  }
 
   g_free (name);
   return dbus_message_new_method_return (message);
@@ -973,7 +973,7 @@ impl_DeregisterEvent (DBusMessage *message, SpiRegistry *registry)
   const char *sender = dbus_message_get_sender (message);
 
   if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &orig_name,
-    DBUS_TYPE_INVALID))
+                              DBUS_TYPE_INVALID))
     return NULL;
   name = ensure_proper_format (orig_name);
 
@@ -1005,9 +1005,9 @@ impl_GetRegisteredEvents (DBusMessage *message, SpiRegistry *registry)
       if (evdata->app_bus_name && strcmp (evdata->app_bus_name, sender) != 0)
         continue;
 
-      str = g_strconcat (evdata->data [0],
-                         ":", (evdata->data [1]? evdata->data [1]: ""),
-                         ":", (evdata->data [1] && evdata->data [2]? evdata->data [2]: ""), NULL);
+      str = g_strconcat (evdata->data[0],
+                         ":", (evdata->data[1] ? evdata->data[1] : ""),
+                         ":", (evdata->data[1] && evdata->data[2] ? evdata->data[2] : ""), NULL);
       dbus_message_iter_open_container (&iter_array, DBUS_TYPE_STRUCT, NULL, &iter_struct);
       dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &evdata->listener_bus_name);
       dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING, &str);
@@ -1020,8 +1020,8 @@ impl_GetRegisteredEvents (DBusMessage *message, SpiRegistry *registry)
 
 /*---------------------------------------------------------------------------*/
 
-static void 
-emit_Available (DBusConnection * bus)
+static void
+emit_Available (DBusConnection *bus)
 {
   DBusMessage *sig;
   DBusMessageIter iter;
@@ -1029,29 +1029,29 @@ emit_Available (DBusConnection * bus)
     SPI_DBUS_NAME_REGISTRY,
     SPI_DBUS_PATH_ROOT,
   };
-  
-  sig = dbus_message_new_signal(SPI_DBUS_PATH_ROOT, SPI_DBUS_INTERFACE_SOCKET, "Available");
 
-  dbus_message_iter_init_append(sig, &iter);
+  sig = dbus_message_new_signal (SPI_DBUS_PATH_ROOT, SPI_DBUS_INTERFACE_SOCKET, "Available");
+
+  dbus_message_iter_init_append (sig, &iter);
   append_reference (&iter, &root_ref);
 
-  dbus_connection_send(bus, sig, NULL);
-  dbus_message_unref(sig);
+  dbus_connection_send (bus, sig, NULL);
+  dbus_message_unref (sig);
 }
 
 /*---------------------------------------------------------------------------*/
 
 static const char *introspection_header =
-"<?xml version=\"1.0\"?>\n";
+    "<?xml version=\"1.0\"?>\n";
 
 static const char *introspection_node_element =
-"<node name=\"%s\">\n";
+    "<node name=\"%s\">\n";
 
 static const char *introspection_footer =
-"</node>";
+    "</node>";
 
 static DBusMessage *
-impl_Introspect_root (DBusMessage * message, SpiRegistry *registry)
+impl_Introspect_root (DBusMessage *message, SpiRegistry *registry)
 {
   GString *output;
   gchar *final;
@@ -1060,26 +1060,26 @@ impl_Introspect_root (DBusMessage * message, SpiRegistry *registry)
 
   DBusMessage *reply;
 
-  output = g_string_new(introspection_header);
+  output = g_string_new (introspection_header);
 
-  g_string_append_printf(output, introspection_node_element, pathstr);
+  g_string_append_printf (output, introspection_node_element, pathstr);
 
   g_string_append (output, spi_org_a11y_atspi_Accessible);
   g_string_append (output, spi_org_a11y_atspi_Component);
   g_string_append (output, spi_org_a11y_atspi_Socket);
 
-  g_string_append(output, introspection_footer);
-  final = g_string_free(output, FALSE);
+  g_string_append (output, introspection_footer);
+  final = g_string_free (output, FALSE);
 
   reply = dbus_message_new_method_return (message);
-  dbus_message_append_args(reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);
+  dbus_message_append_args (reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);
 
-  g_free(final);
+  g_free (final);
   return reply;
 }
 
 static DBusMessage *
-impl_Introspect_registry (DBusMessage * message, SpiRegistry *registry)
+impl_Introspect_registry (DBusMessage *message, SpiRegistry *registry)
 {
   GString *output;
   gchar *final;
@@ -1088,19 +1088,19 @@ impl_Introspect_registry (DBusMessage * message, SpiRegistry *registry)
 
   DBusMessage *reply;
 
-  output = g_string_new(introspection_header);
+  output = g_string_new (introspection_header);
 
-  g_string_append_printf(output, introspection_node_element, pathstr);
+  g_string_append_printf (output, introspection_node_element, pathstr);
 
   g_string_append (output, spi_org_a11y_atspi_Registry);
 
-  g_string_append(output, introspection_footer);
-  final = g_string_free(output, FALSE);
+  g_string_append (output, introspection_footer);
+  final = g_string_free (output, FALSE);
 
   reply = dbus_message_new_method_return (message);
-  dbus_message_append_args(reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);
+  dbus_message_append_args (reply, DBUS_TYPE_STRING, &final, DBUS_TYPE_INVALID);
 
-  g_free(final);
+  g_free (final);
   return reply;
 }
 
@@ -1112,17 +1112,17 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data)
   SpiRegistry *registry = SPI_REGISTRY (user_data);
   DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
-  const gchar *iface   = dbus_message_get_interface (message);
-  const gchar *member  = dbus_message_get_member (message);
-  const gint   type    = dbus_message_get_type (message);
+  const gchar *iface = dbus_message_get_interface (message);
+  const gchar *member = dbus_message_get_member (message);
+  const gint type = dbus_message_get_type (message);
 
   DBusMessage *reply = NULL;
 
   /* Check for basic reasons not to handle */
-  if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
+  if (type != DBUS_MESSAGE_TYPE_METHOD_CALL ||
       member == NULL ||
-      iface  == NULL)
-      return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+      iface == NULL)
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
   if (!strcmp (iface, "org.freedesktop.DBus.Properties"))
     {
@@ -1146,10 +1146,9 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data)
               reply = dbus_message_new_method_return (message);
               dbus_message_iter_init_append (reply, &iter);
 
-
               if (!strcmp (prop_iface, SPI_DBUS_INTERFACE_ACCESSIBLE))
                 {
-                  if      (!strcmp (prop_member, "Name"))
+                  if (!strcmp (prop_member, "Name"))
                     impl_get_Name (&iter, registry);
                   else if (!strcmp (prop_member, "Description"))
                     impl_get_Description (&iter, registry);
@@ -1159,7 +1158,7 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data)
                     impl_get_ChildCount (&iter, registry);
                   else
                     {
-                      dbus_message_unref (reply); 
+                      dbus_message_unref (reply);
                       reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable");
                     }
                 }
@@ -1171,13 +1170,13 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data)
                     impl_get_ToolkitVersion (&iter, registry);
                   else
                     {
-                      dbus_message_unref (reply); 
+                      dbus_message_unref (reply);
                       reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable");
                     }
                 }
               else
                 {
-                  dbus_message_unref (reply); 
+                  dbus_message_unref (reply);
                   reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable");
                 }
             }
@@ -1196,75 +1195,75 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data)
   if (!strcmp (iface, SPI_DBUS_INTERFACE_ACCESSIBLE))
     {
       result = DBUS_HANDLER_RESULT_HANDLED;
-      if      (!strcmp (member, "GetChildAtIndex"))
-          reply = impl_GetChildAtIndex (message, registry);
+      if (!strcmp (member, "GetChildAtIndex"))
+        reply = impl_GetChildAtIndex (message, registry);
       else if (!strcmp (member, "GetChildren"))
-          reply = impl_GetChildren (message, registry);
+        reply = impl_GetChildren (message, registry);
       else if (!strcmp (member, "GetIndexInParent"))
-          reply = impl_GetIndexInParent (message, registry);
+        reply = impl_GetIndexInParent (message, registry);
       else if (!strcmp (member, "GetRelationSet"))
-          reply = impl_GetRelationSet (message, registry);
+        reply = impl_GetRelationSet (message, registry);
       else if (!strcmp (member, "GetRole"))
-          reply = impl_GetRole (message, registry);
+        reply = impl_GetRole (message, registry);
       else if (!strcmp (member, "GetRoleName"))
-          reply = impl_GetRoleName (message, registry);
+        reply = impl_GetRoleName (message, registry);
       else if (!strcmp (member, "GetLocalizedRoleName"))
-          reply = impl_GetLocalizedRoleName (message, registry);
+        reply = impl_GetLocalizedRoleName (message, registry);
       else if (!strcmp (member, "GetState"))
-          reply = impl_GetState (message, registry);
+        reply = impl_GetState (message, registry);
       else if (!strcmp (member, "GetAttributes"))
-          reply = impl_GetAttributes (message, registry);
+        reply = impl_GetAttributes (message, registry);
       else if (!strcmp (member, "GetApplication"))
-          reply = impl_GetApplication (message, registry);
+        reply = impl_GetApplication (message, registry);
       else if (!strcmp (member, "GetInterfaces"))
-          reply = impl_GetInterfaces (message, registry);
+        reply = impl_GetInterfaces (message, registry);
       else
-         result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     }
 
   if (!strcmp (iface, SPI_DBUS_INTERFACE_COMPONENT))
     {
       result = DBUS_HANDLER_RESULT_HANDLED;
-      if      (!strcmp (member, "Contains"))
-          reply = impl_Contains (message, registry);
+      if (!strcmp (member, "Contains"))
+        reply = impl_Contains (message, registry);
       else if (!strcmp (member, "GetAccessibleAtPoint"))
-          reply = impl_GetAccessibleAtPoint (message, registry);
+        reply = impl_GetAccessibleAtPoint (message, registry);
       else if (!strcmp (member, "GetExtents"))
-          reply = impl_GetExtents (message, registry);
+        reply = impl_GetExtents (message, registry);
       else if (!strcmp (member, "GetPosition"))
-          reply = impl_GetPosition (message, registry);
+        reply = impl_GetPosition (message, registry);
       else if (!strcmp (member, "GetSize"))
-          reply = impl_GetSize (message, registry);
+        reply = impl_GetSize (message, registry);
       else if (!strcmp (member, "GetLayer"))
-          reply = impl_GetLayer (message, registry);
+        reply = impl_GetLayer (message, registry);
       else if (!strcmp (member, "GetMDIZOrder"))
-          reply = impl_GetMDIZOrder (message, registry);
+        reply = impl_GetMDIZOrder (message, registry);
       else if (!strcmp (member, "GrabFocus"))
-          reply = impl_GrabFocus (message, registry);
+        reply = impl_GrabFocus (message, registry);
       else if (!strcmp (member, "GetAlpha"))
-          reply = impl_GetAlpha (message, registry);
+        reply = impl_GetAlpha (message, registry);
       else
-         result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     }
 
   if (!strcmp (iface, SPI_DBUS_INTERFACE_SOCKET))
     {
       result = DBUS_HANDLER_RESULT_HANDLED;
-      if      (!strcmp (member, "Embed"))
-          reply = impl_Embed (message, registry);
+      if (!strcmp (member, "Embed"))
+        reply = impl_Embed (message, registry);
       else if (!strcmp (member, "Unembed"))
-          reply = impl_Unembed (message, registry);
+        reply = impl_Unembed (message, registry);
       else
-          result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     }
 
   if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))
     {
       result = DBUS_HANDLER_RESULT_HANDLED;
-      if      (!strcmp (member, "Introspect"))
-          reply = impl_Introspect_root (message, registry);
+      if (!strcmp (member, "Introspect"))
+        reply = impl_Introspect_root (message, registry);
       else
-          result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     }
 
   if (result == DBUS_HANDLER_RESULT_HANDLED)
@@ -1283,7 +1282,7 @@ handle_method_root (DBusConnection *bus, DBusMessage *message, void *user_data)
       g_print ("Registry | Unhandled message : %s|%s\n", iface, member);
     }
 #endif
-  
+
   return result;
 }
 
@@ -1293,25 +1292,25 @@ handle_method_cache (DBusConnection *bus, DBusMessage *message, void *user_data)
   SpiRegistry *registry = SPI_REGISTRY (user_data);
   DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
-  const gchar *iface   = dbus_message_get_interface (message);
-  const gchar *member  = dbus_message_get_member (message);
-  const gint   type    = dbus_message_get_type (message);
+  const gchar *iface = dbus_message_get_interface (message);
+  const gchar *member = dbus_message_get_member (message);
+  const gint type = dbus_message_get_type (message);
 
   DBusMessage *reply = NULL;
 
   /* Check for basic reasons not to handle */
-  if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
+  if (type != DBUS_MESSAGE_TYPE_METHOD_CALL ||
       member == NULL ||
-      iface  == NULL)
-      return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+      iface == NULL)
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
   if (!strcmp (iface, SPI_DBUS_INTERFACE_CACHE))
     {
       result = DBUS_HANDLER_RESULT_HANDLED;
-      if      (!strcmp (member, "GetItems"))
-          reply = impl_GetItems (message, registry);
+      if (!strcmp (member, "GetItems"))
+        reply = impl_GetItems (message, registry);
       else
-         result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     }
 
   if (result == DBUS_HANDLER_RESULT_HANDLED)
@@ -1333,38 +1332,38 @@ handle_method_registry (DBusConnection *bus, DBusMessage *message, void *user_da
   SpiRegistry *registry = SPI_REGISTRY (user_data);
   DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
-  const gchar *iface   = dbus_message_get_interface (message);
-  const gchar *member  = dbus_message_get_member (message);
-  const gint   type    = dbus_message_get_type (message);
+  const gchar *iface = dbus_message_get_interface (message);
+  const gchar *member = dbus_message_get_member (message);
+  const gint type = dbus_message_get_type (message);
 
   DBusMessage *reply = NULL;
 
   /* Check for basic reasons not to handle */
-  if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
+  if (type != DBUS_MESSAGE_TYPE_METHOD_CALL ||
       member == NULL ||
-      iface  == NULL)
-      return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+      iface == NULL)
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
   if (!strcmp (iface, SPI_DBUS_INTERFACE_REGISTRY))
     {
       result = DBUS_HANDLER_RESULT_HANDLED;
-      if (!strcmp(member, "RegisterEvent"))
-      reply = impl_RegisterEvent (message, registry);
-      else if (!strcmp(member, "DeregisterEvent"))
+      if (!strcmp (member, "RegisterEvent"))
+        reply = impl_RegisterEvent (message, registry);
+      else if (!strcmp (member, "DeregisterEvent"))
         reply = impl_DeregisterEvent (message, registry);
-      else if (!strcmp(member, "GetRegisteredEvents"))
+      else if (!strcmp (member, "GetRegisteredEvents"))
         reply = impl_GetRegisteredEvents (message, registry);
       else
-          result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     }
 
   if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))
     {
       result = DBUS_HANDLER_RESULT_HANDLED;
-      if      (!strcmp (member, "Introspect"))
-          reply = impl_Introspect_registry (message, registry);
+      if (!strcmp (member, "Introspect"))
+        reply = impl_Introspect_registry (message, registry);
       else
-          result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
     }
 
   if (result == DBUS_HANDLER_RESULT_HANDLED)
@@ -1383,35 +1382,32 @@ handle_method_registry (DBusConnection *bus, DBusMessage *message, void *user_da
       g_print ("Registry | Unhandled message : %s|%s\n", iface, member);
     }
 #endif
-  
+
   return result;
 }
 
 /*---------------------------------------------------------------------------*/
 
-static DBusObjectPathVTable root_vtable =
-{
+static DBusObjectPathVTable root_vtable = {
   NULL,
   &handle_method_root,
   NULL, NULL, NULL, NULL
 };
 
-static DBusObjectPathVTable registry_vtable =
-{
+static DBusObjectPathVTable registry_vtable = {
   NULL,
   &handle_method_registry,
   NULL, NULL, NULL, NULL
 };
 
-static DBusObjectPathVTable cache_vtable =
-{
+static DBusObjectPathVTable cache_vtable = {
   NULL,
   &handle_method_cache,
   NULL, NULL, NULL, NULL
 };
 
 static gchar *app_sig_match_name_owner =
-       "type='signal', interface='org.freedesktop.DBus', member='NameOwnerChanged'";
+    "type='signal', interface='org.freedesktop.DBus', member='NameOwnerChanged'";
 
 SpiRegistry *
 spi_registry_new (DBusConnection *bus, SpiDEController *dec)
diff --git a/registryd/registry.h b/registryd/registry.h
index a66233e5..96569f2e 100644
--- a/registryd/registry.h
+++ b/registryd/registry.h
@@ -24,8 +24,8 @@
 #ifndef SPI_REGISTRY_H_
 #define SPI_REGISTRY_H_
 
-#include <glib.h>
 #include <glib-object.h>
+#include <glib.h>
 
 #include <dbus/dbus.h>
 
@@ -36,16 +36,17 @@ typedef struct _SpiRegistryClass SpiRegistryClass;
 
 G_BEGIN_DECLS
 
-#define SPI_REGISTRY_TYPE        (spi_registry_get_type ())
-#define SPI_REGISTRY(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_REGISTRY_TYPE, SpiRegistry))
-#define SPI_REGISTRY_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), SPI_REGISTRY_TYPE, SpiRegistryClass))
-#define SPI_IS_REGISTRY(o)       (G_TYPE_CHECK__INSTANCE_TYPE ((o), SPI_REGISTRY_TYPE))
+#define SPI_REGISTRY_TYPE (spi_registry_get_type ())
+#define SPI_REGISTRY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SPI_REGISTRY_TYPE, SpiRegistry))
+#define SPI_REGISTRY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SPI_REGISTRY_TYPE, SpiRegistryClass))
+#define SPI_IS_REGISTRY(o) (G_TYPE_CHECK__INSTANCE_TYPE ((o), SPI_REGISTRY_TYPE))
 #define SPI_IS_REGISTRY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SPI_REGISTRY_TYPE))
 
-struct _SpiRegistry {
-  GObject      parent;
+struct _SpiRegistry
+{
+  GObject parent;
   SpiDEController *dec;
-  GPtrArray   *apps;
+  GPtrArray *apps;
   dbus_int32_t id;
 
   DBusConnection *bus;
@@ -53,12 +54,13 @@ struct _SpiRegistry {
   GList *events;
 };
 
-struct _SpiRegistryClass {
+struct _SpiRegistryClass
+{
   GObjectClass parent_class;
 };
 
-GType        spi_registry_get_type (void);
-SpiRegistry *spi_registry_new      (DBusConnection *bus, SpiDEController *dec);
+GType spi_registry_get_type (void);
+SpiRegistry *spi_registry_new (DBusConnection *bus, SpiDEController *dec);
 
 G_END_DECLS
 
diff --git a/registryd/ucs2keysym.c b/registryd/ucs2keysym.c
index 29a92f3e..bcc3e702 100644
--- a/registryd/ucs2keysym.c
+++ b/registryd/ucs2keysym.c
@@ -31,13 +31,14 @@
  *
  */
 
+#include "deviceeventcontroller.h" /* for prototype */
 #include <X11/X.h>
-#include "deviceeventcontroller.h"	/* for prototype */
 
 /* DO NOT UPATE BY HAND!
  * This table can be regenerated from Xorg's keysymdef.h with the ucs2keysym.sh
  * script.  */
-struct codepair {
+struct codepair
+{
   unsigned short keysym;
   unsigned short ucs;
 } keysymtab[] = {
@@ -823,56 +824,62 @@ struct codepair {
   { 0x0ef5, 0x3186 }, /*          Hangul_YeorinHieuh ㆆ HANGUL LETTER YEORINHIEUH */
   { 0x0ef6, 0x318d }, /*                Hangul_AraeA ㆍ HANGUL LETTER ARAEA */
   { 0x0ef7, 0x318e }, /*               Hangul_AraeAE ㆎ HANGUL LETTER ARAEAE */
- };
+};
 
-long ucs2keysym (long ucs)
+long
+ucs2keysym (long ucs)
 {
-    int min = 0;
-    int max = sizeof(keysymtab) / sizeof(struct codepair) - 1;
-    int mid;
-    
-    /* first check for Latin-1 characters (1:1 mapping) */
-    if ((ucs >= 0x0020 && ucs <= 0x007e) ||
-        (ucs >= 0x00a0 && ucs <= 0x00ff))
-        return ucs;
+  int min = 0;
+  int max = sizeof (keysymtab) / sizeof (struct codepair) - 1;
+  int mid;
+
+  /* first check for Latin-1 characters (1:1 mapping) */
+  if ((ucs >= 0x0020 && ucs <= 0x007e) ||
+      (ucs >= 0x00a0 && ucs <= 0x00ff))
+    return ucs;
 
-    /* binary search in table */
-    while (max >= min) {
-	mid = (min + max) / 2;
-	if (keysymtab[mid].ucs < ucs)
-	    min = mid + 1;
-	else if (keysymtab[mid].ucs > ucs)
-	    max = mid - 1;
-	else {
-	    /* found it */
-	    return keysymtab[mid].keysym;
-	}
+  /* binary search in table */
+  while (max >= min)
+    {
+      mid = (min + max) / 2;
+      if (keysymtab[mid].ucs < ucs)
+        min = mid + 1;
+      else if (keysymtab[mid].ucs > ucs)
+        max = mid - 1;
+      else
+        {
+          /* found it */
+          return keysymtab[mid].keysym;
+        }
     }
 
-    /* no matching keysym value found, return UCS2 with bit set */
-    return ucs | 0x01000000;
+  /* no matching keysym value found, return UCS2 with bit set */
+  return ucs | 0x01000000;
 }
 
-long keysym2ucs(long keysym)
+long
+keysym2ucs (long keysym)
 {
-    int i;
+  int i;
 
-    /* first check for Latin-1 characters (1:1 mapping) */
-    if ((keysym >= 0x0020 && keysym <= 0x007e) ||
-        (keysym >= 0x00a0 && keysym <= 0x00ff))
-        return (long) keysym;
+  /* first check for Latin-1 characters (1:1 mapping) */
+  if ((keysym >= 0x0020 && keysym <= 0x007e) ||
+      (keysym >= 0x00a0 && keysym <= 0x00ff))
+    return (long) keysym;
 
-    /* also check for directly encoded 24-bit UCS characters */
-    if ((keysym & 0xff000000) == 0x01000000)
-	return keysym & 0x00ffffff;
+  /* also check for directly encoded 24-bit UCS characters */
+  if ((keysym & 0xff000000) == 0x01000000)
+    return keysym & 0x00ffffff;
 
-    for (i = 0; i < sizeof(keysymtab) / sizeof(keysymtab[0]); i++) {
-	if (keysymtab[i].keysym == keysym) {
-	    /* found it */
-	    return keysymtab[i].ucs;
-	}
+  for (i = 0; i < sizeof (keysymtab) / sizeof (keysymtab[0]); i++)
+    {
+      if (keysymtab[i].keysym == keysym)
+        {
+          /* found it */
+          return keysymtab[i].ucs;
+        }
     }
 
-    /* no matching Unicode value found */
-    return -1;
+  /* no matching Unicode value found */
+  return -1;
 }