[gtk-mac-integration] Reformat to Gnome coding standard



commit e0aa429e1de9c018a0484be83bae8cb341f70d8b
Author: John Ralls <jralls ceridwen us>
Date:   Tue Jun 25 17:45:12 2013 -0700

    Reformat to Gnome coding standard

 src/GNSMenuBar.c               |   62 +-
 src/GNSMenuItem.c              |   98 ++--
 src/GtkApplicationDelegate.c   |   39 +-
 src/GtkApplicationNotify.c     |   66 +-
 src/cocoa_menu.c               |    6 +-
 src/cocoa_menu_item.c          | 1391 ++++++++++++++++----------------
 src/getlabel.c                 |   14 +-
 src/gtk-mac-bundle.c           |   25 +-
 src/gtk-mac-dock.c             |   59 +-
 src/gtk-mac-image-utils.c      |    4 +-
 src/gtk-mac-menu.c             | 1749 +++++++++++++++++++++-------------------
 src/gtkosx-image.c             |   32 +-
 src/gtkosxapplication.c        |   36 +-
 src/gtkosxapplication_quartz.c |  671 ++++++++--------
 src/test-integration.c         |  563 +++++++------
 15 files changed, 2508 insertions(+), 2307 deletions(-)
---
diff --git a/src/GNSMenuBar.c b/src/GNSMenuBar.c
index 41b5d3a..26350d9 100644
--- a/src/GNSMenuBar.c
+++ b/src/GNSMenuBar.c
@@ -1,4 +1,4 @@
-/* GTK+ Integration with platform-specific application-wide features 
+/* GTK+ Integration with platform-specific application-wide features
  * such as the OS X menubar and application delegate concepts.
  *
  * Copyright © 2010 John Ralls
@@ -23,100 +23,104 @@
 
 @implementation _GNSMenuBar
 
-- (id) initWithTitle:(NSString*) title
+-(id) initWithTitle: (NSString*) title
 {
   self = [super initWithTitle: title];
   app_menu_groups = nil;
   return self;
 }
 
-- (id) initWithGtkMenuBar: (GtkMenuBar*) menubar
+-(id) initWithGtkMenuBar: (GtkMenuBar*) menubar
 {
   self = [self initWithTitle: @""];
   gtk_menubar = menubar;
   return self;
 }
 
-- (GtkosxApplicationMenuGroup*) addGroup
+-(GtkosxApplicationMenuGroup*) addGroup
 {
   GtkosxApplicationMenuGroup *group = g_slice_new0 (GtkosxApplicationMenuGroup);
   app_menu_groups = g_list_append (app_menu_groups, group);
   return group;
 }
 
-- (GList *) app_menu_groups
+-(GList *) app_menu_groups
 {
   return app_menu_groups;
 }
 
-- (void) resync
+-(void) resync
 {
-  cocoa_menu_item_add_submenu(GTK_MENU_SHELL(gtk_menubar), self, TRUE, FALSE);
-    if (help_menu && 
-       [help_menu menu] == self &&
-       [self indexOfItem: (NSMenuItem*)help_menu] < [self numberOfItems] - 1) {
-    [self removeItem: (NSMenuItem*)help_menu];
-    [self addItem: (NSMenuItem*)help_menu];
-  }
+  cocoa_menu_item_add_submenu (GTK_MENU_SHELL (gtk_menubar), self, TRUE, FALSE);
+  if (help_menu &&
+  [help_menu menu] == self &&
+      [self indexOfItem: (NSMenuItem*)help_menu] < [self numberOfItems] - 1)
+    {
+      [self removeItem: (NSMenuItem*)help_menu];
+      [self addItem: (NSMenuItem*)help_menu];
+    }
   if ([window_menu menu] == self &&
-      [self indexOfItem: (NSMenuItem*)window_menu] != [self numberOfItems] - 2) {
-    [self removeItem: (NSMenuItem*)window_menu];
-    [self insertItem: (NSMenuItem*)window_menu atIndex: [self numberOfItems] - 1];
+      [self indexOfItem: (NSMenuItem*)window_menu] != [self numberOfItems] - 2)
+    {
+      [self removeItem: (NSMenuItem*)window_menu];
+      [self insertItem: (NSMenuItem*)window_menu atIndex: [self numberOfItems] - 1];
     }
 }
 
-- (GtkMenuBar*) menuBar
+-(GtkMenuBar*) menuBar
 {
   return gtk_menubar;
 }
 
-- (void) setAppMenu: (_GNSMenuItem*) menu_item
+-(void) setAppMenu: (_GNSMenuItem*) menu_item
 {
   [app_menu release];
   app_menu = menu_item;
   [app_menu retain];
 }
 
-- (_GNSMenuItem*) appMenu {
+- (_GNSMenuItem*) appMenu
+{
   return app_menu;
 }
 
-- (void) setWindowsMenu: (_GNSMenuItem*) menu_item 
+- (void) setWindowsMenu: (_GNSMenuItem*) menu_item
 {
   [window_menu release];
   window_menu = menu_item;
   [window_menu retain];
 }
 
-- (_GNSMenuItem*) windowsMenu
+-(_GNSMenuItem*) windowsMenu
 {
   return window_menu;
 }
 
-- (void) setHelpMenu: (_GNSMenuItem*) menu_item
+-(void) setHelpMenu: (_GNSMenuItem*) menu_item
 {
   [help_menu release];
   help_menu = menu_item;
   [help_menu retain];
 }
 
-- (_GNSMenuItem*) helpMenu
+-(_GNSMenuItem*) helpMenu
 {
   return help_menu;
 }
 
-- (void) dealloc
+-(void) dealloc
 {
   GList *list;
-  for (list = app_menu_groups; list; list = g_list_next(list)) {
-    if (list && list->data)
-      g_list_free(list->data);
-  }
+  for (list = app_menu_groups; list; list = g_list_next (list))
+    {
+      if (list && list->data)
+        g_list_free (list->data);
+    }
   [app_menu release];
   [window_menu release];
   [help_menu release];
   if (app_menu_groups)
-    g_list_free(app_menu_groups);
+    g_list_free (app_menu_groups);
   [super dealloc];
 
 }
diff --git a/src/GNSMenuItem.c b/src/GNSMenuItem.c
index c177359..0916406 100644
--- a/src/GNSMenuItem.c
+++ b/src/GNSMenuItem.c
@@ -1,5 +1,5 @@
 /* --- objc-mode --- */
-/* GTK+ Integration with platform-specific application-wide features 
+/* GTK+ Integration with platform-specific application-wide features
  * such as the OS X menubar and application delegate concepts.
  *
  * Copyright (C) 2009 Paul Davis
@@ -28,46 +28,49 @@ idle_call_activate (ClosureData *action)
 {
 //    g_value_init(&args, GTK_TYPE_MENU_ITEM);
   GValue arg = {0};
-  g_value_init(&arg, G_TYPE_POINTER);
-  g_value_set_pointer(&arg, action->data);
-  g_closure_invoke(action->closure, NULL, 1, &arg, 0);
+  g_value_init (&arg, G_TYPE_POINTER);
+  g_value_set_pointer (&arg, action->data);
+  g_closure_invoke (action->closure, NULL, 1, &arg, 0);
 //  gtk_menu_item_activate ((GtkMenuItem*) data);
   return FALSE;
 }
 
 @implementation _GNSMenuItem
 
-- (id) initWithTitle:(NSString*) title aGClosure:(GClosure*) closure andPointer:(gpointer) ptr
+-(id) initWithTitle: (NSString*) title
+           aGClosure: (GClosure*) closure
+          andPointer: (gpointer) ptr
 {
 
   /* All menu items have the action "activate", which will be handled by this child class
    */
-  self = [ super initWithTitle:title action:@selector(activate:) keyEquivalent:@"" ];
+  self = [ super initWithTitle: title action: @selector (activate: ) keyEquivalent: @"" ];
 
-  if (self) {
-    /* make this handle its own action */
-    [ self setTarget:self ];
-    g_closure_ref(closure);
-    g_closure_sink(closure);
-    action.closure = closure;
-    action.data = ptr;
-    accel_closure = NULL;
-    notUsed = NO;
-  }
+  if (self)
+    {
+      /* make this handle its own action */
+      [ self setTarget: self ];
+      g_closure_ref (closure);
+      g_closure_sink (closure);
+      action.closure = closure;
+      action.data = ptr;
+      accel_closure = NULL;
+      notUsed = NO;
+    }
   return self;
 }
 
-- (void) activate:(id) sender
+-(void) activate: (id) sender
 {
-/* Add an idle in a thread-safe way and wake up the main loop with
-   a bogus event: */
+  /* Add an idle in a thread-safe way and wake up the main loop with
+     a bogus event: */
   GdkEvent *wake_up = gdk_event_new (GDK_NOTHING);
   gdk_threads_add_idle ((GSourceFunc)idle_call_activate, &action);
   gdk_event_put (wake_up);
   gdk_event_free (wake_up);
 }
 
-- (BOOL) isHidden
+-(BOOL) isHidden
 {
 #if MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_4
   return [super isHidden];
@@ -75,56 +78,59 @@ idle_call_activate (ClosureData *action)
   return hidden;
 #endif
 }
-  
-- (void) setHidden: (BOOL) shouldHide
+
+-(void) setHidden: (BOOL)shouldHide
 {
 #if MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_4
   [super setHidden: shouldHide];
 #else
   [self retain];
-  if (!hidden && shouldHide) {
-    inMenu = [self menu];
-    index = [inMenu indexOfItem: self];
-    [inMenu removeItem: self];
-    hidden = YES;
-  }
-  else if (hidden && !shouldHide) {
+  if (!hidden && shouldHide)
+    {
+      inMenu = [self menu];
+      index = [inMenu indexOfItem: self];
+      [inMenu removeItem: self];
+      hidden = YES;
+    }
+  else if (hidden && !shouldHide)
+    {
       int maxIndex = [inMenu numberOfItems];
-    hidden = NO;
-    if (index < 0) index = 0;
-    if (index > maxIndex) index = maxIndex;
-    [inMenu insertItem: self atIndex: index];
-    [(_GNSMenuBar*)[NSApp mainMenu] resync];
-  }
+      hidden = NO;
+      if (index < 0) index = 0;
+      if (index > maxIndex) index = maxIndex;
+      [inMenu insertItem: self atIndex: index];
+      [(_GNSMenuBar*)[NSApp mainMenu] resync];
+    }
   [self release];
 #endif
 }
 
-- (void) mark
+-(void) mark
 {
   notUsed = YES;
 }
 
-- (void) unmark
+-(void) unmark
 {
   notUsed = NO;
 }
 
-- (BOOL) isMarked
+-(BOOL) isMarked
 {
   return notUsed;
 }
 
-- (void) removeFromMenu: (NSMenu*) old_menu {
+-(void) removeFromMenu: (NSMenu*)old_menu
+{
 #if !(MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_4)
-    if (old_menu != inMenu && old_menu != [self menu])
-      return;
-    [[self menu] removeItem: self];
-    inMenu = nil;
-    index = -1;
+  if (old_menu != inMenu && old_menu != [self menu])
+    return;
+  [[self menu] removeItem: self];
+  inMenu = nil;
+  index = -1;
 #else
-    if (old_menu == [self menu])
-      [[self menu] removeItem: self];
+  if (old_menu == [self menu])
+    [[self menu] removeItem: self];
 #endif
 }
 
diff --git a/src/GtkApplicationDelegate.c b/src/GtkApplicationDelegate.c
index 0176813..e7ecd2c 100644
--- a/src/GtkApplicationDelegate.c
+++ b/src/GtkApplicationDelegate.c
@@ -1,4 +1,4 @@
-/* GTK+ Integration with platform-specific application-wide features 
+/* GTK+ Integration with platform-specific application-wide features
  * such as the OS X menubar and application delegate concepts.
  *
  * Copyright (C) 2009 Paul Davis
@@ -25,34 +25,35 @@
 #include "gtkosxapplication.h"
 
 @implementation GtkApplicationDelegate
--(BOOL) application:(NSApplication*) theApplication openFile:(NSString*) file
+-(BOOL) application: (NSApplication*)theApplication openFile: (NSString*) file
 {
   const gchar *utf8_path =  [file UTF8String];
-  GtkosxApplication *app = g_object_new(GTKOSX_TYPE_APPLICATION, NULL);
-  guint sig = g_signal_lookup("NSApplicationOpenFile", 
-                             GTKOSX_TYPE_APPLICATION);
+  GtkosxApplication *app = g_object_new (GTKOSX_TYPE_APPLICATION, NULL);
+  guint sig = g_signal_lookup ("NSApplicationOpenFile",
+  GTKOSX_TYPE_APPLICATION);
   gboolean result = FALSE;
   if (sig)
-      g_signal_emit(app, sig, 0, utf8_path, &result);
-  g_object_unref(app);
+    g_signal_emit (app, sig, 0, utf8_path, &result);
+  g_object_unref (app);
   return result;
 }
 
 
-- (NSApplicationTerminateReply) applicationShouldTerminate:(NSApplication *)sender
+-(NSApplicationTerminateReply) applicationShouldTerminate: (NSApplication *)sender
 {
-  GtkosxApplication *app = g_object_new(GTKOSX_TYPE_APPLICATION, NULL);
-  guint sig = g_signal_lookup("NSApplicationBlockTermination", 
-                             GTKOSX_TYPE_APPLICATION);
+  GtkosxApplication *app = g_object_new (GTKOSX_TYPE_APPLICATION, NULL);
+  guint sig = g_signal_lookup ("NSApplicationBlockTermination",
+  GTKOSX_TYPE_APPLICATION);
   gboolean result = FALSE;
   static gboolean inHandler = FALSE;
   if (inHandler) return NSTerminateCancel;
-  if (sig) {
+  if (sig)
+    {
       inHandler = TRUE;
-      g_signal_emit(app, sig, 0, &result);
-  }
+      g_signal_emit (app, sig, 0, &result);
+    }
 
-  g_object_unref(app);
+  g_object_unref (app);
   inHandler = FALSE;
   if (!result)
     return NSTerminateNow;
@@ -60,12 +61,12 @@
     return NSTerminateCancel;
 }
 
-extern NSMenu* _gtkosx_application_dock_menu(GtkosxApplication* app);
+extern NSMenu* _gtkosx_application_dock_menu (GtkosxApplication* app);
 
--(NSMenu *)applicationDockMenu: (NSApplication*) sender
+-(NSMenu *) applicationDockMenu: (NSApplication*)sender
 {
-    GtkosxApplication *app = g_object_new(GTKOSX_TYPE_APPLICATION, NULL);
-    return _gtkosx_application_dock_menu(app);
+  GtkosxApplication *app = g_object_new (GTKOSX_TYPE_APPLICATION, NULL);
+  return _gtkosx_application_dock_menu (app);
 }
 
 @end
diff --git a/src/GtkApplicationNotify.c b/src/GtkApplicationNotify.c
index fbae00b..90f5cfb 100644
--- a/src/GtkApplicationNotify.c
+++ b/src/GtkApplicationNotify.c
@@ -1,4 +1,4 @@
-/* GTK+ Integration with platform-specific application-wide features 
+/* GTK+ Integration with platform-specific application-wide features
  * such as the OS X menubar and application delegate concepts.
  *
  * Copyright (C) 2009 Paul Davis
@@ -25,57 +25,57 @@
 #include "gtkosxapplication.h"
 
 @implementation GtkApplicationNotificationObject
-- (GtkApplicationNotificationObject*) init
+-(GtkApplicationNotificationObject*) init
 {
   self = [ super init ];
-  g_return_val_if_fail(self != NULL, NULL);
-  [[NSNotificationCenter defaultCenter] addObserver:self
-   selector:@selector(appDidBecomeActive:)
-   name:NSApplicationDidBecomeActiveNotification
-   object:NSApp];
+  g_return_val_if_fail (self != NULL, NULL);
+  [[NSNotificationCenter defaultCenter] addObserver: self
+   selector: @selector (appDidBecomeActive: )
+   name: NSApplicationDidBecomeActiveNotification
+   object: NSApp];
 
-  [[NSNotificationCenter defaultCenter] addObserver:self
-   selector:@selector(appDidBecomeInactive:)
-   name:NSApplicationWillResignActiveNotification 
-   object:NSApp];
+  [[NSNotificationCenter defaultCenter] addObserver: self
+   selector: @selector (appDidBecomeInactive: )
+   name: NSApplicationWillResignActiveNotification
+   object: NSApp];
 
-  [[NSNotificationCenter defaultCenter] addObserver:self
-   selector:@selector(appWillTerminate:)
-   name:NSApplicationWillTerminateNotification
-   object:NSApp];
+  [[NSNotificationCenter defaultCenter] addObserver: self
+   selector: @selector (appWillTerminate: )
+   name: NSApplicationWillTerminateNotification
+   object: NSApp];
 
   return self;
 }
 
-- (void)appDidBecomeActive:(NSNotification *)notification
+-(void) appDidBecomeActive: (NSNotification *)notification
 {
-  GtkosxApplication *app = g_object_new(GTKOSX_TYPE_APPLICATION, NULL);
-  guint sig = g_signal_lookup("NSApplicationDidBecomeActive", 
-                             GTKOSX_TYPE_APPLICATION);
+  GtkosxApplication *app = g_object_new (GTKOSX_TYPE_APPLICATION, NULL);
+  guint sig = g_signal_lookup ("NSApplicationDidBecomeActive",
+                              GTKOSX_TYPE_APPLICATION);
   if (sig)
-      g_signal_emit(app, sig, 0);
-  g_object_unref(app);
+    g_signal_emit (app, sig, 0);
+  g_object_unref (app);
 }
 
-- (void)appDidBecomeInactive:(NSNotification *)notification
+-(void) appDidBecomeInactive: (NSNotification *)notification
 {
-  GtkosxApplication *app = g_object_new(GTKOSX_TYPE_APPLICATION, NULL);
-  guint sig = g_signal_lookup("NSApplicationWillResignActive", 
-                             GTKOSX_TYPE_APPLICATION);
+  GtkosxApplication *app = g_object_new (GTKOSX_TYPE_APPLICATION, NULL);
+  guint sig = g_signal_lookup ("NSApplicationWillResignActive",
+                              GTKOSX_TYPE_APPLICATION);
   if (sig)
-      g_signal_emit(app, sig, 0);
-  g_object_unref(app);
+    g_signal_emit (app, sig, 0);
+  g_object_unref (app);
 }
 
-- (void)appWillTerminate:(NSNotification *)notification
+-(void) appWillTerminate: (NSNotification *)notification
 {
-  GtkosxApplication *app = g_object_new(GTKOSX_TYPE_APPLICATION, NULL);
+  GtkosxApplication *app = g_object_new (GTKOSX_TYPE_APPLICATION, NULL);
   [[NSNotificationCenter defaultCenter] removeObserver: self];
-  guint sig = g_signal_lookup("NSApplicationWillTerminate", 
-                             GTKOSX_TYPE_APPLICATION);
+  guint sig = g_signal_lookup ("NSApplicationWillTerminate",
+                              GTKOSX_TYPE_APPLICATION);
   if (sig)
-      g_signal_emit(app, sig, 0);
-  g_object_unref(app);
+    g_signal_emit (app, sig, 0);
+  g_object_unref (app);
 
 }
 
diff --git a/src/cocoa_menu.c b/src/cocoa_menu.c
index e07926e..01b71d6 100644
--- a/src/cocoa_menu.c
+++ b/src/cocoa_menu.c
@@ -43,7 +43,7 @@ cocoa_menu_free (gpointer *ptr)
 
 void
 cocoa_menu_connect (GtkWidget *menu,
-                   NSMenu*    cocoa_menu)
+                    NSMenu*    cocoa_menu)
 {
   [cocoa_menu retain];
 
@@ -51,6 +51,6 @@ cocoa_menu_connect (GtkWidget *menu,
     cocoa_menu_quark = g_quark_from_static_string ("NSMenu");
 
   g_object_set_qdata_full (G_OBJECT (menu), cocoa_menu_quark,
-                          cocoa_menu,
-                          (GDestroyNotify) cocoa_menu_free);
+                           cocoa_menu,
+                           (GDestroyNotify) cocoa_menu_free);
 }
diff --git a/src/cocoa_menu_item.c b/src/cocoa_menu_item.c
index 3cd50ea..13be754 100644
--- a/src/cocoa_menu_item.c
+++ b/src/cocoa_menu_item.c
@@ -56,8 +56,8 @@ static GQuark cocoa_menu_item_quark = 0;
 
 static gboolean
 accel_find_func (GtkAccelKey *key,
-                GClosure    *closure,
-                gpointer     data)
+                 GClosure    *closure,
+                 gpointer     data)
 {
   return (GClosure *) data == closure;
 }
@@ -65,10 +65,10 @@ accel_find_func (GtkAccelKey *key,
 static GClosure *
 _gtk_accel_label_get_closure (GtkAccelLabel *label)
 {
-  g_return_val_if_fail(GTK_IS_ACCEL_LABEL(label), NULL);
+  g_return_val_if_fail (GTK_IS_ACCEL_LABEL (label), NULL);
 
   GClosure *closure = NULL;
-  g_object_get(G_OBJECT(label), "accel-closure", &closure, NULL);
+  g_object_get (G_OBJECT (label), "accel-closure", &closure, NULL);
   return closure;
 }
 
@@ -83,54 +83,55 @@ cocoa_menu_item_free (gpointer *ptr)
 _GNSMenuItem *
 cocoa_menu_item_get (GtkWidget *widget)
 {
-  return (_GNSMenuItem*) g_object_get_qdata (G_OBJECT (widget), cocoa_menu_item_quark);
+  return (_GNSMenuItem*) g_object_get_qdata (G_OBJECT (widget),
+                                            cocoa_menu_item_quark);
 }
 
 static void
 cocoa_menu_item_update_state (_GNSMenuItem* cocoa_item,
-                             GtkWidget      *widget)
+                              GtkWidget      *widget)
 {
   gboolean sensitive;
   gboolean visible;
 
   g_object_get (widget,
-               "sensitive", &sensitive,
-               "visible",   &visible,
-               NULL);
+                "sensitive", &sensitive,
+                "visible",   &visible,
+                NULL);
 
   if (!sensitive)
-    [cocoa_item setEnabled:NO];
+    [cocoa_item setEnabled: NO];
   else
-    [cocoa_item setEnabled:YES];
+    [cocoa_item setEnabled: YES];
 
   if (!visible)
-    [cocoa_item setHidden:YES];
+    [cocoa_item setHidden: YES];
   else
-    [cocoa_item setHidden:NO];
+    [cocoa_item setHidden: NO];
 }
 
 static void
 cocoa_menu_item_update_checked (_GNSMenuItem *cocoa_item,
-                              GtkWidget  *widget)
+                                GtkWidget  *widget)
 {
   gboolean active, inconsistent;
 
   g_object_get (widget,
-               "active", &active,
-               "inconsistent", &inconsistent,
-               NULL);
+                "active", &active,
+                "inconsistent", &inconsistent,
+                NULL);
 
   if (inconsistent)
-    [cocoa_item setState:NSMixedState];
+    [cocoa_item setState: NSMixedState];
   else if (active)
-    [cocoa_item setState:NSOnState];
+    [cocoa_item setState: NSOnState];
   else
-    [cocoa_item setState:NSOffState];
+    [cocoa_item setState: NSOffState];
 }
 
 static void
 cocoa_menu_item_update_submenu (_GNSMenuItem *cocoa_item,
-                               GtkWidget      *widget)
+                                GtkWidget      *widget)
 {
   GtkWidget *submenu;
 
@@ -139,49 +140,52 @@ cocoa_menu_item_update_submenu (_GNSMenuItem *cocoa_item,
 
   submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
 
-  if (!submenu) {
-    if ([cocoa_item hasSubmenu])
-    /*If the cocoa_item has a submenu but the menu_item doesn't,
-      lose the cocoa_item's submenu */
-      [cocoa_item setSubmenu: nil];
-    return;
-  }
+  if (!submenu)
+    {
+      if ([cocoa_item hasSubmenu])
+        /*If the cocoa_item has a submenu but the menu_item doesn't,
+          lose the cocoa_item's submenu */
+       [cocoa_item setSubmenu: nil];
+      return;
+    }
   GtkWidget* label = NULL;
-  NSMenu* cocoa_submenu = cocoa_menu_get(submenu);
+  NSMenu* cocoa_submenu = cocoa_menu_get (submenu);
 
   if (cocoa_submenu != nil)
     if ([cocoa_item submenu] != cocoa_submenu)
       //covers no submenu or wrong submenu on cocoa_item)
-      [cocoa_item setSubmenu:cocoa_submenu];
+      [cocoa_item setSubmenu: cocoa_submenu];
     else ;
   //Nothing required -- the submenus are already set up correctly
-  else if ([cocoa_item hasSubmenu]) {
-    cocoa_submenu = [cocoa_item submenu];
-    cocoa_menu_connect (submenu, cocoa_submenu);
-  }
-  else { //no submenu anywhere, so create one
-    const gchar *text = get_menu_label_text (widget, &label);
-    NSString *title = [NSString stringWithUTF8String: text ? text : ""];
+  else if ([cocoa_item hasSubmenu])
+    {
+      cocoa_submenu = [cocoa_item submenu];
+      cocoa_menu_connect (submenu, cocoa_submenu);
+    }
+  else   //no submenu anywhere, so create one
+    {
+      const gchar *text = get_menu_label_text (widget, &label);
+      NSString *title = [NSString stringWithUTF8String: text ? text : ""];
 
-    cocoa_submenu = [[[NSMenu alloc] initWithTitle: title] autorelease];
+      cocoa_submenu = [[[NSMenu alloc] initWithTitle: title] autorelease];
 
-    [cocoa_submenu setAutoenablesItems:NO];
-    cocoa_menu_connect (submenu, cocoa_submenu);
+      [cocoa_submenu setAutoenablesItems: NO];
+      cocoa_menu_connect (submenu, cocoa_submenu);
 
-    /* connect the new nsmenu to the passed-in item (which lives in
-       the parent nsmenu)
-       (Note: this will release any pre-existing version of this submenu)
-    */
-    [ cocoa_item setSubmenu:cocoa_submenu];
-  }
+      /* connect the new nsmenu to the passed-in item (which lives in
+         the parent nsmenu)
+         (Note: this will release any pre-existing version of this submenu)
+      */
+      [ cocoa_item setSubmenu: cocoa_submenu];
+    }
   /* and push the GTK menu into the submenu */
   cocoa_menu_item_add_submenu (GTK_MENU_SHELL (submenu), cocoa_submenu,
-                              FALSE, FALSE);
+                               FALSE, FALSE);
 }
 
 static void
 cocoa_menu_item_update_label (_GNSMenuItem *cocoa_item,
-                             GtkWidget      *widget)
+                              GtkWidget      *widget)
 {
   g_return_if_fail (cocoa_item != NULL);
   g_return_if_fail (widget != NULL);
@@ -195,7 +199,7 @@ cocoa_menu_item_update_label (_GNSMenuItem *cocoa_item,
 
 static void
 cocoa_menu_item_update_accelerator (_GNSMenuItem *cocoa_item,
-                                   GtkWidget *widget)
+                                    GtkWidget *widget)
 {
   GtkWidget *label;
 
@@ -214,107 +218,121 @@ cocoa_menu_item_update_accelerator (_GNSMenuItem *cocoa_item,
   if (label == NULL) return;
 
   GClosure *closure = NULL;
-  g_object_get(label, "accel-closure", &closure, NULL);
+  g_object_get (label, "accel-closure", &closure, NULL);
   if (GTK_IS_ACCEL_LABEL (label) && closure)
     {
       GtkAccelKey *key;
 
-      key = gtk_accel_group_find (gtk_accel_group_from_accel_closure(closure),
-                                 accel_find_func,
-                                 closure);
+      key = gtk_accel_group_find (gtk_accel_group_from_accel_closure (closure),
+                                  accel_find_func,
+                                  closure);
 
       if (key            &&
-         key->accel_key &&
-         key->accel_flags & GTK_ACCEL_VISIBLE)
-       {
-         guint modifiers = 0;
-         const gchar* str = NULL;
-         guint actual_key = key->accel_key;
-
-         if (keyval_is_keypad (actual_key)) {
-           if ((actual_key = keyval_keypad_nonkeypad_equivalent (actual_key)) == GDK_VoidSymbol) {
-             /* GDK_KP_Separator */
-             [cocoa_item setKeyEquivalent:@""];
-             return;
-           }
-           modifiers |= NSNumericPadKeyMask;
-         }
-
-         /* if we somehow got here with GDK_A ... GDK_Z rather than GDK_a ... GDK_z, then take note
-            of that and make sure we use a shift modifier.
-         */
-
-         if (keyval_is_uppercase (actual_key)) {
-           modifiers |= NSShiftKeyMask;
-         }
-
-         str = gdk_quartz_keyval_to_string (actual_key);
-         if (str) {
-           unichar ukey = str[0];
-           [cocoa_item setKeyEquivalent:[NSString stringWithCharacters:&ukey length:1]];
-         } else {
-           unichar ukey = gdk_quartz_keyval_to_ns_keyval (actual_key);
-           if (ukey != 0) {
-             [cocoa_item setKeyEquivalent:[NSString stringWithCharacters:&ukey length:1]];
-           } else {
-             /* cannot map this key to Cocoa key equivalent */
-             [cocoa_item setKeyEquivalent:@""];
-             return;
-           }
-         }
-
-         if (key->accel_mods || modifiers)
-           {
-             if (key->accel_mods & GDK_SHIFT_MASK) {
-               modifiers |= NSShiftKeyMask;
-             }
-
-             if (key->accel_mods & GDK_CONTROL_MASK) {
-               modifiers |= NSControlKeyMask;
-             }
-
-             /* gdk/quartz maps Alt/Option to Mod5 */
-             if (key->accel_mods & (GDK_MOD1_MASK)) {
-               modifiers |= NSAlternateKeyMask;
-             }
-
-             /* gdk/quartz maps Command to MOD1 */
-             if (key->accel_mods & GDK_META_MASK) {
-               modifiers |= NSCommandKeyMask;
-             }
-
-           }
-
-         [cocoa_item setKeyEquivalentModifierMask:modifiers];
-         return;
-       }
+          key->accel_key &&
+          key->accel_flags & GTK_ACCEL_VISIBLE)
+        {
+          guint modifiers = 0;
+          const gchar* str = NULL;
+          guint actual_key = key->accel_key;
+
+          if (keyval_is_keypad (actual_key))
+            {
+             actual_key = keyval_keypad_nonkeypad_equivalent (actual_key)
+              if (actual_key == GDK_VoidSymbol)
+                {
+                  /* GDK_KP_Separator */
+                 [cocoa_item setKeyEquivalent: @""];
+                  return;
+                }
+              modifiers |= NSNumericPadKeyMask;
+            }
+
+          /* if we somehow got here with GDK_A ... GDK_Z rather than GDK_a ... GDK_z, then take note
+             of that and make sure we use a shift modifier.
+          */
+
+          if (keyval_is_uppercase (actual_key))
+            {
+              modifiers |= NSShiftKeyMask;
+            }
+
+          str = gdk_quartz_keyval_to_string (actual_key);
+          if (str)
+            {
+              unichar ukey = str[0];
+             [cocoa_item setKeyEquivalent: [NSString stringWithCharacters: &ukey length: 1]];
+            }
+          else
+            {
+              unichar ukey = gdk_quartz_keyval_to_ns_keyval (actual_key);
+              if (ukey != 0)
+                {
+                 [cocoa_item setKeyEquivalent: [NSString stringWithCharacters: &ukey length: 1]];
+                }
+              else
+                {
+                  /* cannot map this key to Cocoa key equivalent */
+                 [cocoa_item setKeyEquivalent: @""];
+                  return;
+                }
+            }
+
+          if (key->accel_mods || modifiers)
+            {
+              if (key->accel_mods & GDK_SHIFT_MASK)
+                {
+                  modifiers |= NSShiftKeyMask;
+                }
+
+              if (key->accel_mods & GDK_CONTROL_MASK)
+                {
+                  modifiers |= NSControlKeyMask;
+                }
+
+              /* gdk/quartz maps Alt/Option to Mod5 */
+              if (key->accel_mods & (GDK_MOD1_MASK))
+                {
+                  modifiers |= NSAlternateKeyMask;
+                }
+
+              /* gdk/quartz maps Command to MOD1 */
+              if (key->accel_mods & GDK_META_MASK)
+                {
+                  modifiers |= NSCommandKeyMask;
+                }
+
+            }
+
+         [cocoa_item setKeyEquivalentModifierMask: modifiers];
+          return;
+        }
     }
 
   /*  otherwise, clear the menu shortcut  */
-  [cocoa_item setKeyEquivalent:@""];
+  [cocoa_item setKeyEquivalent: @""];
 }
 
 static void
 cocoa_menu_item_accel_changed (GtkAccelGroup   *accel_group,
-                              guint            keyval,
-                              GdkModifierType  modifier,
-                              GClosure        *accel_closure,
-                              GtkWidget       *widget)
+                               guint            keyval,
+                               GdkModifierType  modifier,
+                               GClosure        *accel_closure,
+                               GtkWidget       *widget)
 {
   _GNSMenuItem *cocoa_item = cocoa_menu_item_get (widget);
   GtkWidget      *label;
 
   get_menu_label_text (widget, &label);
-  if (gtk_accel_group_from_accel_closure(accel_closure) != accel_group)
-      return;
+  if (gtk_accel_group_from_accel_closure (accel_closure) != accel_group)
+    return;
   if (GTK_IS_ACCEL_LABEL (label) &&
-      _gtk_accel_label_get_closure((GtkAccelLabel *) label) == accel_closure)
+      _gtk_accel_label_get_closure ((GtkAccelLabel *) label) == accel_closure)
     cocoa_menu_item_update_accelerator (cocoa_item, widget);
 }
 
 static void
 cocoa_menu_item_update_accel_closure (_GNSMenuItem *cocoa_item,
-                                     GtkWidget      *widget)
+                                      GtkWidget      *widget)
 {
   GtkAccelGroup *group;
   GtkWidget     *label;
@@ -326,16 +344,17 @@ cocoa_menu_item_update_accel_closure (_GNSMenuItem *cocoa_item,
       group = gtk_accel_group_from_accel_closure (cocoa_item->accel_closure);
 
       g_signal_handlers_disconnect_by_func (group,
-                                           (void*) cocoa_menu_item_accel_changed,
-                                           widget);
+                                            (void*) cocoa_menu_item_accel_changed,
+                                            widget);
 
       g_closure_unref (cocoa_item->accel_closure);
       cocoa_item->accel_closure = NULL;
     }
 
-  if (GTK_IS_ACCEL_LABEL (label)) {
-       cocoa_item->accel_closure = _gtk_accel_label_get_closure((GtkAccelLabel *) label);
-  }
+  if (GTK_IS_ACCEL_LABEL (label))
+    {
+      cocoa_item->accel_closure = _gtk_accel_label_get_closure ((GtkAccelLabel *) label);
+    }
 
   if (cocoa_item->accel_closure)
     {
@@ -344,8 +363,8 @@ cocoa_menu_item_update_accel_closure (_GNSMenuItem *cocoa_item,
       group = gtk_accel_group_from_accel_closure (cocoa_item->accel_closure);
 
       g_signal_connect_object (group, "accel-changed",
-                              G_CALLBACK (cocoa_menu_item_accel_changed),
-                              widget, (GConnectFlags) 0);
+                               G_CALLBACK (cocoa_menu_item_accel_changed),
+                               widget, (GConnectFlags) 0);
     }
 
   cocoa_menu_item_update_accelerator (cocoa_item, widget);
@@ -353,27 +372,27 @@ cocoa_menu_item_update_accel_closure (_GNSMenuItem *cocoa_item,
 
 static void
 cocoa_menu_item_notify_label (GObject    *object,
-                             GParamSpec *pspec,
-                             gpointer    data)
+                              GParamSpec *pspec,
+                              gpointer    data)
 {
   _GNSMenuItem *cocoa_item = cocoa_menu_item_get (GTK_WIDGET (object));
 
   if (!strcmp (pspec->name, "label"))
     {
       cocoa_menu_item_update_label (cocoa_item,
-                                   GTK_WIDGET (object));
+                                    GTK_WIDGET (object));
     }
   else if (!strcmp (pspec->name, "accel-closure"))
     {
       cocoa_menu_item_update_accel_closure (cocoa_item,
-                                           GTK_WIDGET (object));
+                                            GTK_WIDGET (object));
     }
 }
 
 static void
 cocoa_menu_item_notify (GObject        *object,
-                       GParamSpec     *pspec,
-                       _GNSMenuItem *cocoa_item)
+                        GParamSpec     *pspec,
+                        _GNSMenuItem *cocoa_item)
 {
   if (!strcmp (pspec->name, "sensitive") ||
       !strcmp (pspec->name, "visible"))
@@ -381,7 +400,7 @@ cocoa_menu_item_notify (GObject        *object,
       cocoa_menu_item_update_state (cocoa_item, GTK_WIDGET (object));
     }
   else if (!strcmp (pspec->name, "active") ||
-          !strcmp (pspec->name, "inconsistent"))
+           !strcmp (pspec->name, "inconsistent"))
     {
       cocoa_menu_item_update_checked (cocoa_item, GTK_WIDGET (object));
     }
@@ -393,13 +412,13 @@ cocoa_menu_item_notify (GObject        *object,
 
 static void
 cocoa_menu_item_connect (GtkWidget*   menu_item,
-                        _GNSMenuItem* cocoa_item,
-                        GtkWidget     *label)
+                         _GNSMenuItem* cocoa_item,
+                         GtkWidget     *label)
 {
   _GNSMenuItem* old_item = cocoa_menu_item_get (menu_item);
 
   if (old_item == cocoa_item)
-      return;
+    return;
 
   [cocoa_item retain];
 
@@ -407,28 +426,29 @@ cocoa_menu_item_connect (GtkWidget*   menu_item,
     cocoa_menu_item_quark = g_quark_from_static_string ("_GNSMenuItem");
 
   g_object_set_qdata_full (G_OBJECT (menu_item), cocoa_menu_item_quark,
-                          cocoa_item,
-                          (GDestroyNotify) cocoa_menu_item_free);
+                           cocoa_item,
+                           (GDestroyNotify) cocoa_menu_item_free);
 
-  if (old_item) {
+  if (old_item)
+    {
       GSignalMatchType mask = G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA;
-      guint notify_sig = g_signal_lookup("notify", GTK_TYPE_MENU_ITEM);
-      if (! g_signal_handlers_disconnect_matched(G_OBJECT(menu_item),
-                                                mask, notify_sig,
-                                                (GQuark)0, NULL, NULL,
-                                                old_item))
-         g_print ("Failed to disconnect old notify signal for %s\\n",
-                  gtk_widget_get_name(menu_item));
+      guint notify_sig = g_signal_lookup ("notify", GTK_TYPE_MENU_ITEM);
+      if (! g_signal_handlers_disconnect_matched (G_OBJECT (menu_item),
+          mask, notify_sig,
+          (GQuark)0, NULL, NULL,
+          old_item))
+        g_print ("Failed to disconnect old notify signal for %s\\n",
+                 gtk_widget_get_name (menu_item));
       [old_item release];
-  }
+    }
   g_signal_connect (menu_item, "notify",
-                   G_CALLBACK (cocoa_menu_item_notify),
-                   cocoa_item);
+                    G_CALLBACK (cocoa_menu_item_notify),
+                    cocoa_item);
 
   if (label)
-      g_signal_connect_swapped (label, "notify::label",
-                               G_CALLBACK (cocoa_menu_item_notify_label),
-                               menu_item);
+    g_signal_connect_swapped (label, "notify::label",
+                              G_CALLBACK (cocoa_menu_item_notify_label),
+                              menu_item);
 }
 
 static void
@@ -473,25 +493,25 @@ cocoa_menu_item_add_item_image (_GNSMenuItem* cocoa_item, GtkWidget* menu_item)
     {
       GtkImage *menu_image = menu_widget;
       switch (gtk_image_get_storage_type (menu_image))
-       {
-       case GTK_IMAGE_PIXBUF:
-         pixbuf = gtk_image_get_pixbuf (menu_image);
-         image = nsimage_from_pixbuf (pixbuf);
-         break;
-       case GTK_IMAGE_STOCK:
-         {
-           DEBUG("Menu image is GTK_IMAGE_STOCK\n");
-           gchar *stock_id;
-           GtkIconSize size;
-           gtk_image_get_stock(menu_image, &stock_id, &size);
-           pixbuf = gtk_widget_render_icon (menu_image, stock_id, size, "");
-           image = nsimage_from_pixbuf (pixbuf);
-           g_object_unref (pixbuf);
-           break;
-         }
-       default:
-         return;
-       }
+        {
+        case GTK_IMAGE_PIXBUF:
+          pixbuf = gtk_image_get_pixbuf (menu_image);
+          image = nsimage_from_pixbuf (pixbuf);
+          break;
+        case GTK_IMAGE_STOCK:
+        {
+          DEBUG ("Menu image is GTK_IMAGE_STOCK\n");
+          gchar *stock_id;
+          GtkIconSize size;
+          gtk_image_get_stock (menu_image, &stock_id, &size);
+          pixbuf = gtk_widget_render_icon (menu_image, stock_id, size, "");
+          image = nsimage_from_pixbuf (pixbuf);
+          g_object_unref (pixbuf);
+          break;
+        }
+        default:
+          return;
+        }
     }
   if (image)
     [cocoa_item setImage: image];
@@ -508,9 +528,9 @@ cocoa_menu_item_add_item (NSMenu* cocoa_menu, GtkWidget* menu_item, int index)
   _GNSMenuItem *cocoa_item;
 
   DEBUG ("add %s to menu %s separator ? %d\n",
-        get_menu_label_text (menu_item, NULL),
-        [[cocoa_menu title] cStringUsingEncoding:NSUTF8StringEncoding],
-        GTK_IS_SEPARATOR_MENU_ITEM(menu_item));
+         get_menu_label_text (menu_item, NULL),
+       [[cocoa_menu title] cStringUsingEncoding: NSUTF8StringEncoding],
+         GTK_IS_SEPARATOR_MENU_ITEM (menu_item));
 
   cocoa_item = cocoa_menu_item_get (menu_item);
 
@@ -530,16 +550,16 @@ cocoa_menu_item_add_item (NSMenu* cocoa_menu, GtkWidget* menu_item, int index)
   else
     {
       const gchar* text = get_menu_label_text (menu_item, &label);
-      NSString *title = [NSString stringWithUTF8String:(text ? text : @"")];
+      NSString *title = [NSString stringWithUTF8String: (text ? text : @"")];
 
       GClosure *menu_action =
-       g_cclosure_new_object_swap(G_CALLBACK(gtk_menu_item_activate),
-                                  G_OBJECT(menu_item));
-      g_closure_set_marshal(menu_action, g_cclosure_marshal_VOID__VOID);
+        g_cclosure_new_object_swap (G_CALLBACK (gtk_menu_item_activate),
+                                    G_OBJECT (menu_item));
+      g_closure_set_marshal (menu_action, g_cclosure_marshal_VOID__VOID);
 
       cocoa_item = [[_GNSMenuItem alloc]
                    initWithTitle: title
-                   aGClosure:menu_action andPointer:NULL];
+                   aGClosure: menu_action andPointer: NULL];
 
       DEBUG ("\tan item\n");
     }
@@ -547,27 +567,27 @@ cocoa_menu_item_add_item (NSMenu* cocoa_menu, GtkWidget* menu_item, int index)
 
 #ifdef USE_MENU_IMAGES
   if (GTK_IS_IMAGE_MENU_ITEM (menu_item))
-    cocoa_menu_item_add_item_image(cocoa_item, menu_item);
+    cocoa_menu_item_add_item_image (cocoa_item, menu_item);
 #endif
 
-  [cocoa_item setEnabled:YES];
+[cocoa_item setEnabled: YES];
 
   /* connect GtkMenuItem and _GNSMenuItem so that we can notice changes
    * to accel/label/submenu etc. */
 
   if (index >= 0 && index < [cocoa_menu numberOfItems])
-    [ cocoa_menu insertItem:cocoa_item atIndex:index];
+    [ cocoa_menu insertItem: cocoa_item atIndex: index];
   else
-    [ cocoa_menu addItem:cocoa_item];
+    [ cocoa_menu addItem: cocoa_item];
 
-  cocoa_menu_item_sync(menu_item);
+  cocoa_menu_item_sync (menu_item);
 }
 
 void
 cocoa_menu_item_add_submenu (GtkMenuShell *menu_shell,
-                          NSMenu*       cocoa_menu,
-                          gboolean      toplevel,
-                          gboolean      debug)
+                             NSMenu*       cocoa_menu,
+                             gboolean      toplevel,
+                             gboolean      debug)
 {
   GList         *children;
   GList         *l;
@@ -575,66 +595,72 @@ cocoa_menu_item_add_submenu (GtkMenuShell *menu_shell,
 
   count = [cocoa_menu numberOfItems];
   /* First go through the cocoa menu and mark all of the items unused. */
-  for (index = 0; index < count; index++) {
-    _GNSMenuItem *indexedItem = (_GNSMenuItem*)[cocoa_menu itemAtIndex: index];
-    if (GTK_IS_MENU_BAR(menu_shell) &&
-       (indexedItem == [(_GNSMenuBar*)cocoa_menu windowsMenu] ||
-        indexedItem == [(_GNSMenuBar*)cocoa_menu helpMenu] ||
-        indexedItem == [(_GNSMenuBar*)cocoa_menu appMenu]))
-      continue;
-    if ([[cocoa_menu itemAtIndex: index] respondsToSelector: @selector(mark)])
-      [(_GNSMenuItem*)[cocoa_menu itemAtIndex: index] mark];
-  }
+  for (index = 0; index < count; index++)
+    {
+      _GNSMenuItem *indexedItem = (_GNSMenuItem*)[cocoa_menu itemAtIndex: index];
+      if (GTK_IS_MENU_BAR (menu_shell) &&
+          (indexedItem == [ (_GNSMenuBar*)cocoa_menu windowsMenu] ||
+           indexedItem == [ (_GNSMenuBar*)cocoa_menu helpMenu] ||
+           indexedItem == [ (_GNSMenuBar*)cocoa_menu appMenu]))
+        continue;
+      if ([[cocoa_menu itemAtIndex: index] respondsToSelector: @selector (mark)])
+       [ (_GNSMenuItem*)[cocoa_menu itemAtIndex: index] mark];
+    }
   index = toplevel ? 1 : 0; //Skip the 0th menu item on the menu bar
   /* Now iterate over the menu shell and check it against the cocoa menu */
   children = gtk_container_get_children (GTK_CONTAINER (menu_shell));
-  for (l = children; l; l = l->next) {
-    GtkWidget   *menu_item = (GtkWidget*) l->data;
-    _GNSMenuItem *cocoa_item =  cocoa_menu_item_get (menu_item);
-    if ([cocoa_item menu] && [cocoa_item menu] != cocoa_menu)
-      /* This item has been moved to another menu; skip it */
-      continue;
-    if ([cocoa_item respondsToSelector: @selector(isMarked)] &&
-       [cocoa_menu numberOfItems] > index &&
-       [cocoa_menu itemAtIndex:index] == cocoa_item) {
-      /* This item is where it belongs, so unmark and update it */
-      [cocoa_item unmark];
-      cocoa_menu_item_sync(menu_item);
-      ++index;
-      continue;
-    }
-    if (cocoa_item && (loc = [cocoa_menu indexOfItem: cocoa_item]) > -1) {
-      /*It's in there, just in the wrong place. Put it where it goes
-       and update it*/
-      [cocoa_item retain];
-      [cocoa_menu removeItem: cocoa_item];
-      [cocoa_menu insertItem: cocoa_item atIndex: index++];
-      if ([cocoa_item respondsToSelector: @selector(isMarked)])
-       [cocoa_item unmark];
-      [cocoa_item release];
-      cocoa_menu_item_sync(menu_item);
-      continue;
+  for (l = children; l; l = l->next)
+    {
+      GtkWidget   *menu_item = (GtkWidget*) l->data;
+      _GNSMenuItem *cocoa_item =  cocoa_menu_item_get (menu_item);
+      if ([cocoa_item menu] && [cocoa_item menu] != cocoa_menu)
+        /* This item has been moved to another menu; skip it */
+        continue;
+      if ([cocoa_item respondsToSelector: @selector (isMarked)] &&
+         [cocoa_menu numberOfItems] > index &&
+         [cocoa_menu itemAtIndex: index] == cocoa_item)
+        {
+          /* This item is where it belongs, so unmark and update it */
+          [cocoa_item unmark];
+          cocoa_menu_item_sync (menu_item);
+          ++index;
+          continue;
+        }
+      if (cocoa_item && (loc = [cocoa_menu indexOfItem: cocoa_item]) > -1)
+        {
+          /*It's in there, just in the wrong place. Put it where it goes
+          and update it*/
+          [cocoa_item retain];
+         [cocoa_menu removeItem: cocoa_item];
+         [cocoa_menu insertItem: cocoa_item atIndex: index++];
+         if ([cocoa_item respondsToSelector: @selector (isMarked)])
+            [cocoa_item unmark];
+          [cocoa_item release];
+          cocoa_menu_item_sync (menu_item);
+          continue;
+        }
+      if (GTK_IS_SEPARATOR_MENU_ITEM (menu_item) &&
+         GTK_IS_MENU_BAR (menu_shell))
+        /* Don't want separators on the menubar */
+        continue;
+
+      if (GTK_IS_TEAROFF_MENU_ITEM (menu_item))
+        /*Don't want tearoff items at all */
+        continue;
+
+      if (g_object_get_data (G_OBJECT (menu_item), "gtk-empty-menu-item"))
+        /* Nor blank items. */
+        continue;
+      /*OK, this must be a new one. Add it. */
+      cocoa_menu_item_add_item (cocoa_menu, menu_item, index++);
     }
-    if (GTK_IS_SEPARATOR_MENU_ITEM (menu_item) && GTK_IS_MENU_BAR(menu_shell))
-      /* Don't want separators on the menubar */
-      continue;
-
-    if (GTK_IS_TEAROFF_MENU_ITEM (menu_item))
-      /*Don't want tearoff items at all */
-      continue;
-
-    if (g_object_get_data (G_OBJECT (menu_item), "gtk-empty-menu-item"))
-      /* Nor blank items. */
-      continue;
-    /*OK, this must be a new one. Add it. */
-    cocoa_menu_item_add_item (cocoa_menu, menu_item, index++);
-  }
   /* Iterate over the cocoa menu again removing anything that's still marked */
-  for (index = 0; index < [cocoa_menu numberOfItems]; index++) {
-    _GNSMenuItem *item = (_GNSMenuItem*)[cocoa_menu itemAtIndex: index];
-    if (([item respondsToSelector: @selector(isMarked)]) && [item isMarked])
-      [cocoa_menu removeItem: item];
-  }
+  for (index = 0; index < [cocoa_menu numberOfItems]; index++)
+    {
+      _GNSMenuItem *item = (_GNSMenuItem*)[cocoa_menu itemAtIndex: index];
+      if (([item respondsToSelector: @selector (isMarked)]) && [item isMarked])
+       [cocoa_menu removeItem: item];
+    }
 
   g_list_free (children);
 }
@@ -646,134 +672,135 @@ cocoa_menu_item_add_submenu (GtkMenuShell *menu_shell,
 static guint
 gdk_quartz_keyval_to_ns_keyval (guint keyval)
 {
-  switch (keyval) {
-  case GDK_BackSpace:
-    return NSBackspaceCharacter;
-  case GDK_Delete:
-    return NSDeleteFunctionKey;
-  case GDK_Pause:
-    return NSPauseFunctionKey;
-  case GDK_Scroll_Lock:
-    return NSScrollLockFunctionKey;
-  case GDK_Sys_Req:
-    return NSSysReqFunctionKey;
-  case GDK_Home:
-    return NSHomeFunctionKey;
-  case GDK_Left:
-  case GDK_leftarrow:
-    return NSLeftArrowFunctionKey;
-  case GDK_Up:
-  case GDK_uparrow:
-    return NSUpArrowFunctionKey;
-  case GDK_Right:
-  case GDK_rightarrow:
-    return NSRightArrowFunctionKey;
-  case GDK_Down:
-  case GDK_downarrow:
-    return NSDownArrowFunctionKey;
-  case GDK_Page_Up:
-    return NSPageUpFunctionKey;
-  case GDK_Page_Down:
-    return NSPageDownFunctionKey;
-  case GDK_End:
-    return NSEndFunctionKey;
-  case GDK_Begin:
-    return NSBeginFunctionKey;
-  case GDK_Select:
-    return NSSelectFunctionKey;
-  case GDK_Print:
-    return NSPrintFunctionKey;
-  case GDK_Execute:
-    return NSExecuteFunctionKey;
-  case GDK_Insert:
-    return NSInsertFunctionKey;
-  case GDK_Undo:
-    return NSUndoFunctionKey;
-  case GDK_Redo:
-    return NSRedoFunctionKey;
-  case GDK_Menu:
-    return NSMenuFunctionKey;
-  case GDK_Find:
-    return NSFindFunctionKey;
-  case GDK_Help:
-    return NSHelpFunctionKey;
-  case GDK_Break:
-    return NSBreakFunctionKey;
-  case GDK_Mode_switch:
-    return NSModeSwitchFunctionKey;
-  case GDK_F1:
-    return NSF1FunctionKey;
-  case GDK_F2:
-    return NSF2FunctionKey;
-  case GDK_F3:
-    return NSF3FunctionKey;
-  case GDK_F4:
-    return NSF4FunctionKey;
-  case GDK_F5:
-    return NSF5FunctionKey;
-  case GDK_F6:
-    return NSF6FunctionKey;
-  case GDK_F7:
-    return NSF7FunctionKey;
-  case GDK_F8:
-    return NSF8FunctionKey;
-  case GDK_F9:
-    return NSF9FunctionKey;
-  case GDK_F10:
-    return NSF10FunctionKey;
-  case GDK_F11:
-    return NSF11FunctionKey;
-  case GDK_F12:
-    return NSF12FunctionKey;
-  case GDK_F13:
-    return NSF13FunctionKey;
-  case GDK_F14:
-    return NSF14FunctionKey;
-  case GDK_F15:
-    return NSF15FunctionKey;
-  case GDK_F16:
-    return NSF16FunctionKey;
-  case GDK_F17:
-    return NSF17FunctionKey;
-  case GDK_F18:
-    return NSF18FunctionKey;
-  case GDK_F19:
-    return NSF19FunctionKey;
-  case GDK_F20:
-    return NSF20FunctionKey;
-  case GDK_F21:
-    return NSF21FunctionKey;
-  case GDK_F22:
-    return NSF22FunctionKey;
-  case GDK_F23:
-    return NSF23FunctionKey;
-  case GDK_F24:
-    return NSF24FunctionKey;
-  case GDK_F25:
-    return NSF25FunctionKey;
-  case GDK_F26:
-    return NSF26FunctionKey;
-  case GDK_F27:
-    return NSF27FunctionKey;
-  case GDK_F28:
-    return NSF28FunctionKey;
-  case GDK_F29:
-    return NSF29FunctionKey;
-  case GDK_F30:
-    return NSF30FunctionKey;
-  case GDK_F31:
-    return NSF31FunctionKey;
-  case GDK_F32:
-    return NSF32FunctionKey;
-  case GDK_F33:
-    return NSF33FunctionKey;
-  case GDK_F34:
-    return NSF34FunctionKey;
-  case GDK_F35:
-    return NSF35FunctionKey;
-  default:
-    break;
-  }
+  switch (keyval)
+    {
+    case GDK_BackSpace:
+      return NSBackspaceCharacter;
+    case GDK_Delete:
+      return NSDeleteFunctionKey;
+    case GDK_Pause:
+      return NSPauseFunctionKey;
+    case GDK_Scroll_Lock:
+      return NSScrollLockFunctionKey;
+    case GDK_Sys_Req:
+      return NSSysReqFunctionKey;
+    case GDK_Home:
+      return NSHomeFunctionKey;
+    case GDK_Left:
+    case GDK_leftarrow:
+      return NSLeftArrowFunctionKey;
+    case GDK_Up:
+    case GDK_uparrow:
+      return NSUpArrowFunctionKey;
+    case GDK_Right:
+    case GDK_rightarrow:
+      return NSRightArrowFunctionKey;
+    case GDK_Down:
+    case GDK_downarrow:
+      return NSDownArrowFunctionKey;
+    case GDK_Page_Up:
+      return NSPageUpFunctionKey;
+    case GDK_Page_Down:
+      return NSPageDownFunctionKey;
+    case GDK_End:
+      return NSEndFunctionKey;
+    case GDK_Begin:
+      return NSBeginFunctionKey;
+    case GDK_Select:
+      return NSSelectFunctionKey;
+    case GDK_Print:
+      return NSPrintFunctionKey;
+    case GDK_Execute:
+      return NSExecuteFunctionKey;
+    case GDK_Insert:
+      return NSInsertFunctionKey;
+    case GDK_Undo:
+      return NSUndoFunctionKey;
+    case GDK_Redo:
+      return NSRedoFunctionKey;
+    case GDK_Menu:
+      return NSMenuFunctionKey;
+    case GDK_Find:
+      return NSFindFunctionKey;
+    case GDK_Help:
+      return NSHelpFunctionKey;
+    case GDK_Break:
+      return NSBreakFunctionKey;
+    case GDK_Mode_switch:
+      return NSModeSwitchFunctionKey;
+    case GDK_F1:
+      return NSF1FunctionKey;
+    case GDK_F2:
+      return NSF2FunctionKey;
+    case GDK_F3:
+      return NSF3FunctionKey;
+    case GDK_F4:
+      return NSF4FunctionKey;
+    case GDK_F5:
+      return NSF5FunctionKey;
+    case GDK_F6:
+      return NSF6FunctionKey;
+    case GDK_F7:
+      return NSF7FunctionKey;
+    case GDK_F8:
+      return NSF8FunctionKey;
+    case GDK_F9:
+      return NSF9FunctionKey;
+    case GDK_F10:
+      return NSF10FunctionKey;
+    case GDK_F11:
+      return NSF11FunctionKey;
+    case GDK_F12:
+      return NSF12FunctionKey;
+    case GDK_F13:
+      return NSF13FunctionKey;
+    case GDK_F14:
+      return NSF14FunctionKey;
+    case GDK_F15:
+      return NSF15FunctionKey;
+    case GDK_F16:
+      return NSF16FunctionKey;
+    case GDK_F17:
+      return NSF17FunctionKey;
+    case GDK_F18:
+      return NSF18FunctionKey;
+    case GDK_F19:
+      return NSF19FunctionKey;
+    case GDK_F20:
+      return NSF20FunctionKey;
+    case GDK_F21:
+      return NSF21FunctionKey;
+    case GDK_F22:
+      return NSF22FunctionKey;
+    case GDK_F23:
+      return NSF23FunctionKey;
+    case GDK_F24:
+      return NSF24FunctionKey;
+    case GDK_F25:
+      return NSF25FunctionKey;
+    case GDK_F26:
+      return NSF26FunctionKey;
+    case GDK_F27:
+      return NSF27FunctionKey;
+    case GDK_F28:
+      return NSF28FunctionKey;
+    case GDK_F29:
+      return NSF29FunctionKey;
+    case GDK_F30:
+      return NSF30FunctionKey;
+    case GDK_F31:
+      return NSF31FunctionKey;
+    case GDK_F32:
+      return NSF32FunctionKey;
+    case GDK_F33:
+      return NSF33FunctionKey;
+    case GDK_F34:
+      return NSF34FunctionKey;
+    case GDK_F35:
+      return NSF35FunctionKey;
+    default:
+      break;
+    }
 
   return 0;
 }
@@ -781,116 +808,118 @@ gdk_quartz_keyval_to_ns_keyval (guint keyval)
 static gboolean
 keyval_is_keypad (guint keyval)
 {
-  switch (keyval) {
-  case GDK_KP_F1:
-  case GDK_KP_F2:
-  case GDK_KP_F3:
-  case GDK_KP_F4:
-  case GDK_KP_Home:
-  case GDK_KP_Left:
-  case GDK_KP_Up:
-  case GDK_KP_Right:
-  case GDK_KP_Down:
-  case GDK_KP_Page_Up:
-  case GDK_KP_Page_Down:
-  case GDK_KP_End:
-  case GDK_KP_Begin:
-  case GDK_KP_Insert:
-  case GDK_KP_Delete:
-  case GDK_KP_Equal:
-  case GDK_KP_Multiply:
-  case GDK_KP_Add:
-  case GDK_KP_Separator:
-  case GDK_KP_Subtract:
-  case GDK_KP_Decimal:
-  case GDK_KP_Divide:
-  case GDK_KP_0:
-  case GDK_KP_1:
-  case GDK_KP_2:
-  case GDK_KP_3:
-  case GDK_KP_4:
-  case GDK_KP_5:
-  case GDK_KP_6:
-  case GDK_KP_7:
-  case GDK_KP_8:
-  case GDK_KP_9:
-    return TRUE;
-    break;
-  default:
-    break;
-  }
+  switch (keyval)
+    {
+    case GDK_KP_F1:
+    case GDK_KP_F2:
+    case GDK_KP_F3:
+    case GDK_KP_F4:
+    case GDK_KP_Home:
+    case GDK_KP_Left:
+    case GDK_KP_Up:
+    case GDK_KP_Right:
+    case GDK_KP_Down:
+    case GDK_KP_Page_Up:
+    case GDK_KP_Page_Down:
+    case GDK_KP_End:
+    case GDK_KP_Begin:
+    case GDK_KP_Insert:
+    case GDK_KP_Delete:
+    case GDK_KP_Equal:
+    case GDK_KP_Multiply:
+    case GDK_KP_Add:
+    case GDK_KP_Separator:
+    case GDK_KP_Subtract:
+    case GDK_KP_Decimal:
+    case GDK_KP_Divide:
+    case GDK_KP_0:
+    case GDK_KP_1:
+    case GDK_KP_2:
+    case GDK_KP_3:
+    case GDK_KP_4:
+    case GDK_KP_5:
+    case GDK_KP_6:
+    case GDK_KP_7:
+    case GDK_KP_8:
+    case GDK_KP_9:
+      return TRUE;
+      break;
+    default:
+      break;
+    }
   return FALSE;
 }
 
 static guint
 keyval_keypad_nonkeypad_equivalent (guint keyval)
 {
-  switch (keyval) {
-  case GDK_KP_F1:
-    return GDK_F1;
-  case GDK_KP_F2:
-    return GDK_F2;
-  case GDK_KP_F3:
-    return GDK_F3;
-  case GDK_KP_F4:
-    return GDK_F4;
-  case GDK_KP_Home:
-    return GDK_Home;
-  case GDK_KP_Left:
-    return GDK_Left;
-  case GDK_KP_Up:
-    return GDK_Up;
-  case GDK_KP_Right:
-    return GDK_Right;
-  case GDK_KP_Down:
-    return GDK_Down;
-  case GDK_KP_Page_Up:
-    return GDK_Page_Up;
-  case GDK_KP_Page_Down:
-    return GDK_Page_Down;
-  case GDK_KP_End:
-    return GDK_End;
-  case GDK_KP_Begin:
-    return GDK_Begin;
-  case GDK_KP_Insert:
-    return GDK_Insert;
-  case GDK_KP_Delete:
-    return GDK_Delete;
-  case GDK_KP_Equal:
-    return GDK_equal;
-  case GDK_KP_Multiply:
-    return GDK_asterisk;
-  case GDK_KP_Add:
-    return GDK_plus;
-  case GDK_KP_Subtract:
-    return GDK_minus;
-  case GDK_KP_Decimal:
-    return GDK_period;
-  case GDK_KP_Divide:
-    return GDK_slash;
-  case GDK_KP_0:
-    return GDK_0;
-  case GDK_KP_1:
-    return GDK_1;
-  case GDK_KP_2:
-    return GDK_2;
-  case GDK_KP_3:
-    return GDK_3;
-  case GDK_KP_4:
-    return GDK_4;
-  case GDK_KP_5:
-    return GDK_5;
-  case GDK_KP_6:
-    return GDK_6;
-  case GDK_KP_7:
-    return GDK_7;
-  case GDK_KP_8:
-    return GDK_8;
-  case GDK_KP_9:
-    return GDK_9;
-  default:
-    break;
-  }
+  switch (keyval)
+    {
+    case GDK_KP_F1:
+      return GDK_F1;
+    case GDK_KP_F2:
+      return GDK_F2;
+    case GDK_KP_F3:
+      return GDK_F3;
+    case GDK_KP_F4:
+      return GDK_F4;
+    case GDK_KP_Home:
+      return GDK_Home;
+    case GDK_KP_Left:
+      return GDK_Left;
+    case GDK_KP_Up:
+      return GDK_Up;
+    case GDK_KP_Right:
+      return GDK_Right;
+    case GDK_KP_Down:
+      return GDK_Down;
+    case GDK_KP_Page_Up:
+      return GDK_Page_Up;
+    case GDK_KP_Page_Down:
+      return GDK_Page_Down;
+    case GDK_KP_End:
+      return GDK_End;
+    case GDK_KP_Begin:
+      return GDK_Begin;
+    case GDK_KP_Insert:
+      return GDK_Insert;
+    case GDK_KP_Delete:
+      return GDK_Delete;
+    case GDK_KP_Equal:
+      return GDK_equal;
+    case GDK_KP_Multiply:
+      return GDK_asterisk;
+    case GDK_KP_Add:
+      return GDK_plus;
+    case GDK_KP_Subtract:
+      return GDK_minus;
+    case GDK_KP_Decimal:
+      return GDK_period;
+    case GDK_KP_Divide:
+      return GDK_slash;
+    case GDK_KP_0:
+      return GDK_0;
+    case GDK_KP_1:
+      return GDK_1;
+    case GDK_KP_2:
+      return GDK_2;
+    case GDK_KP_3:
+      return GDK_3;
+    case GDK_KP_4:
+      return GDK_4;
+    case GDK_KP_5:
+      return GDK_5;
+    case GDK_KP_6:
+      return GDK_6;
+    case GDK_KP_7:
+      return GDK_7;
+    case GDK_KP_8:
+      return GDK_8;
+    case GDK_KP_9:
+      return GDK_9;
+    default:
+      break;
+    }
 
   return GDK_VoidSymbol;
 }
@@ -898,209 +927,211 @@ keyval_keypad_nonkeypad_equivalent (guint keyval)
 static const gchar*
 gdk_quartz_keyval_to_string (guint keyval)
 {
-  switch (keyval) {
-  case GDK_space:
-    return " ";
-  case GDK_exclam:
-    return "!";
-  case GDK_quotedbl:
-    return "\"";
-  case GDK_numbersign:
-    return "#";
-  case GDK_dollar:
-    return "$";
-  case GDK_percent:
-    return "%";
-  case GDK_ampersand:
-    return "&";
-  case GDK_apostrophe:
-    return "'";
-  case GDK_parenleft:
-    return "(";
-  case GDK_parenright:
-    return ")";
-  case GDK_asterisk:
-    return "*";
-  case GDK_plus:
-    return "+";
-  case GDK_comma:
-    return ",";
-  case GDK_minus:
-    return "-";
-  case GDK_period:
-    return ".";
-  case GDK_slash:
-    return "/";
-  case GDK_0:
-    return "0";
-  case GDK_1:
-    return "1";
-  case GDK_2:
-    return "2";
-  case GDK_3:
-    return "3";
-  case GDK_4:
-    return "4";
-  case GDK_5:
-    return "5";
-  case GDK_6:
-    return "6";
-  case GDK_7:
-    return "7";
-  case GDK_8:
-    return "8";
-  case GDK_9:
-    return "9";
-  case GDK_colon:
-    return ":";
-  case GDK_semicolon:
-    return ";";
-  case GDK_less:
-    return "<";
-  case GDK_equal:
-    return "=";
-  case GDK_greater:
-    return ">";
-  case GDK_question:
-    return "?";
-  case GDK_at:
-    return "@";
-  case GDK_A:
-  case GDK_a:
-    return "a";
-  case GDK_B:
-  case GDK_b:
-    return "b";
-  case GDK_C:
-  case GDK_c:
-    return "c";
-  case GDK_D:
-  case GDK_d:
-    return "d";
-  case GDK_E:
-  case GDK_e:
-    return "e";
-  case GDK_F:
-  case GDK_f:
-    return "f";
-  case GDK_G:
-  case GDK_g:
-    return "g";
-  case GDK_H:
-  case GDK_h:
-    return "h";
-  case GDK_I:
-  case GDK_i:
-    return "i";
-  case GDK_J:
-  case GDK_j:
-    return "j";
-  case GDK_K:
-  case GDK_k:
-    return "k";
-  case GDK_L:
-  case GDK_l:
-    return "l";
-  case GDK_M:
-  case GDK_m:
-    return "m";
-  case GDK_N:
-  case GDK_n:
-    return "n";
-  case GDK_O:
-  case GDK_o:
-    return "o";
-  case GDK_P:
-  case GDK_p:
-    return "p";
-  case GDK_Q:
-  case GDK_q:
-    return "q";
-  case GDK_R:
-  case GDK_r:
-    return "r";
-  case GDK_S:
-  case GDK_s:
-    return "s";
-  case GDK_T:
-  case GDK_t:
-    return "t";
-  case GDK_U:
-  case GDK_u:
-    return "u";
-  case GDK_V:
-  case GDK_v:
-    return "v";
-  case GDK_W:
-  case GDK_w:
-    return "w";
-  case GDK_X:
-  case GDK_x:
-    return "x";
-  case GDK_Y:
-  case GDK_y:
-    return "y";
-  case GDK_Z:
-  case GDK_z:
-    return "z";
-  case GDK_bracketleft:
-    return "[";
-  case GDK_backslash:
-    return "\\";
-  case GDK_bracketright:
-    return "]";
-  case GDK_asciicircum:
-    return "^";
-  case GDK_underscore:
-    return "_";
-  case GDK_grave:
-    return "`";
-  case GDK_braceleft:
-    return "{";
-  case GDK_bar:
-    return "|";
-  case GDK_braceright:
-    return "}";
-  case GDK_asciitilde:
-    return "~";
-  default:
-    break;
-  }
+  switch (keyval)
+    {
+    case GDK_space:
+      return " ";
+    case GDK_exclam:
+      return "!";
+    case GDK_quotedbl:
+      return "\"";
+    case GDK_numbersign:
+      return "#";
+    case GDK_dollar:
+      return "$";
+    case GDK_percent:
+      return "%";
+    case GDK_ampersand:
+      return "&";
+    case GDK_apostrophe:
+      return "'";
+    case GDK_parenleft:
+      return "(";
+    case GDK_parenright:
+      return ")";
+    case GDK_asterisk:
+      return "*";
+    case GDK_plus:
+      return "+";
+    case GDK_comma:
+      return ",";
+    case GDK_minus:
+      return "-";
+    case GDK_period:
+      return ".";
+    case GDK_slash:
+      return "/";
+    case GDK_0:
+      return "0";
+    case GDK_1:
+      return "1";
+    case GDK_2:
+      return "2";
+    case GDK_3:
+      return "3";
+    case GDK_4:
+      return "4";
+    case GDK_5:
+      return "5";
+    case GDK_6:
+      return "6";
+    case GDK_7:
+      return "7";
+    case GDK_8:
+      return "8";
+    case GDK_9:
+      return "9";
+    case GDK_colon:
+      return ":";
+    case GDK_semicolon:
+      return ";";
+    case GDK_less:
+      return "<";
+    case GDK_equal:
+      return "=";
+    case GDK_greater:
+      return ">";
+    case GDK_question:
+      return "?";
+    case GDK_at:
+      return "@";
+    case GDK_A:
+    case GDK_a:
+      return "a";
+    case GDK_B:
+    case GDK_b:
+      return "b";
+    case GDK_C:
+    case GDK_c:
+      return "c";
+    case GDK_D:
+    case GDK_d:
+      return "d";
+    case GDK_E:
+    case GDK_e:
+      return "e";
+    case GDK_F:
+    case GDK_f:
+      return "f";
+    case GDK_G:
+    case GDK_g:
+      return "g";
+    case GDK_H:
+    case GDK_h:
+      return "h";
+    case GDK_I:
+    case GDK_i:
+      return "i";
+    case GDK_J:
+    case GDK_j:
+      return "j";
+    case GDK_K:
+    case GDK_k:
+      return "k";
+    case GDK_L:
+    case GDK_l:
+      return "l";
+    case GDK_M:
+    case GDK_m:
+      return "m";
+    case GDK_N:
+    case GDK_n:
+      return "n";
+    case GDK_O:
+    case GDK_o:
+      return "o";
+    case GDK_P:
+    case GDK_p:
+      return "p";
+    case GDK_Q:
+    case GDK_q:
+      return "q";
+    case GDK_R:
+    case GDK_r:
+      return "r";
+    case GDK_S:
+    case GDK_s:
+      return "s";
+    case GDK_T:
+    case GDK_t:
+      return "t";
+    case GDK_U:
+    case GDK_u:
+      return "u";
+    case GDK_V:
+    case GDK_v:
+      return "v";
+    case GDK_W:
+    case GDK_w:
+      return "w";
+    case GDK_X:
+    case GDK_x:
+      return "x";
+    case GDK_Y:
+    case GDK_y:
+      return "y";
+    case GDK_Z:
+    case GDK_z:
+      return "z";
+    case GDK_bracketleft:
+      return "[";
+    case GDK_backslash:
+      return "\\";
+    case GDK_bracketright:
+      return "]";
+    case GDK_asciicircum:
+      return "^";
+    case GDK_underscore:
+      return "_";
+    case GDK_grave:
+      return "`";
+    case GDK_braceleft:
+      return "{";
+    case GDK_bar:
+      return "|";
+    case GDK_braceright:
+      return "}";
+    case GDK_asciitilde:
+      return "~";
+    default:
+      break;
+    }
   return NULL;
 };
 static gboolean
 keyval_is_uppercase (guint keyval)
 {
-  switch (keyval) {
-  case GDK_A:
-  case GDK_B:
-  case GDK_C:
-  case GDK_D:
-  case GDK_E:
-  case GDK_F:
-  case GDK_G:
-  case GDK_H:
-  case GDK_I:
-  case GDK_J:
-  case GDK_K:
-  case GDK_L:
-  case GDK_M:
-  case GDK_N:
-  case GDK_O:
-  case GDK_P:
-  case GDK_Q:
-  case GDK_R:
-  case GDK_S:
-  case GDK_T:
-  case GDK_U:
-  case GDK_V:
-  case GDK_W:
-  case GDK_X:
-  case GDK_Y:
-  case GDK_Z:
-    return TRUE;
-  default:
-    return FALSE;
-  }
+  switch (keyval)
+    {
+    case GDK_A:
+    case GDK_B:
+    case GDK_C:
+    case GDK_D:
+    case GDK_E:
+    case GDK_F:
+    case GDK_G:
+    case GDK_H:
+    case GDK_I:
+    case GDK_J:
+    case GDK_K:
+    case GDK_L:
+    case GDK_M:
+    case GDK_N:
+    case GDK_O:
+    case GDK_P:
+    case GDK_Q:
+    case GDK_R:
+    case GDK_S:
+    case GDK_T:
+    case GDK_U:
+    case GDK_V:
+    case GDK_W:
+    case GDK_X:
+    case GDK_Y:
+    case GDK_Z:
+      return TRUE;
+    default:
+      return FALSE;
+    }
   return FALSE;
 }
diff --git a/src/getlabel.c b/src/getlabel.c
index 165f1d4..7f4cd45 100644
--- a/src/getlabel.c
+++ b/src/getlabel.c
@@ -1,4 +1,4 @@
-/* GTK+ Integration with platform-specific application-wide features 
+/* GTK+ Integration with platform-specific application-wide features
  * such as the OS X menubar and application delegate concepts.
  *
  * Copyright (C) 2009 Paul Davis
@@ -38,11 +38,11 @@ find_menu_label (GtkWidget *widget)
       children = gtk_container_get_children (GTK_CONTAINER (widget));
 
       for (l = children; l; l = l->next)
-       {
-         label = find_menu_label ((GtkWidget*) l->data);
-         if (label)
-           break;
-       }
+        {
+          label = find_menu_label ((GtkWidget*) l->data);
+          if (label)
+            break;
+        }
 
       g_list_free (children);
     }
@@ -52,7 +52,7 @@ find_menu_label (GtkWidget *widget)
 
 const gchar *
 get_menu_label_text (GtkWidget  *menu_item,
-                    GtkWidget **label)
+                     GtkWidget **label)
 {
   GtkWidget *my_label;
 
diff --git a/src/gtk-mac-bundle.c b/src/gtk-mac-bundle.c
index 12e984d..9fd77a5 100644
--- a/src/gtk-mac-bundle.c
+++ b/src/gtk-mac-bundle.c
@@ -30,8 +30,9 @@
 
 typedef struct GtkMacBundlePriv GtkMacBundlePriv;
 
-struct GtkMacBundlePriv {
-  CFBundleRef  cf_bundle; 
+struct GtkMacBundlePriv
+{
+  CFBundleRef  cf_bundle;
   gchar       *path;
   gchar       *id;
   gchar       *datadir;
@@ -43,8 +44,8 @@ struct GtkMacBundlePriv {
 static void   mac_bundle_finalize              (GObject      *object);
 static gchar *cf_string_to_utf8                (CFStringRef   str);
 static void   mac_bundle_set_environment_value (GtkMacBundle *bundle,
-                                                const gchar  *key,
-                                                const gchar  *value);
+    const gchar  *key,
+    const gchar  *value);
 
 static GtkMacBundle *global_bundle;
 
@@ -126,7 +127,7 @@ gtk_mac_bundle_init (GtkMacBundle *bundle)
 
           g_free (keys);
           g_free (values);
-        }      
+        }
     }
 }
 
@@ -168,8 +169,8 @@ cf_string_to_utf8 (CFStringRef str)
   CFIndex  len;
   gchar   *ret;
 
-  len = CFStringGetMaximumSizeForEncoding (CFStringGetLength (str), 
-                                           kCFStringEncodingUTF8) + 1;
+  len = CFStringGetMaximumSizeForEncoding (CFStringGetLength (str),
+        kCFStringEncodingUTF8) + 1;
 
   ret = g_malloc (len);
   ret[len] = '\0';
@@ -183,7 +184,7 @@ cf_string_to_utf8 (CFStringRef str)
 
 static void
 mac_bundle_set_environment_value (GtkMacBundle *bundle,
-                                  const gchar  *key, 
+                                  const gchar  *key,
                                   const gchar  *value)
 {
   GtkMacBundlePriv *priv = GET_PRIV (bundle);
@@ -332,8 +333,8 @@ gtk_mac_bundle_setup_environment (GtkMacBundle *bundle)
   // could add FONTCONFIG_FILE
 
   /*export LANG="\`grep \"\\\`defaults read .GlobalPreferences AppleCollationOrder \
- 2>&1\\\`_\" /usr/share/locale/locale.alias | tail -n1 | sed 's/\./ /' | \
- awk '{print \$2}'\`.UTF-8"*/
+  2>&1\\\`_\" /usr/share/locale/locale.alias | tail -n1 | sed 's/\./ /' | \
+  awk '{print \$2}'\`.UTF-8"*/
 
   g_free (share);
   g_free (lib);
@@ -367,8 +368,8 @@ gtk_mac_bundle_get_resource_path (GtkMacBundle *bundle,
   // FIXME: Look at using CFURLGetFileSystemRepresentation (urlcf_, true, (UInt8*)outPathName, 256)
 
   // FIXME: crate real cfstring here...
-  cf_url = CFBundleCopyResourceURL (priv->cf_bundle, 
-                                    CFSTR("name"), CFSTR("type"), CFSTR("subdir"));
+  cf_url = CFBundleCopyResourceURL (priv->cf_bundle,
+                                    CFSTR ("name"), CFSTR ("type"), CFSTR ("subdir"));
   cf_string = CFURLCopyFileSystemPath (cf_url, kCFURLPOSIXPathStyle);
   path = cf_string_to_utf8 (cf_string);
   CFRelease (cf_string);
diff --git a/src/gtk-mac-dock.c b/src/gtk-mac-dock.c
index 93e5806..b7e0fb7 100644
--- a/src/gtk-mac-dock.c
+++ b/src/gtk-mac-dock.c
@@ -43,7 +43,8 @@
 #include "gtk-mac-image-utils.h"
 #include "gtk-mac-private.h"
 
-enum {
+enum
+{
   CLICKED,
   QUIT_ACTIVATE,
   OPEN_DOCUMENTS,
@@ -54,23 +55,24 @@ static guint signals[LAST_SIGNAL] = { 0 };
 
 typedef struct GtkMacDockPriv GtkMacDockPriv;
 
-struct GtkMacDockPriv {
+struct GtkMacDockPriv
+{
   glong id;
 };
 
 static void  mac_dock_finalize                  (GObject          *object);
 static OSErr mac_dock_handle_quit               (const AppleEvent *inAppleEvent,
-                                                 AppleEvent       *outAppleEvent,
-                                                 long              inHandlerRefcon);
+    AppleEvent       *outAppleEvent,
+    long              inHandlerRefcon);
 static OSErr mac_dock_handle_open_documents     (const AppleEvent *inAppleEvent,
-                                                 AppleEvent       *outAppleEvent,
-                                                 long              inHandlerRefcon);
+    AppleEvent       *outAppleEvent,
+    long              inHandlerRefcon);
 static OSErr mac_dock_handle_open_application   (const AppleEvent *inAppleEvent,
-                                                 AppleEvent       *outAppleEvent,
-                                                 long              inHandlerRefcon);
+    AppleEvent       *outAppleEvent,
+    long              inHandlerRefcon);
 static OSErr mac_dock_handle_reopen_application (const AppleEvent *inAppleEvent,
-                                                 AppleEvent       *outAppleEvent,
-                                                 long              inHandlerRefcon);
+    AppleEvent       *outAppleEvent,
+    long              inHandlerRefcon);
 
 G_DEFINE_TYPE (GtkMacDock, gtk_mac_dock, G_TYPE_OBJECT)
 
@@ -125,10 +127,10 @@ gtk_mac_dock_class_init (GtkMacDockClass *class)
 #if 0
   EventTypeSpec kFakeEventList[] = { { INT_MAX, INT_MAX } };
   EventRef event;
-  
+
   ReceiveNextEvent (GetEventTypeCount (kFakeEventList),
                     kFakeEventList,
-                    kEventDurationNoWait, false, 
+                    kEventDurationNoWait, false,
                     &event);
 #endif
 }
@@ -143,13 +145,13 @@ gtk_mac_dock_init (GtkMacDock *dock)
 
   handlers = g_list_prepend (handlers, dock);
 
-  AEInstallEventHandler (kCoreEventClass, kAEQuitApplication, 
+  AEInstallEventHandler (kCoreEventClass, kAEQuitApplication,
                          mac_dock_handle_quit,
                          priv->id, true);
   AEInstallEventHandler (kCoreEventClass, kAEOpenApplication,
                          mac_dock_handle_open_application,
                          priv->id, true);
-  AEInstallEventHandler (kCoreEventClass, kAEReopenApplication, 
+  AEInstallEventHandler (kCoreEventClass, kAEReopenApplication,
                          mac_dock_handle_reopen_application,
                          priv->id, true);
   AEInstallEventHandler (kCoreEventClass, kAEOpenDocuments,
@@ -215,14 +217,14 @@ mac_dock_get_from_id (gulong id)
         break;
 
       dock = NULL;
-  }
+    }
 
   return dock;
 }
 
 static OSErr
-mac_dock_handle_quit (const AppleEvent *inAppleEvent, 
-                      AppleEvent       *outAppleEvent, 
+mac_dock_handle_quit (const AppleEvent *inAppleEvent,
+                      AppleEvent       *outAppleEvent,
                       long              inHandlerRefcon)
 {
   GtkMacDock *dock;
@@ -246,8 +248,8 @@ mac_dock_handle_open_application (const AppleEvent *inAppleEvent,
 }
 
 static OSErr
-mac_dock_handle_reopen_application (const AppleEvent *inAppleEvent, 
-                                    AppleEvent       *outAppleEvent, 
+mac_dock_handle_reopen_application (const AppleEvent *inAppleEvent,
+                                    AppleEvent       *outAppleEvent,
                                     long              inHandlerRefcon)
 {
   GtkMacDock *dock;
@@ -256,7 +258,7 @@ mac_dock_handle_reopen_application (const AppleEvent *inAppleEvent,
 
   if (dock)
     g_signal_emit (dock, signals[CLICKED], 0);
-  
+
   return noErr;
 }
 
@@ -288,7 +290,7 @@ mac_dock_handle_open_documents (const AppleEvent *inAppleEvent,
         {
           FSRef ref;
 
-          status = AEGetNthPtr (&documents, i + 1, typeFSRef, 
+          status = AEGetNthPtr (&documents, i + 1, typeFSRef,
                                 0, 0, &ref, sizeof (ref),
                                 0);
           if (status != noErr)
@@ -302,8 +304,8 @@ mac_dock_handle_open_documents (const AppleEvent *inAppleEvent,
           /*g_print ("  %s\n", path);*/
         }
     }
-        
-    return status;
+
+  return status;
 }
 
 void
@@ -397,7 +399,8 @@ gtk_mac_dock_set_overlay_from_resource (GtkMacDock   *dock,
     }
 }
 
-struct _GtkMacAttentionRequest {
+struct _GtkMacAttentionRequest
+{
   NMRec    nm_request;
   guint    timeout_id;
   gboolean is_cancelled;
@@ -428,7 +431,7 @@ gtk_mac_dock_attention_request (GtkMacDock          *dock,
 
   request->nm_request.nmMark = 1;
   request->nm_request.qType = nmType;
-  
+
   if (NMInstall (&request->nm_request) != noErr)
     {
       g_free (request);
@@ -437,9 +440,9 @@ gtk_mac_dock_attention_request (GtkMacDock          *dock,
 
   if (type == GTK_MAC_ATTENTION_INFO)
     request->timeout_id = gdk_threads_add_timeout (
-            1000,
-            (GSourceFunc) mac_dock_attention_cb,
-            request);
+                            1000,
+                            (GSourceFunc) mac_dock_attention_cb,
+                            request);
 
   return request;
 }
diff --git a/src/gtk-mac-image-utils.c b/src/gtk-mac-image-utils.c
index 1bdaa69..858ccfb 100644
--- a/src/gtk-mac-image-utils.c
+++ b/src/gtk-mac-image-utils.c
@@ -45,8 +45,8 @@ gtkosx_create_cgimage_from_pixbuf (GdkPixbuf *pixbuf)
 
   colorspace = CGColorSpaceCreateDeviceRGB ();
   data_provider = CGDataProviderCreateWithData (NULL, data,
-                                                pixbuf_height * rowstride,
-                                                NULL);
+                  pixbuf_height * rowstride,
+                  NULL);
 
   image = CGImageCreate (pixbuf_width, pixbuf_height, 8,
                          has_alpha ? 32 : 24, rowstride,
diff --git a/src/gtk-mac-menu.c b/src/gtk-mac-menu.c
index dcb3e96..4f8d362 100644
--- a/src/gtk-mac-menu.c
+++ b/src/gtk-mac-menu.c
@@ -60,7 +60,7 @@ static MenuID   last_menu_id;
 static gboolean global_key_handler_enabled = TRUE;
 
 static void   sync_menu_shell (GtkMenuShell *menu_shell, MenuRef carbon_menu,
-                              gboolean toplevel, gboolean debug);
+                               gboolean toplevel, gboolean debug);
 
 /* A category that exposes the protected carbon event for an NSEvent. */
 @interface NSEvent (GdkQuartzNSEvent)
@@ -68,16 +68,18 @@ static void   sync_menu_shell (GtkMenuShell *menu_shell, MenuRef carbon_menu,
 @end
 
 @implementation NSEvent (GdkQuartzNSEvent)
-- (void *)gdk_quartz_event_ref {
-    return _eventRef;
+- (void *)gdk_quartz_event_ref
+{
+  return _eventRef;
 }
 @end
 
 static gboolean
-menu_flash_off_cb (gpointer data) {
-    /* Disable flash by flashing a non-existing menu id. */
-    FlashMenuBar (last_menu_id + 1);
-    return FALSE;
+menu_flash_off_cb (gpointer data)
+{
+  /* Disable flash by flashing a non-existing menu id. */
+  FlashMenuBar (last_menu_id + 1);
+  return FALSE;
 }
 
 /*
@@ -85,46 +87,52 @@ menu_flash_off_cb (gpointer data) {
  */
 
 static GtkWidget *
-find_menu_label (GtkWidget *widget) {
-    GtkWidget *label = NULL;
-    if (GTK_IS_LABEL (widget))
-       return widget;
-    if (GTK_IS_CONTAINER (widget)) {
-       GList *children;
-       GList *l;
-       children = gtk_container_get_children (GTK_CONTAINER (widget));
-       for (l = children; l; l = l->next) {
-           label = find_menu_label (l->data);
-           if (label)
-               break;
-       }
-       g_list_free (children);
+find_menu_label (GtkWidget *widget)
+{
+  GtkWidget *label = NULL;
+  if (GTK_IS_LABEL (widget))
+    return widget;
+  if (GTK_IS_CONTAINER (widget))
+    {
+      GList *children;
+      GList *l;
+      children = gtk_container_get_children (GTK_CONTAINER (widget));
+      for (l = children; l; l = l->next)
+        {
+          label = find_menu_label (l->data);
+          if (label)
+            break;
+        }
+      g_list_free (children);
     }
-    return label;
+  return label;
 }
 
 static const gchar *
-get_menu_label_text (GtkWidget  *menu_item, GtkWidget **label) {
-    GtkWidget *my_label;
-    my_label = find_menu_label (menu_item);
-    if (label)
-       *label = my_label;
-    if (my_label)
-       return gtk_label_get_text (GTK_LABEL (my_label));
-    return NULL;
+get_menu_label_text (GtkWidget  *menu_item, GtkWidget **label)
+{
+  GtkWidget *my_label;
+  my_label = find_menu_label (menu_item);
+  if (label)
+    *label = my_label;
+  if (my_label)
+    return gtk_label_get_text (GTK_LABEL (my_label));
+  return NULL;
 }
 
 static gboolean
-accel_find_func (GtkAccelKey *key, GClosure *closure, gpointer data) {
-    return (GClosure *) data == closure;
+accel_find_func (GtkAccelKey *key, GClosure *closure, gpointer data)
+{
+  return (GClosure *) data == closure;
 }
 
 static GClosure *
-_gtk_accel_label_get_closure (GtkAccelLabel *label) {
-  g_return_val_if_fail(GTK_IS_ACCEL_LABEL(label), NULL);
+_gtk_accel_label_get_closure (GtkAccelLabel *label)
+{
+  g_return_val_if_fail (GTK_IS_ACCEL_LABEL (label), NULL);
 
   GClosure *closure = NULL;
-  g_object_get(G_OBJECT(label), "accel-closure", &closure, NULL);
+  g_object_get (G_OBJECT (label), "accel-closure", &closure, NULL);
   return closure;
 }
 
@@ -139,40 +147,46 @@ _gtk_accel_label_get_closure (GtkAccelLabel *label) {
  * so no MenuRef points to it.
  */
 
-typedef struct {
-    MenuRef menu;
-    guint   toplevel : 1;
+typedef struct
+{
+  MenuRef menu;
+  guint   toplevel : 1;
 } CarbonMenu;
 
 static GQuark carbon_menu_quark = 0;
 
 static CarbonMenu *
-carbon_menu_new (void) {
-    return g_slice_new0 (CarbonMenu);
+carbon_menu_new (void)
+{
+  return g_slice_new0 (CarbonMenu);
 }
 
 static void
-carbon_menu_free (CarbonMenu *menu) {
-    DisposeMenu(menu->menu);
-    g_slice_free (CarbonMenu, menu);
+carbon_menu_free (CarbonMenu *menu)
+{
+  DisposeMenu (menu->menu);
+  g_slice_free (CarbonMenu, menu);
 }
 
 static CarbonMenu *
-carbon_menu_get (GtkWidget *widget) {
-    return g_object_get_qdata (G_OBJECT (widget), carbon_menu_quark);
+carbon_menu_get (GtkWidget *widget)
+{
+  return g_object_get_qdata (G_OBJECT (widget), carbon_menu_quark);
 }
 
 static void
-carbon_menu_connect (GtkWidget *menu, MenuRef menuRef, gboolean toplevel) {
-    CarbonMenu *carbon_menu = carbon_menu_get (menu);
-    if (!carbon_menu) {
-       carbon_menu = carbon_menu_new ();
-       g_object_set_qdata_full (G_OBJECT (menu), carbon_menu_quark, 
-                                carbon_menu,
-                                (GDestroyNotify) carbon_menu_free);
+carbon_menu_connect (GtkWidget *menu, MenuRef menuRef, gboolean toplevel)
+{
+  CarbonMenu *carbon_menu = carbon_menu_get (menu);
+  if (!carbon_menu)
+    {
+      carbon_menu = carbon_menu_new ();
+      g_object_set_qdata_full (G_OBJECT (menu), carbon_menu_quark,
+                               carbon_menu,
+                               (GDestroyNotify) carbon_menu_free);
     }
-    carbon_menu->menu     = menuRef;
-    carbon_menu->toplevel = toplevel;
+  carbon_menu->menu     = menuRef;
+  carbon_menu->toplevel = toplevel;
 }
 
 
@@ -191,79 +205,84 @@ carbon_menu_connect (GtkWidget *menu, MenuRef menuRef, gboolean toplevel) {
  * if they get out of sync.
  */
 
-typedef struct {
-    MenuRef        menu;
-    MenuItemIndex  index;
-    MenuRef        submenu;
-    GClosure      *accel_closure;
+typedef struct
+{
+  MenuRef        menu;
+  MenuItemIndex  index;
+  MenuRef        submenu;
+  GClosure      *accel_closure;
 } CarbonMenuItem;
 
 static GQuark carbon_menu_item_quark = 0;
 
 static CarbonMenuItem *
-carbon_menu_item_new (void) {
-    return g_slice_new0 (CarbonMenuItem);
+carbon_menu_item_new (void)
+{
+  return g_slice_new0 (CarbonMenuItem);
 }
 
 static void
-carbon_menu_item_free (CarbonMenuItem *menu_item) {
-    DeleteMenuItem(menu_item->menu, menu_item->index);  //Clean up the Carbon Menu
-    if (menu_item->accel_closure)
-       g_closure_unref (menu_item->accel_closure);
-    g_slice_free (CarbonMenuItem, menu_item);
+carbon_menu_item_free (CarbonMenuItem *menu_item)
+{
+  DeleteMenuItem (menu_item->menu, menu_item->index); //Clean up the Carbon Menu
+  if (menu_item->accel_closure)
+    g_closure_unref (menu_item->accel_closure);
+  g_slice_free (CarbonMenuItem, menu_item);
 }
 
 static const gchar *
-carbon_menu_error_string(OSStatus err) {
-    switch (err) {
+carbon_menu_error_string (OSStatus err)
+{
+  switch (err)
+    {
     case 0:
-       return "No Error";
+      return "No Error";
     case -50:
-       return "User Parameter List";
+      return "User Parameter List";
     case -5603:
-       return "Menu Property Reserved Creator Type";
+      return "Menu Property Reserved Creator Type";
     case -5604:
-       return "Menu Property Not Found";
+      return "Menu Property Not Found";
     case -5620:
-       return "Menu Not Found";
+      return "Menu Not Found";
     case -5621:
-       return "Menu uses system definition";
+      return "Menu uses system definition";
     case -5622:
-       return "Menu Item Not Found";
+      return "Menu Item Not Found";
     case -5623:
-       return "Menu Reference Invalid";
+      return "Menu Reference Invalid";
     case -9860:
-       return "Event Already Posted";
+      return "Event Already Posted";
     case -9861:
-       return "Event Target Busy";
+      return "Event Target Busy";
     case -9862:
-       return "Invalid Event Class";
+      return "Invalid Event Class";
     case -9864:
-       return "Incorrect Event Class";
+      return "Incorrect Event Class";
     case -9866:
-       return "Event Handler Already Installed";
+      return "Event Handler Already Installed";
     case -9868:
-       return "Internal Event Error";
+      return "Internal Event Error";
     case -9869:
-       return "Incorrect Event Kind";
+      return "Incorrect Event Kind";
     case -9870:
-       return "Event Parameter Not Found";
+      return "Event Parameter Not Found";
     case -9874:
-       return "Event Not Handled";
+      return "Event Not Handled";
     case -9875:
-       return "Event Loop Timeout";
+      return "Event Loop Timeout";
     case -9876:
-       return "Event Loop Quit";
+      return "Event Loop Quit";
     case -9877:
-       return  "Event Not In Queue";
+      return  "Event Not In Queue";
     case -9878:
-       return "Hot Key Exists";
+      return "Hot Key Exists";
     case -9879:
-       return "Invalid Hot Key";
+      return "Invalid Hot Key";
     default:
-       return "Invalid Error Code";
+      return "Invalid Error Code";
     }
-    return "System Error: Unreachable";
+  return "System Error: Unreachable";
 }
 
 #define carbon_menu_warn(err, msg) \
@@ -303,371 +322,405 @@ carbon_menu_error_string(OSStatus err) {
     }
 
 static CarbonMenuItem *
-carbon_menu_item_get (GtkWidget *widget) {
-    return g_object_get_qdata (G_OBJECT (widget), carbon_menu_item_quark);
+carbon_menu_item_get (GtkWidget *widget)
+{
+  return g_object_get_qdata (G_OBJECT (widget), carbon_menu_item_quark);
 }
 
 static CarbonMenuItem *
-carbon_menu_item_get_checked (GtkWidget *widget) {
-    CarbonMenuItem * carbon_item = carbon_menu_item_get(widget);
-    GtkWidget *checkWidget = NULL;
-    OSStatus  err;
-    const gchar *label = get_menu_label_text(GTK_WIDGET(widget), NULL);
-    const gchar *name = gtk_widget_get_name(widget);
-
-    if (!carbon_item)
-       return NULL;
-
-    /* Get any GtkWidget associated with the item. */
-    err = GetMenuItemProperty (carbon_item->menu, carbon_item->index,
-                              GTK_QUARTZ_MENU_CREATOR,
-                              GTK_QUARTZ_ITEM_WIDGET,
-                              sizeof (checkWidget), 0, &checkWidget);
-    if (err) {
-       if (DEBUG_CARBON)
-           g_printerr("%s: Widget %s %s Cross-check error %s\n", G_STRFUNC,
-                      name, label, carbon_menu_error_string(err));
-       return NULL;
+carbon_menu_item_get_checked (GtkWidget *widget)
+{
+  CarbonMenuItem * carbon_item = carbon_menu_item_get (widget);
+  GtkWidget *checkWidget = NULL;
+  OSStatus  err;
+  const gchar *label = get_menu_label_text (GTK_WIDGET (widget), NULL);
+  const gchar *name = gtk_widget_get_name (widget);
+
+  if (!carbon_item)
+    return NULL;
+
+  /* Get any GtkWidget associated with the item. */
+  err = GetMenuItemProperty (carbon_item->menu, carbon_item->index,
+                             GTK_QUARTZ_MENU_CREATOR,
+                             GTK_QUARTZ_ITEM_WIDGET,
+                             sizeof (checkWidget), 0, &checkWidget);
+  if (err)
+    {
+      if (DEBUG_CARBON)
+        g_printerr ("%s: Widget %s %s Cross-check error %s\n", G_STRFUNC,
+                    name, label, carbon_menu_error_string (err));
+      return NULL;
     }
-/* This could check the checkWidget, but that could turn into a
- * recursion nightmare, so worry about it when it we run
- * carbon_menu_item_get on it.
- */
-    if (widget != checkWidget) {
-       const gchar *clabel = get_menu_label_text(GTK_WIDGET(checkWidget), 
-                                                 NULL);
-       const gchar *cname = gtk_widget_get_name(checkWidget);
-       if (DEBUG_CARBON)
-           g_printerr("%s: Widget mismatch, expected %s %s got %s %s\n", 
-                      G_STRFUNC, name, label, cname, clabel);
-       return NULL;
+  /* This could check the checkWidget, but that could turn into a
+   * recursion nightmare, so worry about it when it we run
+   * carbon_menu_item_get on it.
+   */
+  if (widget != checkWidget)
+    {
+      const gchar *clabel = get_menu_label_text (GTK_WIDGET (checkWidget),
+                            NULL);
+      const gchar *cname = gtk_widget_get_name (checkWidget);
+      if (DEBUG_CARBON)
+        g_printerr ("%s: Widget mismatch, expected %s %s got %s %s\n",
+                    G_STRFUNC, name, label, cname, clabel);
+      return NULL;
     }
-    return carbon_item;
+  return carbon_item;
 }
 
 static void
-carbon_menu_item_update_state (CarbonMenuItem *carbon_item, GtkWidget *widget) {
-    gboolean sensitive;
-    gboolean visible;
-    UInt32   set_attrs = 0;
-    UInt32   clear_attrs = 0;
-    OSStatus err;
-
-    g_object_get (widget, "sensitive", &sensitive, "visible",   &visible, NULL);
-    if (!sensitive)
-       set_attrs |= kMenuItemAttrDisabled;
-    else
-       clear_attrs |= kMenuItemAttrDisabled;
-    if (!visible)
-       set_attrs |= kMenuItemAttrHidden;
-    else
-       clear_attrs |= kMenuItemAttrHidden;
-    err = ChangeMenuItemAttributes (carbon_item->menu, carbon_item->index,
-                                   set_attrs, clear_attrs);
-    if (!err && carbon_item->submenu)
-       err = ChangeMenuAttributes (carbon_item->submenu, 
-                                   set_attrs, clear_attrs);
-    carbon_menu_warn(err, "Failed to update state");
+carbon_menu_item_update_state (CarbonMenuItem *carbon_item, GtkWidget *widget)
+{
+  gboolean sensitive;
+  gboolean visible;
+  UInt32   set_attrs = 0;
+  UInt32   clear_attrs = 0;
+  OSStatus err;
+
+  g_object_get (widget, "sensitive", &sensitive, "visible",   &visible, NULL);
+  if (!sensitive)
+    set_attrs |= kMenuItemAttrDisabled;
+  else
+    clear_attrs |= kMenuItemAttrDisabled;
+  if (!visible)
+    set_attrs |= kMenuItemAttrHidden;
+  else
+    clear_attrs |= kMenuItemAttrHidden;
+  err = ChangeMenuItemAttributes (carbon_item->menu, carbon_item->index,
+                                  set_attrs, clear_attrs);
+  if (!err && carbon_item->submenu)
+    err = ChangeMenuAttributes (carbon_item->submenu,
+                                set_attrs, clear_attrs);
+  carbon_menu_warn (err, "Failed to update state");
 }
 
 static void
-carbon_menu_item_update_active (CarbonMenuItem *carbon_item, 
-                               GtkWidget *widget) {
-    gboolean active;
-    g_object_get (widget, "active", &active, NULL);
-    CheckMenuItem (carbon_item->menu, carbon_item->index, active);
+carbon_menu_item_update_active (CarbonMenuItem *carbon_item,
+                                GtkWidget *widget)
+{
+  gboolean active;
+  g_object_get (widget, "active", &active, NULL);
+  CheckMenuItem (carbon_item->menu, carbon_item->index, active);
 }
 
 static void
-carbon_menu_item_update_submenu (CarbonMenuItem *carbon_item, 
-                                GtkWidget *widget, bool debug) {
-    GtkWidget *submenu;
-    const gchar *label_text;
-    CFStringRef  cfstr = NULL;
-    OSStatus err;
-
-    label_text = get_menu_label_text (widget, NULL);
-    submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
-    if (!submenu) {
-       err = SetMenuItemHierarchicalMenu (carbon_item->menu, 
-                                          carbon_item->index, NULL);
-       carbon_menu_warn_label(err, label_text, "Failed to clear submenu");
-       carbon_item->submenu = NULL;
-       return;
+carbon_menu_item_update_submenu (CarbonMenuItem *carbon_item,
+                                 GtkWidget *widget, bool debug)
+{
+  GtkWidget *submenu;
+  const gchar *label_text;
+  CFStringRef  cfstr = NULL;
+  OSStatus err;
+
+  label_text = get_menu_label_text (widget, NULL);
+  submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
+  if (!submenu)
+    {
+      err = SetMenuItemHierarchicalMenu (carbon_item->menu,
+                                         carbon_item->index, NULL);
+      carbon_menu_warn_label (err, label_text, "Failed to clear submenu");
+      carbon_item->submenu = NULL;
+      return;
     }
-    err = CreateNewMenu (++last_menu_id, 0, &carbon_item->submenu);
-    carbon_menu_err_return_label(err, label_text, "Failed to create new menu");
-    if (label_text)
-       cfstr = CFStringCreateWithCString (NULL, label_text,
-                                          kCFStringEncodingUTF8);
-
-    err = SetMenuTitleWithCFString (carbon_item->submenu, cfstr);
-    if (cfstr)
-       CFRelease (cfstr);
-    carbon_menu_err_return_label(err, label_text, "Failed to set menu title");
-    err = SetMenuItemHierarchicalMenu (carbon_item->menu, carbon_item->index,
-                                      carbon_item->submenu);
-    carbon_menu_err_return_label(err, label_text, "Failed to set menu");
-    sync_menu_shell (GTK_MENU_SHELL (submenu), carbon_item->submenu, 
-                    FALSE, debug);
+  err = CreateNewMenu (++last_menu_id, 0, &carbon_item->submenu);
+  carbon_menu_err_return_label (err, label_text, "Failed to create new menu");
+  if (label_text)
+    cfstr = CFStringCreateWithCString (NULL, label_text,
+                                       kCFStringEncodingUTF8);
+
+  err = SetMenuTitleWithCFString (carbon_item->submenu, cfstr);
+  if (cfstr)
+    CFRelease (cfstr);
+  carbon_menu_err_return_label (err, label_text, "Failed to set menu title");
+  err = SetMenuItemHierarchicalMenu (carbon_item->menu, carbon_item->index,
+                                     carbon_item->submenu);
+  carbon_menu_err_return_label (err, label_text, "Failed to set menu");
+  sync_menu_shell (GTK_MENU_SHELL (submenu), carbon_item->submenu,
+                   FALSE, debug);
 }
 
 static void
-carbon_menu_item_update_label (CarbonMenuItem *carbon_item, GtkWidget *widget) {
-    const gchar *label_text;
-    CFStringRef  cfstr = NULL;
-    OSStatus err;
-
-    label_text = get_menu_label_text (widget, NULL);
-    if (label_text)
-       cfstr = CFStringCreateWithCString (NULL, label_text, 
-                                          kCFStringEncodingUTF8);
-    err = SetMenuItemTextWithCFString (carbon_item->menu, carbon_item->index, 
-                                      cfstr);
-    carbon_menu_warn(err, "Failed to set menu text");
-    if (cfstr)
-       CFRelease (cfstr);
+carbon_menu_item_update_label (CarbonMenuItem *carbon_item, GtkWidget *widget)
+{
+  const gchar *label_text;
+  CFStringRef  cfstr = NULL;
+  OSStatus err;
+
+  label_text = get_menu_label_text (widget, NULL);
+  if (label_text)
+    cfstr = CFStringCreateWithCString (NULL, label_text,
+                                       kCFStringEncodingUTF8);
+  err = SetMenuItemTextWithCFString (carbon_item->menu, carbon_item->index,
+                                     cfstr);
+  carbon_menu_warn (err, "Failed to set menu text");
+  if (cfstr)
+    CFRelease (cfstr);
 }
 
 static void
 carbon_menu_item_update_accelerator (CarbonMenuItem *carbon_item,
-                                    GtkWidget *widget) {
-    GtkAccelKey *key;
-    GtkWidget *label;
-    GdkDisplay *display = NULL;
-    GdkKeymap *keymap = NULL;
-    GdkKeymapKey *keys = NULL;
-    gint n_keys = 0;
-    UInt8 modifiers = 0;
-    OSStatus err;
-
-    const gchar *label_txt = get_menu_label_text (widget, &label);
-    if (!(GTK_IS_ACCEL_LABEL (label) 
-         && _gtk_accel_label_get_closure(GTK_ACCEL_LABEL (label)))) {
+                                     GtkWidget *widget)
+{
+  GtkAccelKey *key;
+  GtkWidget *label;
+  GdkDisplay *display = NULL;
+  GdkKeymap *keymap = NULL;
+  GdkKeymapKey *keys = NULL;
+  gint n_keys = 0;
+  UInt8 modifiers = 0;
+  OSStatus err;
+
+  const gchar *label_txt = get_menu_label_text (widget, &label);
+  if (! (GTK_IS_ACCEL_LABEL (label)
+         && _gtk_accel_label_get_closure (GTK_ACCEL_LABEL (label))))
+    {
 // Clear the menu shortcut
-       err = SetMenuItemModifiers (carbon_item->menu, carbon_item->index,
-                                   kMenuNoModifiers | kMenuNoCommandModifier);
-       carbon_menu_warn_label(err, label_txt, "Failed to set modifiers");
-       err = ChangeMenuItemAttributes (carbon_item->menu, carbon_item->index,
-                                       0, kMenuItemAttrUseVirtualKey);
-       carbon_menu_warn_label(err, label_txt, "Failed to change attributes");
-       err = SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
-                                    false, 0);
-       carbon_menu_warn_label(err, label_txt, "Failed to clear command key");
-       return;
+      err = SetMenuItemModifiers (carbon_item->menu, carbon_item->index,
+                                  kMenuNoModifiers | kMenuNoCommandModifier);
+      carbon_menu_warn_label (err, label_txt, "Failed to set modifiers");
+      err = ChangeMenuItemAttributes (carbon_item->menu, carbon_item->index,
+                                      0, kMenuItemAttrUseVirtualKey);
+      carbon_menu_warn_label (err, label_txt, "Failed to change attributes");
+      err = SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
+                                   false, 0);
+      carbon_menu_warn_label (err, label_txt, "Failed to clear command key");
+      return;
     }
-    GClosure *closure = _gtk_accel_label_get_closure(GTK_ACCEL_LABEL(label));
-    key = gtk_accel_group_find (gtk_accel_group_from_accel_closure(closure),
-                                   accel_find_func,
-                                   closure);
-    if (!(key && key->accel_key && key->accel_flags & GTK_ACCEL_VISIBLE))
-       return;
-    display = gtk_widget_get_display (widget);
-    keymap  = gdk_keymap_get_for_display (display);
-
-    if (!gdk_keymap_get_entries_for_keyval (keymap, key->accel_key,
-                                           &keys, &n_keys))
-       return;
-
-    err = SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
-                                true, keys[0].keycode);
-    carbon_menu_warn_label(err, label_txt, "Set Command Key Failed");
-    g_free (keys);
-    if (key->accel_mods) {
-       if (key->accel_mods & GDK_SHIFT_MASK)
-           modifiers |= kMenuShiftModifier;
-       if (key->accel_mods & GDK_MOD1_MASK)
-           modifiers |= kMenuOptionModifier;
+  GClosure *closure = _gtk_accel_label_get_closure (GTK_ACCEL_LABEL (label));
+  key = gtk_accel_group_find (gtk_accel_group_from_accel_closure (closure),
+                              accel_find_func,
+                              closure);
+  if (! (key && key->accel_key && key->accel_flags & GTK_ACCEL_VISIBLE))
+    return;
+  display = gtk_widget_get_display (widget);
+  keymap  = gdk_keymap_get_for_display (display);
+
+  if (!gdk_keymap_get_entries_for_keyval (keymap, key->accel_key,
+                                          &keys, &n_keys))
+    return;
+
+  err = SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
+                               true, keys[0].keycode);
+  carbon_menu_warn_label (err, label_txt, "Set Command Key Failed");
+  g_free (keys);
+  if (key->accel_mods)
+    {
+      if (key->accel_mods & GDK_SHIFT_MASK)
+        modifiers |= kMenuShiftModifier;
+      if (key->accel_mods & GDK_MOD1_MASK)
+        modifiers |= kMenuOptionModifier;
     }
-    if (!(key->accel_mods & GDK_CONTROL_MASK)) {
-       modifiers |= kMenuNoCommandModifier;
+  if (! (key->accel_mods & GDK_CONTROL_MASK))
+    {
+      modifiers |= kMenuNoCommandModifier;
     }
-    err = SetMenuItemModifiers (carbon_item->menu, carbon_item->index,
-                               modifiers);
-    carbon_menu_warn_label(err, label_txt, "Set Item Modifiers Failed");
-    return;
+  err = SetMenuItemModifiers (carbon_item->menu, carbon_item->index,
+                              modifiers);
+  carbon_menu_warn_label (err, label_txt, "Set Item Modifiers Failed");
+  return;
 }
 
 static void
 carbon_menu_item_accel_changed (GtkAccelGroup *accel_group, guint keyval,
-                               GdkModifierType  modifier,
-                               GClosure *accel_closure, GtkWidget *widget) {
-    CarbonMenuItem *carbon_item = carbon_menu_item_get (widget);
-    GtkWidget      *label;
-
-    const gchar *label_text = get_menu_label_text (widget, &label);
-    if (!carbon_item) {
-       if (DEBUG_CARBON)
-           g_printerr("%s: Bad carbon item for %s\n", G_STRFUNC, label_text);
-       return;
+                                GdkModifierType  modifier,
+                                GClosure *accel_closure, GtkWidget *widget)
+{
+  CarbonMenuItem *carbon_item = carbon_menu_item_get (widget);
+  GtkWidget      *label;
+
+  const gchar *label_text = get_menu_label_text (widget, &label);
+  if (!carbon_item)
+    {
+      if (DEBUG_CARBON)
+        g_printerr ("%s: Bad carbon item for %s\n", G_STRFUNC, label_text);
+      return;
     }
-    if (gtk_accel_group_from_accel_closure(accel_closure) != accel_group)
-       return;
-    if (GTK_IS_ACCEL_LABEL (label) &&
-       _gtk_accel_label_get_closure(GTK_ACCEL_LABEL(label)) == accel_closure)
-       carbon_menu_item_update_accelerator (carbon_item, widget);
+  if (gtk_accel_group_from_accel_closure (accel_closure) != accel_group)
+    return;
+  if (GTK_IS_ACCEL_LABEL (label) &&
+      _gtk_accel_label_get_closure (GTK_ACCEL_LABEL (label)) == accel_closure)
+    carbon_menu_item_update_accelerator (carbon_item, widget);
 }
 
 static void
 carbon_menu_item_update_accel_closure (CarbonMenuItem *carbon_item,
-                                      GtkWidget *widget) {
-    GtkAccelGroup *group;
-    GtkWidget     *label;
-    get_menu_label_text (widget, &label);
-    if (carbon_item->accel_closure) {
-       group = gtk_accel_group_from_accel_closure (carbon_item->accel_closure);
-       g_signal_handlers_disconnect_by_func (group,
-                                             carbon_menu_item_accel_changed,
-                                             widget);
-       g_closure_unref (carbon_item->accel_closure);
-       carbon_item->accel_closure = NULL;
+                                       GtkWidget *widget)
+{
+  GtkAccelGroup *group;
+  GtkWidget     *label;
+  get_menu_label_text (widget, &label);
+  if (carbon_item->accel_closure)
+    {
+      group = gtk_accel_group_from_accel_closure (carbon_item->accel_closure);
+      g_signal_handlers_disconnect_by_func (group,
+                                            carbon_menu_item_accel_changed,
+                                            widget);
+      g_closure_unref (carbon_item->accel_closure);
+      carbon_item->accel_closure = NULL;
     }
-    if (GTK_IS_ACCEL_LABEL (label))
-       carbon_item->accel_closure = _gtk_accel_label_get_closure(GTK_ACCEL_LABEL (label));
-    if (carbon_item->accel_closure) {
-       g_closure_ref (carbon_item->accel_closure);
-       group = gtk_accel_group_from_accel_closure (carbon_item->accel_closure);
-       g_signal_connect_object (group, "accel-changed",
-                                G_CALLBACK (carbon_menu_item_accel_changed),
-                                widget, 0);
+  if (GTK_IS_ACCEL_LABEL (label))
+    carbon_item->accel_closure = _gtk_accel_label_get_closure (GTK_ACCEL_LABEL (label));
+  if (carbon_item->accel_closure)
+    {
+      g_closure_ref (carbon_item->accel_closure);
+      group = gtk_accel_group_from_accel_closure (carbon_item->accel_closure);
+      g_signal_connect_object (group, "accel-changed",
+                               G_CALLBACK (carbon_menu_item_accel_changed),
+                               widget, 0);
     }
-    carbon_menu_item_update_accelerator (carbon_item, widget);
+  carbon_menu_item_update_accelerator (carbon_item, widget);
 }
 
 static void
 carbon_menu_item_notify (GObject *object, GParamSpec *pspec,
-                        CarbonMenuItem *carbon_item) {
-    if (!strcmp (pspec->name, "sensitive") ||
-       !strcmp (pspec->name, "visible")) {
-       carbon_menu_item_update_state (carbon_item, GTK_WIDGET (object));
+                         CarbonMenuItem *carbon_item)
+{
+  if (!strcmp (pspec->name, "sensitive") ||
+      !strcmp (pspec->name, "visible"))
+    {
+      carbon_menu_item_update_state (carbon_item, GTK_WIDGET (object));
     }
-    else if (!strcmp (pspec->name, "active")) {
-       carbon_menu_item_update_active (carbon_item, GTK_WIDGET (object));
+  else if (!strcmp (pspec->name, "active"))
+    {
+      carbon_menu_item_update_active (carbon_item, GTK_WIDGET (object));
     }
-    else if (!strcmp (pspec->name, "submenu")) {
-       carbon_menu_item_update_submenu (carbon_item, GTK_WIDGET (object), 
-DEBUG_SIGNAL);
+  else if (!strcmp (pspec->name, "submenu"))
+    {
+      carbon_menu_item_update_submenu (carbon_item, GTK_WIDGET (object),
+                                       DEBUG_SIGNAL);
     }
-    else if (DEBUG)
-       g_printerr("%s: Invalid parameter specification %s\n", G_STRFUNC, 
-                  pspec->name);
+  else if (DEBUG)
+    g_printerr ("%s: Invalid parameter specification %s\n", G_STRFUNC,
+                pspec->name);
 }
 
 static void
 carbon_menu_item_notify_label (GObject *object, GParamSpec *pspec,
-                              gpointer data) {
-    CarbonMenuItem *carbon_item = 
-       carbon_menu_item_get_checked (GTK_WIDGET (object));
-    const gchar *label_text = get_menu_label_text(GTK_WIDGET(object), NULL);
-
-    if (!carbon_item) {
-       if (DEBUG_CARBON)
-           g_printerr("%s: Bad carbon item for %s\n", G_STRFUNC, label_text);
-       return;
+                               gpointer data)
+{
+  CarbonMenuItem *carbon_item =
+    carbon_menu_item_get_checked (GTK_WIDGET (object));
+  const gchar *label_text = get_menu_label_text (GTK_WIDGET (object), NULL);
+
+  if (!carbon_item)
+    {
+      if (DEBUG_CARBON)
+        g_printerr ("%s: Bad carbon item for %s\n", G_STRFUNC, label_text);
+      return;
     }
-   if (!strcmp (pspec->name, "label")) {
-       carbon_menu_item_update_label (carbon_item, GTK_WIDGET (object));
+  if (!strcmp (pspec->name, "label"))
+    {
+      carbon_menu_item_update_label (carbon_item, GTK_WIDGET (object));
     }
-    else if (!strcmp (pspec->name, "accel-closure")) {
-       carbon_menu_item_update_accel_closure (carbon_item, 
-                                              GTK_WIDGET (object));
+  else if (!strcmp (pspec->name, "accel-closure"))
+    {
+      carbon_menu_item_update_accel_closure (carbon_item,
+                                             GTK_WIDGET (object));
     }
 }
 
 static CarbonMenuItem *
 carbon_menu_item_connect (GtkWidget *menu_item, GtkWidget *label,
-                         MenuRef menu, MenuItemIndex index) {
-    CarbonMenuItem *carbon_item = 
-       carbon_menu_item_get_checked (menu_item);
-
-    if (!carbon_item) {
-       carbon_item = carbon_menu_item_new ();
-       g_object_set_qdata_full (G_OBJECT (menu_item), carbon_menu_item_quark,
-                                carbon_item,
-                                (GDestroyNotify) carbon_menu_item_free);
-       g_signal_connect (menu_item, "notify",
-                         G_CALLBACK (carbon_menu_item_notify), carbon_item);
-       if (label)
-           g_signal_connect_swapped(label, "notify::label",
-                                    G_CALLBACK (carbon_menu_item_notify_label),
-                                    menu_item);
+                          MenuRef menu, MenuItemIndex index)
+{
+  CarbonMenuItem *carbon_item =
+    carbon_menu_item_get_checked (menu_item);
+
+  if (!carbon_item)
+    {
+      carbon_item = carbon_menu_item_new ();
+      g_object_set_qdata_full (G_OBJECT (menu_item), carbon_menu_item_quark,
+                               carbon_item,
+                               (GDestroyNotify) carbon_menu_item_free);
+      g_signal_connect (menu_item, "notify",
+                        G_CALLBACK (carbon_menu_item_notify), carbon_item);
+      if (label)
+        g_signal_connect_swapped (label, "notify::label",
+                                  G_CALLBACK (carbon_menu_item_notify_label),
+                                  menu_item);
     }
-    carbon_item->menu  = menu;
-    carbon_item->index = index;
-    return carbon_item;
+  carbon_item->menu  = menu;
+  carbon_item->index = index;
+  return carbon_item;
 }
 
 static CarbonMenuItem *
 carbon_menu_item_create (GtkWidget *menu_item, MenuRef carbon_menu,
-                        MenuItemIndex index, bool debug) {
-    GtkWidget          *label      = NULL;
-    const gchar        *label_text;
-    CFStringRef         cfstr      = NULL;
-    MenuItemAttributes  attributes = 0;
-    CarbonMenuItem *carbon_item;
-    OSStatus err;
-
-    label_text = get_menu_label_text (menu_item, &label);
-    if (debug)
-       g_printerr ("%s:   -> creating new %s\n", G_STRFUNC, label_text);
-    if (label_text)
-       cfstr = CFStringCreateWithCString (NULL, label_text,
-                                          kCFStringEncodingUTF8);
-    if (GTK_IS_SEPARATOR_MENU_ITEM (menu_item))
-       attributes |= kMenuItemAttrSeparator;
-    if (!gtk_widget_get_sensitive(menu_item))
-       attributes |= kMenuItemAttrDisabled;
-    if (!gtk_widget_get_visible (menu_item))
-       attributes |= kMenuItemAttrHidden;
-    err = InsertMenuItemTextWithCFString (carbon_menu, cfstr, index - 1,
-                                         attributes, 0);
-    carbon_menu_err_return_label_val(err, label_text, 
-                                    "Failed to insert menu item", NULL);
-    err = SetMenuItemProperty (carbon_menu, index,
-                              GTK_QUARTZ_MENU_CREATOR,
-                              GTK_QUARTZ_ITEM_WIDGET,
-                              sizeof (menu_item), &menu_item);
-
-    if (cfstr)
-       CFRelease (cfstr);
-    if (err) {
-       carbon_menu_warn_label(err, label_text,
-                                  "Failed to set menu property");
-       DeleteMenuItem(carbon_menu, index); //Clean up the extra menu item
-       return NULL;
+                         MenuItemIndex index, bool debug)
+{
+  GtkWidget          *label      = NULL;
+  const gchar        *label_text;
+  CFStringRef         cfstr      = NULL;
+  MenuItemAttributes  attributes = 0;
+  CarbonMenuItem *carbon_item;
+  OSStatus err;
+
+  label_text = get_menu_label_text (menu_item, &label);
+  if (debug)
+    g_printerr ("%s:   -> creating new %s\n", G_STRFUNC, label_text);
+  if (label_text)
+    cfstr = CFStringCreateWithCString (NULL, label_text,
+                                       kCFStringEncodingUTF8);
+  if (GTK_IS_SEPARATOR_MENU_ITEM (menu_item))
+    attributes |= kMenuItemAttrSeparator;
+  if (!gtk_widget_get_sensitive (menu_item))
+    attributes |= kMenuItemAttrDisabled;
+  if (!gtk_widget_get_visible (menu_item))
+    attributes |= kMenuItemAttrHidden;
+  err = InsertMenuItemTextWithCFString (carbon_menu, cfstr, index - 1,
+                                        attributes, 0);
+  carbon_menu_err_return_label_val (err, label_text,
+                                    "Failed to insert menu item", NULL);
+  err = SetMenuItemProperty (carbon_menu, index,
+                             GTK_QUARTZ_MENU_CREATOR,
+                             GTK_QUARTZ_ITEM_WIDGET,
+                             sizeof (menu_item), &menu_item);
+
+  if (cfstr)
+    CFRelease (cfstr);
+  if (err)
+    {
+      carbon_menu_warn_label (err, label_text,
+                              "Failed to set menu property");
+      DeleteMenuItem (carbon_menu, index); //Clean up the extra menu item
+      return NULL;
     }
-    carbon_item = carbon_menu_item_connect (menu_item, label,
-                                           carbon_menu,
-                                           index);
-    if (!carbon_item) { //Got a bad carbon_item, bail out
-       DeleteMenuItem(carbon_menu, index); //Clean up the extra menu item
-       return carbon_item;
+  carbon_item = carbon_menu_item_connect (menu_item, label,
+                                          carbon_menu,
+                                          index);
+  if (!carbon_item)   //Got a bad carbon_item, bail out
+    {
+      DeleteMenuItem (carbon_menu, index); //Clean up the extra menu item
+      return carbon_item;
     }
-    return carbon_item;
+  return carbon_item;
 }
 
 
-typedef struct {
-    GtkWidget *widget;
+typedef struct
+{
+  GtkWidget *widget;
 } ActivateIdleData;
 
 static void
-activate_destroy_cb (gpointer user_data) {
-    ActivateIdleData *data = user_data;
-
-    if (data->widget)
-       g_object_remove_weak_pointer (G_OBJECT (data->widget), 
-                                     (gpointer) &data->widget);
-    g_free (data);
+activate_destroy_cb (gpointer user_data)
+{
+  ActivateIdleData *data = user_data;
+
+  if (data->widget)
+    g_object_remove_weak_pointer (G_OBJECT (data->widget),
+                                  (gpointer) &data->widget);
+  g_free (data);
 }
 
 static gboolean
-activate_idle_cb (gpointer user_data) {
-    ActivateIdleData *data = user_data;
+activate_idle_cb (gpointer user_data)
+{
+  ActivateIdleData *data = user_data;
 
-    if (data->widget)
-       gtk_menu_item_activate (GTK_MENU_ITEM (data->widget));
-    return FALSE;
+  if (data->widget)
+    gtk_menu_item_activate (GTK_MENU_ITEM (data->widget));
+  return FALSE;
 }
 
 /*
@@ -676,304 +729,330 @@ activate_idle_cb (gpointer user_data) {
 
 static OSStatus
 menu_event_handler_func (EventHandlerCallRef  event_handler_call_ref,
-                        EventRef event_ref, void *data) {
-    UInt32 event_class = GetEventClass (event_ref);
-    UInt32 event_kind = GetEventKind (event_ref);
-    HICommand command;
-    OSStatus  err;
-    GtkWidget *widget = NULL;
-    ActivateIdleData *idleData;
-
-    switch (event_class) {
+                         EventRef event_ref, void *data)
+{
+  UInt32 event_class = GetEventClass (event_ref);
+  UInt32 event_kind = GetEventKind (event_ref);
+  HICommand command;
+  OSStatus  err;
+  GtkWidget *widget = NULL;
+  ActivateIdleData *idleData;
+
+  switch (event_class)
+    {
     case kEventClassCommand:
-       /* This is called when activating (is that the right GTK+ term?)
-        * a menu item.
-        */
-       if (event_kind != kEventCommandProcess)
-           break;
+      /* This is called when activating (is that the right GTK+ term?)
+       * a menu item.
+       */
+      if (event_kind != kEventCommandProcess)
+        break;
 
 #if DEBUG
-       g_printerr ("Menu: kEventClassCommand/kEventCommandProcess\n");
+      g_printerr ("Menu: kEventClassCommand/kEventCommandProcess\n");
 #endif
-       err = GetEventParameter (event_ref, kEventParamDirectObject,
-                                typeHICommand, 0,
-                                sizeof (command), 0, &command);
-       if (err != noErr) {
-           carbon_menu_warn(err, "Get Event Returned Error");
-           break;
-       }
-       /* Get any GtkWidget associated with the item. */
-       err = GetMenuItemProperty (command.menu.menuRef,
-                                  command.menu.menuItemIndex,
-                                  GTK_QUARTZ_MENU_CREATOR,
-                                  GTK_QUARTZ_ITEM_WIDGET,
-                                  sizeof (widget), 0, &widget);
-       if (err != noErr) {
-           carbon_menu_warn(err, "Failed to retrieve the widget associated with the menu item");
-           break;
-       }
-       if (! GTK_IS_WIDGET (widget)) {
-           g_printerr("The item associated with the menu item isn't a widget\n");
-           break;
-       }
-       /* Activate from an idle handler so that the event is
-        * emitted from the main loop instead of in the middle of
-        * handling quartz events.
-        */
-       idleData = g_new0 (ActivateIdleData, 1);
-       idleData->widget= widget;
-       g_object_add_weak_pointer (G_OBJECT (widget), 
-                                  (gpointer) &idleData->widget);
-       g_idle_add_full (G_PRIORITY_HIGH, activate_idle_cb,
-                        idleData, activate_destroy_cb);
-       return noErr;
-       break;
+      err = GetEventParameter (event_ref, kEventParamDirectObject,
+                               typeHICommand, 0,
+                               sizeof (command), 0, &command);
+      if (err != noErr)
+        {
+          carbon_menu_warn (err, "Get Event Returned Error");
+          break;
+        }
+      /* Get any GtkWidget associated with the item. */
+      err = GetMenuItemProperty (command.menu.menuRef,
+                                 command.menu.menuItemIndex,
+                                 GTK_QUARTZ_MENU_CREATOR,
+                                 GTK_QUARTZ_ITEM_WIDGET,
+                                 sizeof (widget), 0, &widget);
+      if (err != noErr)
+        {
+          carbon_menu_warn (err, "Failed to retrieve the widget associated with the menu item");
+          break;
+        }
+      if (! GTK_IS_WIDGET (widget))
+        {
+          g_printerr ("The item associated with the menu item isn't a widget\n");
+          break;
+        }
+      /* Activate from an idle handler so that the event is
+       * emitted from the main loop instead of in the middle of
+       * handling quartz events.
+       */
+      idleData = g_new0 (ActivateIdleData, 1);
+      idleData->widget = widget;
+      g_object_add_weak_pointer (G_OBJECT (widget),
+                                 (gpointer) &idleData->widget);
+      g_idle_add_full (G_PRIORITY_HIGH, activate_idle_cb,
+                       idleData, activate_destroy_cb);
+      return noErr;
+      break;
     case kEventClassMenu:
-       if (event_kind == kEventMenuEndTracking)
-           g_idle_add (menu_flash_off_cb, NULL);
-       break;
+      if (event_kind == kEventMenuEndTracking)
+        g_idle_add (menu_flash_off_cb, NULL);
+      break;
     default:
-       break;
+      break;
     }
-    return eventNotHandledErr;
+  return eventNotHandledErr;
 }
 
 static gboolean
-nsevent_handle_menu_key (NSEvent *nsevent) {
-    EventRef      event_ref;
-    MenuRef       menu_ref;
-    MenuItemIndex index;
-    MenuCommand menu_command;
-    HICommand   hi_command;
-   OSStatus err;
-
-    if ([nsevent type] != NSKeyDown)
-       return FALSE;
-    event_ref = [nsevent gdk_quartz_event_ref];
-    if (!IsMenuKeyEvent (NULL, event_ref, kMenuEventQueryOnly, 
-                       &menu_ref, &index)) 
-       return FALSE;
-    err = GetMenuItemCommandID (menu_ref, index, &menu_command);
-    carbon_menu_err_return_val(err, "Failed to get command id", FALSE);
-    hi_command.commandID = menu_command;
-    hi_command.menu.menuRef = menu_ref;
-    hi_command.menu.menuItemIndex = index;
-    err = CreateEvent (NULL, kEventClassCommand, kEventCommandProcess,
-                      0, kEventAttributeUserEvent, &event_ref);
-    carbon_menu_err_return_val(err, "Failed to create event", FALSE);
-    err = SetEventParameter (event_ref, kEventParamDirectObject, typeHICommand,
-                            sizeof (HICommand), &hi_command);
-    if (err != noErr)
-       ReleaseEvent(event_ref); //We're about to bail, don't want to leak
-     carbon_menu_err_return_val(err, "Failed to set event parm", FALSE);
-    FlashMenuBar (GetMenuID (menu_ref));
-    g_timeout_add (30, menu_flash_off_cb, NULL);
-    err = SendEventToEventTarget (event_ref, GetMenuEventTarget (menu_ref));
-    ReleaseEvent (event_ref);
-    carbon_menu_err_return_val(err, "Failed to send event", FALSE);
-    return TRUE;
+nsevent_handle_menu_key (NSEvent *nsevent)
+{
+  EventRef      event_ref;
+  MenuRef       menu_ref;
+  MenuItemIndex index;
+  MenuCommand menu_command;
+  HICommand   hi_command;
+  OSStatus err;
+
+  if ([nsevent type] != NSKeyDown)
+    return FALSE;
+  event_ref = [nsevent gdk_quartz_event_ref];
+  if (!IsMenuKeyEvent (NULL, event_ref, kMenuEventQueryOnly,
+                       &menu_ref, &index))
+    return FALSE;
+  err = GetMenuItemCommandID (menu_ref, index, &menu_command);
+  carbon_menu_err_return_val (err, "Failed to get command id", FALSE);
+  hi_command.commandID = menu_command;
+  hi_command.menu.menuRef = menu_ref;
+  hi_command.menu.menuItemIndex = index;
+  err = CreateEvent (NULL, kEventClassCommand, kEventCommandProcess,
+                     0, kEventAttributeUserEvent, &event_ref);
+  carbon_menu_err_return_val (err, "Failed to create event", FALSE);
+  err = SetEventParameter (event_ref, kEventParamDirectObject, typeHICommand,
+                           sizeof (HICommand), &hi_command);
+  if (err != noErr)
+    ReleaseEvent (event_ref); //We're about to bail, don't want to leak
+  carbon_menu_err_return_val (err, "Failed to set event parm", FALSE);
+  FlashMenuBar (GetMenuID (menu_ref));
+  g_timeout_add (30, menu_flash_off_cb, NULL);
+  err = SendEventToEventTarget (event_ref, GetMenuEventTarget (menu_ref));
+  ReleaseEvent (event_ref);
+  carbon_menu_err_return_val (err, "Failed to send event", FALSE);
+  return TRUE;
 }
 
 gboolean
-gtk_mac_menu_handle_menu_event (GdkEventKey *event) {
-    NSEvent *nsevent;
-
-    /* FIXME: If the event here is unallocated, we crash. */
-    nsevent = gdk_quartz_event_get_nsevent ((GdkEvent *) event);
-    if (nsevent)
-       return nsevent_handle_menu_key (nsevent);
-    return FALSE;
+gtk_mac_menu_handle_menu_event (GdkEventKey *event)
+{
+  NSEvent *nsevent;
+
+  /* FIXME: If the event here is unallocated, we crash. */
+  nsevent = gdk_quartz_event_get_nsevent ((GdkEvent *) event);
+  if (nsevent)
+    return nsevent_handle_menu_key (nsevent);
+  return FALSE;
 }
 
 static GdkFilterReturn
 global_event_filter_func (gpointer  windowing_event, GdkEvent *event,
-                          gpointer  user_data) {
-    NSEvent *nsevent = windowing_event;
-
-    /* Handle menu events with no window, since they won't go through the
-     * regular event processing.
-     */
-    if ([nsevent window] == nil) {
-       if (nsevent_handle_menu_key (nsevent))
-           return GDK_FILTER_REMOVE;
+                          gpointer  user_data)
+{
+  NSEvent *nsevent = windowing_event;
+
+  /* Handle menu events with no window, since they won't go through the
+   * regular event processing.
+   */
+  if ([nsevent window] == nil)
+    {
+      if (nsevent_handle_menu_key (nsevent))
+        return GDK_FILTER_REMOVE;
     }
-    else if (global_key_handler_enabled && [nsevent type] == NSKeyDown) {
-       GList *toplevels, *l;
-       GtkWindow *focus = NULL;
-
-       toplevels = gtk_window_list_toplevels ();
-       for (l = toplevels; l; l = l->next) {
-           if (gtk_window_has_toplevel_focus (l->data)) {
-               focus = l->data;
-               break;
+  else if (global_key_handler_enabled && [nsevent type] == NSKeyDown)
+    {
+      GList *toplevels, *l;
+      GtkWindow *focus = NULL;
+
+      toplevels = gtk_window_list_toplevels ();
+      for (l = toplevels; l; l = l->next)
+        {
+          if (gtk_window_has_toplevel_focus (l->data))
+            {
+              focus = l->data;
+              break;
             }
         }
-       g_list_free (toplevels);
-
-       /* FIXME: We could do something to skip menu events if there is a
-        * modal dialog...
-        */
-       if (!focus 
-           || !g_object_get_data (G_OBJECT (focus), GTK_MAC_KEY_HANDLER)) {
-           if (nsevent_handle_menu_key (nsevent))
-               return GDK_FILTER_REMOVE;
+      g_list_free (toplevels);
+
+      /* FIXME: We could do something to skip menu events if there is a
+       * modal dialog...
+       */
+      if (!focus
+          || !g_object_get_data (G_OBJECT (focus), GTK_MAC_KEY_HANDLER))
+        {
+          if (nsevent_handle_menu_key (nsevent))
+            return GDK_FILTER_REMOVE;
         }
     }
-    return GDK_FILTER_CONTINUE;
+  return GDK_FILTER_CONTINUE;
 }
 
 static gboolean
-key_press_event (GtkWidget   *widget, GdkEventKey *event, gpointer user_data) {
-    GtkWindow *window = GTK_WINDOW (widget);
-    GtkWidget *focus = gtk_window_get_focus (window);
-    gboolean handled = FALSE;
+key_press_event (GtkWidget   *widget, GdkEventKey *event, gpointer user_data)
+{
+  GtkWindow *window = GTK_WINDOW (widget);
+  GtkWidget *focus = gtk_window_get_focus (window);
+  gboolean handled = FALSE;
 
-    /* Text widgets get all key events first. */
-    if (GTK_IS_EDITABLE (focus) || GTK_IS_TEXT_VIEW (focus))
-       handled = gtk_window_propagate_key_event (window, event);
+  /* Text widgets get all key events first. */
+  if (GTK_IS_EDITABLE (focus) || GTK_IS_TEXT_VIEW (focus))
+    handled = gtk_window_propagate_key_event (window, event);
 
-    if (!handled)
-       handled = gtk_mac_menu_handle_menu_event (event);
+  if (!handled)
+    handled = gtk_mac_menu_handle_menu_event (event);
 
-    /* Invoke control/alt accelerators. */
-    if (!handled && event->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK))
-       handled = gtk_window_activate_key (window, event);
+  /* Invoke control/alt accelerators. */
+  if (!handled && event->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK))
+    handled = gtk_window_activate_key (window, event);
 
-    /* Invoke focus widget handlers. */
-    if (!handled)
-       handled = gtk_window_propagate_key_event (window, event);
+  /* Invoke focus widget handlers. */
+  if (!handled)
+    handled = gtk_window_propagate_key_event (window, event);
 
-    /* Invoke non-(control/alt) accelerators. */
-    if (!handled && !(event->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK)))
-       handled = gtk_window_activate_key (window, event);
+  /* Invoke non-(control/alt) accelerators. */
+  if (!handled && ! (event->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK)))
+    handled = gtk_window_activate_key (window, event);
 
-    return handled;
+  return handled;
 }
 
 static void
-setup_menu_event_handler (void) {
-    static gboolean is_setup = FALSE;
-
-    EventHandlerUPP menu_event_handler_upp;
-    EventHandlerRef menu_event_handler_ref;
-    OSStatus err;
-    const EventTypeSpec menu_events[] = {
-       { kEventClassCommand, kEventCommandProcess },
-       { kEventClassMenu, kEventMenuEndTracking }
-    };
-
-    if (is_setup)
-       return;
-    gdk_window_add_filter (NULL, global_event_filter_func, NULL);
-    menu_event_handler_upp = NewEventHandlerUPP (menu_event_handler_func);
-    err = InstallEventHandler (GetApplicationEventTarget (), 
-                              menu_event_handler_upp,
-                              GetEventTypeCount (menu_events), menu_events, 0,
-                              &menu_event_handler_ref);
-    carbon_menu_err_return(err, "Failed to install event handler");
+setup_menu_event_handler (void)
+{
+  static gboolean is_setup = FALSE;
+
+  EventHandlerUPP menu_event_handler_upp;
+  EventHandlerRef menu_event_handler_ref;
+  OSStatus err;
+  const EventTypeSpec menu_events[] =
+  {
+    { kEventClassCommand, kEventCommandProcess },
+    { kEventClassMenu, kEventMenuEndTracking }
+  };
+
+  if (is_setup)
+    return;
+  gdk_window_add_filter (NULL, global_event_filter_func, NULL);
+  menu_event_handler_upp = NewEventHandlerUPP (menu_event_handler_func);
+  err = InstallEventHandler (GetApplicationEventTarget (),
+                             menu_event_handler_upp,
+                             GetEventTypeCount (menu_events), menu_events, 0,
+                             &menu_event_handler_ref);
+  carbon_menu_err_return (err, "Failed to install event handler");
 #if 0
-    /* Note: If we want to supporting shutting down, remove the handler
-     * with:
-     */
-    err = RemoveEventHandler(menu_event_handler_ref);
-    carbon_menu_warn(err, "Failed to remove handler");
-    err = DisposeEventHandlerUPP(menu_event_handler_upp);
-    carbon_menu_warn(err, "Failed to elete menu handler UPP");
+  /* Note: If we want to supporting shutting down, remove the handler
+   * with:
+   */
+  err = RemoveEventHandler (menu_event_handler_ref);
+  carbon_menu_warn (err, "Failed to remove handler");
+  err = DisposeEventHandlerUPP (menu_event_handler_upp);
+  carbon_menu_warn (err, "Failed to elete menu handler UPP");
 #endif
-    is_setup = TRUE;
+  is_setup = TRUE;
 }
 
 static void
 sync_menu_shell (GtkMenuShell *menu_shell, MenuRef carbon_menu,
-                gboolean toplevel, gboolean debug) {
-    GList         *children;
-    GList         *l;
-    MenuItemIndex  carbon_index = 1;
-    OSStatus err;
-
-    if (debug)
-       g_printerr ("%s: syncing shell %s (%p)\n", G_STRFUNC, 
-                   get_menu_label_text(GTK_WIDGET(menu_shell), NULL),
-                   menu_shell);
-    carbon_menu_connect (GTK_WIDGET (menu_shell), carbon_menu, toplevel);
-    children = gtk_container_get_children (GTK_CONTAINER (menu_shell));
-    for (l = children; l; l = l->next) {
-       GtkWidget      *menu_item = l->data;
-       CarbonMenuItem *carbon_item;
-       MenuAttributes attrs;
-       const gchar *label = get_menu_label_text (menu_item, NULL);
-
-       if (GTK_IS_TEAROFF_MENU_ITEM (menu_item))
-           continue;
-       if (toplevel && (g_object_get_data (G_OBJECT (menu_item),
-                                           "gtk-empty-menu-item") 
-                        || GTK_IS_SEPARATOR_MENU_ITEM (menu_item)))
-           continue;
-       carbon_item = carbon_menu_item_get (menu_item);
-       if (debug)
-           g_printerr ("%s: carbon_item %d for menu_item %d (%s, %s)\n",
-                       G_STRFUNC, carbon_item ? carbon_item->index : -1,
-                       carbon_index, label,
-                       g_type_name (G_TYPE_FROM_INSTANCE (menu_item)));
-
-       if (carbon_item && carbon_item->index != carbon_index) {
-           if (carbon_item->index == carbon_index - 1) {
-               if (debug)
-                   g_printerr("%s: %s incrementing index\n", G_STRFUNC, label);
-               ++carbon_item->index;
-           } 
-           else if (carbon_item->index == carbon_index + 1) {
-               if (debug)
-                   g_printerr("%s: %s decrementing index\n", G_STRFUNC, label);
-               --carbon_item->index;
-           } 
-           else {
-               if (debug)
-                   g_printerr ("%s: %s -> not matching, deleting\n",
-                               G_STRFUNC, label);
-               DeleteMenuItem (carbon_item->menu, carbon_index);
-               carbon_item = NULL;
-           }
-       }
-       if (!carbon_item)
-           carbon_item = carbon_menu_item_create(menu_item, carbon_menu,
-                                                 carbon_index, debug);
-       if (!carbon_item) //Bad carbon item, give up
-           continue;
-       if (GTK_IS_CHECK_MENU_ITEM (menu_item))
-           carbon_menu_item_update_active (carbon_item, menu_item);
-       carbon_menu_item_update_accel_closure (carbon_item, menu_item);
-       if (gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu_item)))
-           carbon_menu_item_update_submenu (carbon_item, menu_item, debug);
-       else {
-           carbon_index++;
-           continue;
-       }
-
-/*The rest only applies to submenus, not to items which should have
- * been fixed up in carbon_menu_item_create
- */
-       err = GetMenuAttributes( carbon_item->submenu, &attrs);
-       carbon_menu_warn(err, "Failed to get menu attributes");
-       if (!gtk_widget_get_visible (menu_item)) {
-           if ((attrs & kMenuAttrHidden) == 0) {
-               if (debug)
-                   g_printerr("Hiding menu %s\n", label);
-               err = ChangeMenuAttributes (carbon_item->submenu, 
-                                           kMenuAttrHidden, 0);
-               carbon_menu_warn_label(err, label, "Failed to set visible");
-           }
-       }
-       else if ((attrs & kMenuAttrHidden) != 0) {
-           if (debug) 
-               g_printerr("Revealing menu %s\n", label);
-           err = ChangeMenuAttributes (carbon_item->submenu, 0, 
-                                           kMenuAttrHidden);
-           carbon_menu_warn_label(err, label, "Failed to set Hidden");
-       }
-       carbon_index++;
+                 gboolean toplevel, gboolean debug)
+{
+  GList         *children;
+  GList         *l;
+  MenuItemIndex  carbon_index = 1;
+  OSStatus err;
+
+  if (debug)
+    g_printerr ("%s: syncing shell %s (%p)\n", G_STRFUNC,
+                get_menu_label_text (GTK_WIDGET (menu_shell), NULL),
+                menu_shell);
+  carbon_menu_connect (GTK_WIDGET (menu_shell), carbon_menu, toplevel);
+  children = gtk_container_get_children (GTK_CONTAINER (menu_shell));
+  for (l = children; l; l = l->next)
+    {
+      GtkWidget      *menu_item = l->data;
+      CarbonMenuItem *carbon_item;
+      MenuAttributes attrs;
+      const gchar *label = get_menu_label_text (menu_item, NULL);
+
+      if (GTK_IS_TEAROFF_MENU_ITEM (menu_item))
+        continue;
+      if (toplevel && (g_object_get_data (G_OBJECT (menu_item),
+                                          "gtk-empty-menu-item")
+                       || GTK_IS_SEPARATOR_MENU_ITEM (menu_item)))
+        continue;
+      carbon_item = carbon_menu_item_get (menu_item);
+      if (debug)
+        g_printerr ("%s: carbon_item %d for menu_item %d (%s, %s)\n",
+                    G_STRFUNC, carbon_item ? carbon_item->index : -1,
+                    carbon_index, label,
+                    g_type_name (G_TYPE_FROM_INSTANCE (menu_item)));
+
+      if (carbon_item && carbon_item->index != carbon_index)
+        {
+          if (carbon_item->index == carbon_index - 1)
+            {
+              if (debug)
+                g_printerr ("%s: %s incrementing index\n", G_STRFUNC, label);
+              ++carbon_item->index;
+            }
+          else if (carbon_item->index == carbon_index + 1)
+            {
+              if (debug)
+                g_printerr ("%s: %s decrementing index\n", G_STRFUNC, label);
+              --carbon_item->index;
+            }
+          else
+            {
+              if (debug)
+                g_printerr ("%s: %s -> not matching, deleting\n",
+                            G_STRFUNC, label);
+              DeleteMenuItem (carbon_item->menu, carbon_index);
+              carbon_item = NULL;
+            }
+        }
+      if (!carbon_item)
+        carbon_item = carbon_menu_item_create (menu_item, carbon_menu,
+                                               carbon_index, debug);
+      if (!carbon_item) //Bad carbon item, give up
+        continue;
+      if (GTK_IS_CHECK_MENU_ITEM (menu_item))
+        carbon_menu_item_update_active (carbon_item, menu_item);
+      carbon_menu_item_update_accel_closure (carbon_item, menu_item);
+      if (gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu_item)))
+        carbon_menu_item_update_submenu (carbon_item, menu_item, debug);
+      else
+        {
+          carbon_index++;
+          continue;
+        }
+
+      /*The rest only applies to submenus, not to items which should have
+       * been fixed up in carbon_menu_item_create
+       */
+      err = GetMenuAttributes ( carbon_item->submenu, &attrs);
+      carbon_menu_warn (err, "Failed to get menu attributes");
+      if (!gtk_widget_get_visible (menu_item))
+        {
+          if ((attrs & kMenuAttrHidden) == 0)
+            {
+              if (debug)
+                g_printerr ("Hiding menu %s\n", label);
+              err = ChangeMenuAttributes (carbon_item->submenu,
+                                          kMenuAttrHidden, 0);
+              carbon_menu_warn_label (err, label, "Failed to set visible");
+            }
+        }
+      else if ((attrs & kMenuAttrHidden) != 0)
+        {
+          if (debug)
+            g_printerr ("Revealing menu %s\n", label);
+          err = ChangeMenuAttributes (carbon_item->submenu, 0,
+                                      kMenuAttrHidden);
+          carbon_menu_warn_label (err, label, "Failed to set Hidden");
+        }
+      carbon_index++;
     }
-    g_list_free (children);
+  g_list_free (children);
 }
 
 static gulong emission_hook_id    = 0;
@@ -981,66 +1060,74 @@ static gint   emission_hook_count = 0;
 
 static gboolean
 parent_set_emission_hook (GSignalInvocationHint *ihint, guint n_param_values,
-                         const GValue *param_values, gpointer data) {
-    GtkWidget *instance = g_value_get_object (param_values);
-    CarbonMenu *carbon_menu;
-    GtkWidget *previous_parent  = NULL;
-    GtkWidget *menu_shell = NULL;
-
-    if (!GTK_IS_MENU_ITEM (instance)) 
-       return TRUE;
-    previous_parent = g_value_get_object (param_values + 1);
-    if (GTK_IS_MENU_SHELL (previous_parent)) {
-       menu_shell = previous_parent;
+                          const GValue *param_values, gpointer data)
+{
+  GtkWidget *instance = g_value_get_object (param_values);
+  CarbonMenu *carbon_menu;
+  GtkWidget *previous_parent  = NULL;
+  GtkWidget *menu_shell = NULL;
+
+  if (!GTK_IS_MENU_ITEM (instance))
+    return TRUE;
+  previous_parent = g_value_get_object (param_values + 1);
+  if (GTK_IS_MENU_SHELL (previous_parent))
+    {
+      menu_shell = previous_parent;
     }
-    else if (GTK_IS_MENU_SHELL (gtk_widget_get_parent(instance))) {
-       menu_shell = gtk_widget_get_parent(instance);
+  else if (GTK_IS_MENU_SHELL (gtk_widget_get_parent (instance)))
+    {
+      menu_shell = gtk_widget_get_parent (instance);
     }
-    if (!menu_shell) 
-       return TRUE;
-    carbon_menu = carbon_menu_get (menu_shell);
+  if (!menu_shell)
+    return TRUE;
+  carbon_menu = carbon_menu_get (menu_shell);
 
-    if (!carbon_menu) 
-       return TRUE;
+  if (!carbon_menu)
+    return TRUE;
 #if DEBUG
-    g_printerr ("%s: item %s (%s) %s %s (%p)\n", G_STRFUNC,
-               get_menu_label_text (instance, NULL),
-               g_type_name (G_TYPE_FROM_INSTANCE (instance)),
-               previous_parent ? "removed from" : "added to",
-               get_menu_label_text(menu_shell, NULL),
-               menu_shell);
+  g_printerr ("%s: item %s (%s) %s %s (%p)\n", G_STRFUNC,
+              get_menu_label_text (instance, NULL),
+              g_type_name (G_TYPE_FROM_INSTANCE (instance)),
+              previous_parent ? "removed from" : "added to",
+              get_menu_label_text (menu_shell, NULL),
+              menu_shell);
 #endif
-    sync_menu_shell (GTK_MENU_SHELL (menu_shell), carbon_menu->menu,
-                    carbon_menu->toplevel, DEBUG_SIGNAL);
-    return TRUE;
+  sync_menu_shell (GTK_MENU_SHELL (menu_shell), carbon_menu->menu,
+                   carbon_menu->toplevel, DEBUG_SIGNAL);
+  return TRUE;
 }
 
 static void
-parent_set_emission_hook_remove (GtkWidget *widget, gpointer data) {
-    CarbonMenu *carbon_menu = carbon_menu_get(widget);
-    if (carbon_menu) {
-       MenuID id = GetMenuID(carbon_menu->menu);
-       ClearMenuBar();
-       DeleteMenu(id);
+parent_set_emission_hook_remove (GtkWidget *widget, gpointer data)
+{
+  CarbonMenu *carbon_menu = carbon_menu_get (widget);
+  if (carbon_menu)
+    {
+      MenuID id = GetMenuID (carbon_menu->menu);
+      ClearMenuBar ();
+      DeleteMenu (id);
     }
-    emission_hook_count--;
-    if (emission_hook_count > 0)
-       return;
-    g_signal_remove_emission_hook (
-       g_signal_lookup("parent-set", GTK_TYPE_WIDGET), emission_hook_id);
-    emission_hook_id = 0;
+  emission_hook_count--;
+  if (emission_hook_count > 0)
+    return;
+  g_signal_remove_emission_hook (
+    g_signal_lookup ("parent-set", GTK_TYPE_WIDGET), emission_hook_id);
+  emission_hook_id = 0;
 }
 
 static gboolean
-window_focus(GtkWindow *window, GdkEventFocus *event, CarbonMenu *menu) {
-    OSStatus err = SetRootMenu(menu->menu);
-    if (err) {
-       carbon_menu_warn(err, "Failed to transfer menu");
+window_focus (GtkWindow *window, GdkEventFocus *event, CarbonMenu *menu)
+{
+  OSStatus err = SetRootMenu (menu->menu);
+  if (err)
+    {
+      carbon_menu_warn (err, "Failed to transfer menu");
     }
-    else if (DEBUG){
-       g_printerr("%s: Switched Menu\n", G_STRFUNC);
+  else if (DEBUG)
+    {
+      g_printerr ("%s: Switched Menu\n", G_STRFUNC);
     }
-    return FALSE;
+  return FALSE;
 }
 
 
@@ -1049,83 +1136,89 @@ window_focus(GtkWindow *window, GdkEventFocus *event, CarbonMenu *menu) {
  */
 
 void
-gtk_mac_menu_set_menu_bar (GtkMenuShell *menu_shell) {
-    CarbonMenu *current_menu;
-    MenuRef     carbon_menubar;
-    OSStatus    err;
-    GtkWidget *parent = gtk_widget_get_toplevel(GTK_WIDGET(menu_shell));
-
-    g_return_if_fail (GTK_IS_MENU_SHELL (menu_shell));
-    if (carbon_menu_quark == 0)
-       carbon_menu_quark = g_quark_from_static_string ("CarbonMenu");
-    if (carbon_menu_item_quark == 0)
-       carbon_menu_item_quark = g_quark_from_static_string ("CarbonMenuItem");
-    current_menu = carbon_menu_get (GTK_WIDGET (menu_shell));
-    if (current_menu) {
-       err = SetRootMenu (current_menu->menu);
-       carbon_menu_warn(err, "Failed to set root menu");
-       return;
+gtk_mac_menu_set_menu_bar (GtkMenuShell *menu_shell)
+{
+  CarbonMenu *current_menu;
+  MenuRef     carbon_menubar;
+  OSStatus    err;
+  GtkWidget *parent = gtk_widget_get_toplevel (GTK_WIDGET (menu_shell));
+
+  g_return_if_fail (GTK_IS_MENU_SHELL (menu_shell));
+  if (carbon_menu_quark == 0)
+    carbon_menu_quark = g_quark_from_static_string ("CarbonMenu");
+  if (carbon_menu_item_quark == 0)
+    carbon_menu_item_quark = g_quark_from_static_string ("CarbonMenuItem");
+  current_menu = carbon_menu_get (GTK_WIDGET (menu_shell));
+  if (current_menu)
+    {
+      err = SetRootMenu (current_menu->menu);
+      carbon_menu_warn (err, "Failed to set root menu");
+      return;
     }
-    err = CreateNewMenu (++last_menu_id /*id*/, 0 /*options*/, &carbon_menubar);
-    carbon_menu_err_return(err, "Failed to create menu");
-    err = SetRootMenu (carbon_menubar);
-    carbon_menu_err_return(err, "Failed to set root menu");
-    setup_menu_event_handler ();
-    if (emission_hook_id == 0) {
-       emission_hook_id =
-           g_signal_add_emission_hook(
-               g_signal_lookup("parent-set", GTK_TYPE_WIDGET), 0,
-               parent_set_emission_hook, NULL, NULL);
+  err = CreateNewMenu (++last_menu_id /*id*/, 0 /*options*/, &carbon_menubar);
+  carbon_menu_err_return (err, "Failed to create menu");
+  err = SetRootMenu (carbon_menubar);
+  carbon_menu_err_return (err, "Failed to set root menu");
+  setup_menu_event_handler ();
+  if (emission_hook_id == 0)
+    {
+      emission_hook_id =
+        g_signal_add_emission_hook (
+          g_signal_lookup ("parent-set", GTK_TYPE_WIDGET), 0,
+          parent_set_emission_hook, NULL, NULL);
     }
-    emission_hook_count++;
-    g_signal_connect (menu_shell, "destroy",
-                     G_CALLBACK (parent_set_emission_hook_remove), NULL);
+  emission_hook_count++;
+  g_signal_connect (menu_shell, "destroy",
+                    G_CALLBACK (parent_set_emission_hook_remove), NULL);
 
 #if DEBUG_SET
-    g_printerr ("%s: syncing menubar\n", G_STRFUNC);
+  g_printerr ("%s: syncing menubar\n", G_STRFUNC);
 #endif
-    sync_menu_shell (menu_shell, carbon_menubar, TRUE, DEBUG_SET);
-    if (parent)
-       g_signal_connect (parent, "focus-in-event",
-                         G_CALLBACK(window_focus), 
-                         carbon_menu_get(GTK_WIDGET(menu_shell)));
+  sync_menu_shell (menu_shell, carbon_menubar, TRUE, DEBUG_SET);
+  if (parent)
+    g_signal_connect (parent, "focus-in-event",
+                      G_CALLBACK (window_focus),
+                      carbon_menu_get (GTK_WIDGET (menu_shell)));
 
 }
 
 void
-gtk_mac_menu_set_quit_menu_item (GtkMenuItem *menu_item) {
-    MenuRef       appmenu;
-    MenuItemIndex index;
-    OSStatus err;
-
-    g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
-    setup_menu_event_handler ();
-    err = GetIndMenuItemWithCommandID (NULL, kHICommandQuit, 1,
-                                       &appmenu, &index);
-    carbon_menu_err_return(err, "Failed to obtain Quit Menu");
-    err = SetMenuItemCommandID (appmenu, index, 0);
-    carbon_menu_err_return(err, 
-                          "Failed to set Quit menu command id");
-    err = SetMenuItemProperty (appmenu, index, GTK_QUARTZ_MENU_CREATOR,
-                              GTK_QUARTZ_ITEM_WIDGET, sizeof (menu_item), 
-                              &menu_item);
-    carbon_menu_err_return(err, 
-                          "Failed to associate Quit menu item");
-    gtk_widget_hide (GTK_WIDGET (menu_item));
-    return;
+gtk_mac_menu_set_quit_menu_item (GtkMenuItem *menu_item)
+{
+  MenuRef       appmenu;
+  MenuItemIndex index;
+  OSStatus err;
+
+  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
+  setup_menu_event_handler ();
+  err = GetIndMenuItemWithCommandID (NULL, kHICommandQuit, 1,
+                                     &appmenu, &index);
+  carbon_menu_err_return (err, "Failed to obtain Quit Menu");
+  err = SetMenuItemCommandID (appmenu, index, 0);
+  carbon_menu_err_return (err,
+                          "Failed to set Quit menu command id");
+  err = SetMenuItemProperty (appmenu, index, GTK_QUARTZ_MENU_CREATOR,
+                             GTK_QUARTZ_ITEM_WIDGET, sizeof (menu_item),
+                             &menu_item);
+  carbon_menu_err_return (err,
+                          "Failed to associate Quit menu item");
+  gtk_widget_hide (GTK_WIDGET (menu_item));
+  return;
 }
 
 void
-gtk_mac_menu_connect_window_key_handler (GtkWindow *window) {
-    if (g_object_get_data (G_OBJECT (window), GTK_MAC_KEY_HANDLER)) {
-       g_warning ("Window %p is already connected", window);
-       return;
+gtk_mac_menu_connect_window_key_handler (GtkWindow *window)
+{
+  if (g_object_get_data (G_OBJECT (window), GTK_MAC_KEY_HANDLER))
+    {
+      g_warning ("Window %p is already connected", window);
+      return;
     }
 
-    g_signal_connect (window, "key-press-event", 
-                     G_CALLBACK (key_press_event), NULL);
-    g_object_set_data (G_OBJECT (window), GTK_MAC_KEY_HANDLER, 
-                      GINT_TO_POINTER (1));
+  g_signal_connect (window, "key-press-event",
+                    G_CALLBACK (key_press_event), NULL);
+  g_object_set_data (G_OBJECT (window), GTK_MAC_KEY_HANDLER,
+                     GINT_TO_POINTER (1));
 }
 
 /* Most applications will want to have this enabled (which is the
@@ -1133,21 +1226,23 @@ gtk_mac_menu_connect_window_key_handler (GtkWindow *window) {
  * global handling can be disabled.
  */
 void
-gtk_mac_menu_set_global_key_handler_enabled (gboolean enabled) {
-    global_key_handler_enabled = enabled;
+gtk_mac_menu_set_global_key_handler_enabled (gboolean enabled)
+{
+  global_key_handler_enabled = enabled;
 }
 
 /* For testing use only. Returns TRUE if there is a GtkMenuItem assigned to
  * the Quit menu item.
  */
 gboolean
-_gtk_mac_menu_is_quit_menu_item_handled (void) {
-    MenuRef       appmenu;
-    MenuItemIndex index;
-    OSStatus err = GetIndMenuItemWithCommandID (NULL, kHICommandQuit, 1,
-                                               &appmenu, &index);
-    carbon_menu_warn(err, "failed with");
-    return (err == noErr);
+_gtk_mac_menu_is_quit_menu_item_handled (void)
+{
+  MenuRef       appmenu;
+  MenuItemIndex index;
+  OSStatus err = GetIndMenuItemWithCommandID (NULL, kHICommandQuit, 1,
+                 &appmenu, &index);
+  carbon_menu_warn (err, "failed with");
+  return (err == noErr);
 }
 
 /* Application Menu Functions
@@ -1159,21 +1254,23 @@ _gtk_mac_menu_is_quit_menu_item_handled (void) {
  * (and others, if they want) from their Gtk locations to the app
  * menu.
  */
-struct _GtkMacMenuGroup {
-    GList *items;
+struct _GtkMacMenuGroup
+{
+  GList *items;
 };
 /* app_menu_groups is a list of GtkMacMenuGroups, itself a list of
  * menu_items. They're provided to insert separators into the app
- * menu, grouping the items. 
+ * menu, grouping the items.
 */
 static GList *app_menu_groups = NULL;
 
 GtkMacMenuGroup *
-gtk_mac_menu_add_app_menu_group (void) {
-    GtkMacMenuGroup *group = g_slice_new0 (GtkMacMenuGroup);
+gtk_mac_menu_add_app_menu_group (void)
+{
+  GtkMacMenuGroup *group = g_slice_new0 (GtkMacMenuGroup);
 
-    app_menu_groups = g_list_append (app_menu_groups, group);
-    return group;
+  app_menu_groups = g_list_append (app_menu_groups, group);
+  return group;
 }
 
 /**
@@ -1191,62 +1288,65 @@ gtk_mac_menu_add_app_menu_group (void) {
  */
 void
 gtk_mac_menu_add_app_menu_item (GtkMacMenuGroup *group, GtkMenuItem *menu_item,
-                               const gchar *label) {
-    MenuRef  appmenu;
-    GList   *list;
-    gint     index = 0;
-    CFStringRef cfstr;
-    OSStatus err;
-
-    g_return_if_fail (group != NULL);
-    g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
-    setup_menu_event_handler ();
-    err = GetIndMenuItemWithCommandID (NULL, kHICommandHide, 1,
-                                      &appmenu, NULL);
-    carbon_menu_err_return(err, "retrieving app menu failed");
-    for (list = app_menu_groups; list; list = g_list_next (list)) {
-       GtkMacMenuGroup *list_group = list->data;
-
-       index += g_list_length (list_group->items);
-       /*  adjust index for the separator between groups, but not
-        *  before the first group
-        */
-       if (list_group->items && list->prev)
-           index++;
-       if (group != list_group) 
-           continue;
-
-       /*  add a separator before adding the first item, but not
-        *  for the first group
-        */
-       if (!group->items && list->prev) {
-           err = InsertMenuItemTextWithCFString (appmenu, NULL, index,
-                                                 kMenuItemAttrSeparator, 0);
-           carbon_menu_err_return(err, "Failed to add separator");
-           index++;
-       }
-       if (!label)
-           label = get_menu_label_text (GTK_WIDGET (menu_item), NULL);
-       cfstr = CFStringCreateWithCString (NULL, label,
-                                          kCFStringEncodingUTF8);
+                                const gchar *label)
+{
+  MenuRef  appmenu;
+  GList   *list;
+  gint     index = 0;
+  CFStringRef cfstr;
+  OSStatus err;
+
+  g_return_if_fail (group != NULL);
+  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
+  setup_menu_event_handler ();
+  err = GetIndMenuItemWithCommandID (NULL, kHICommandHide, 1,
+                                     &appmenu, NULL);
+  carbon_menu_err_return (err, "retrieving app menu failed");
+  for (list = app_menu_groups; list; list = g_list_next (list))
+    {
+      GtkMacMenuGroup *list_group = list->data;
+
+      index += g_list_length (list_group->items);
+      /*  adjust index for the separator between groups, but not
+       *  before the first group
+       */
+      if (list_group->items && list->prev)
+        index++;
+      if (group != list_group)
+        continue;
+
+      /*  add a separator before adding the first item, but not
+       *  for the first group
+       */
+      if (!group->items && list->prev)
+        {
+          err = InsertMenuItemTextWithCFString (appmenu, NULL, index,
+                                                kMenuItemAttrSeparator, 0);
+          carbon_menu_err_return (err, "Failed to add separator");
+          index++;
+        }
+      if (!label)
+        label = get_menu_label_text (GTK_WIDGET (menu_item), NULL);
+      cfstr = CFStringCreateWithCString (NULL, label,
+                                         kCFStringEncodingUTF8);
 //Add a new menu item and associate it with the GtkMenuItem.
-       err = InsertMenuItemTextWithCFString (appmenu, cfstr, index, 0, 0);
-       carbon_menu_err_return(err, "Failed to add menu item");
-       err = SetMenuItemProperty (appmenu, index + 1,
-                                  GTK_QUARTZ_MENU_CREATOR,
-                                  GTK_QUARTZ_ITEM_WIDGET,
-                                  sizeof (menu_item), &menu_item);
-       CFRelease (cfstr);
-       carbon_menu_err_return(err, "Failed to associate Gtk Widget");
-       gtk_widget_hide (GTK_WIDGET (menu_item));
+      err = InsertMenuItemTextWithCFString (appmenu, cfstr, index, 0, 0);
+      carbon_menu_err_return (err, "Failed to add menu item");
+      err = SetMenuItemProperty (appmenu, index + 1,
+                                 GTK_QUARTZ_MENU_CREATOR,
+                                 GTK_QUARTZ_ITEM_WIDGET,
+                                 sizeof (menu_item), &menu_item);
+      CFRelease (cfstr);
+      carbon_menu_err_return (err, "Failed to associate Gtk Widget");
+      gtk_widget_hide (GTK_WIDGET (menu_item));
 //Finally add the item to the group; this is really just for tracking the count.
-       group->items = g_list_append (group->items, menu_item);
+      group->items = g_list_append (group->items, menu_item);
 //Bail out: The rest of the menu doesn't matter.
-       return;
+      return;
 
     }
-    if (!list)
-       g_warning ("%s: app menu group %p does not exist", G_STRFUNC, group);
+  if (!list)
+    g_warning ("%s: app menu group %p does not exist", G_STRFUNC, group);
 }
 /**
  * gtk_mac_menu_sync:
@@ -1256,14 +1356,15 @@ gtk_mac_menu_add_app_menu_item (GtkMacMenuGroup *group, GtkMenuItem *menu_item,
  * GtkMenuBar to be synced.
  */
 void
-gtk_mac_menu_sync(GtkMenuShell *menu_shell) {
-    CarbonMenu *carbon_menu = carbon_menu_get (GTK_WIDGET(menu_shell));
-    g_return_if_fail(carbon_menu != NULL);
+gtk_mac_menu_sync (GtkMenuShell *menu_shell)
+{
+  CarbonMenu *carbon_menu = carbon_menu_get (GTK_WIDGET (menu_shell));
+  g_return_if_fail (carbon_menu != NULL);
 #if DEBUG_SYNC
-    g_printerr ("%s: syncing menubar\n", G_STRFUNC);
+  g_printerr ("%s: syncing menubar\n", G_STRFUNC);
 #endif
-    sync_menu_shell (menu_shell, carbon_menu->menu,
-                    carbon_menu->toplevel, DEBUG_SYNC);
+  sync_menu_shell (menu_shell, carbon_menu->menu,
+                   carbon_menu->toplevel, DEBUG_SYNC);
 }
 
 #endif __x86_64__
diff --git a/src/gtkosx-image.c b/src/gtkosx-image.c
index 668a6ed..0c5ed28 100644
--- a/src/gtkosx-image.c
+++ b/src/gtkosx-image.c
@@ -1,4 +1,4 @@
-/* GTK+ application-level integration for the Mac OS X/Cocoa 
+/* GTK+ application-level integration for the Mac OS X/Cocoa
  *
  * Copyright (C) 2007 Pioneer Research Center USA, Inc.
  * Copyright (C) 2007 Imendio AB
@@ -41,21 +41,21 @@
  * Returns: An autoreleased NSImage
  */
 NSImage*
-nsimage_from_resource(const gchar *name, const gchar* type, const gchar* subdir)
+nsimage_from_resource (const gchar *name, const gchar* type, const gchar* subdir)
 {
   NSString *ns_name, *ns_type, *ns_subdir, *path;
-  NSImage *image = NULL; 
-  g_return_val_if_fail(name != NULL, NULL);
-  g_return_val_if_fail(type != NULL, NULL);
-  g_return_val_if_fail(subdir != NULL, NULL);
+  NSImage *image = NULL;
+  g_return_val_if_fail (name != NULL, NULL);
+  g_return_val_if_fail (type != NULL, NULL);
+  g_return_val_if_fail (subdir != NULL, NULL);
 
   ns_name = [NSString stringWithUTF8String: name];
   ns_type = [NSString stringWithUTF8String: type];
   ns_subdir = [NSString stringWithUTF8String: subdir];
   path = [[NSApp mainBundle] pathForResource: ns_name
-                    ofType: ns_type inDirectory: ns_subdir];
-  if (path) 
-  image = [[[NSImage alloc] initWithContentsOfFile: path] autorelease];
+         ofType: ns_type inDirectory: ns_subdir];
+  if (path)
+    image = [[[NSImage alloc] initWithContentsOfFile: path] autorelease];
 
   return image;
 }
@@ -70,27 +70,27 @@ nsimage_from_resource(const gchar *name, const gchar* type, const gchar* subdir)
  * Returns: An auto-released NSImage*
  */
 NSImage*
-nsimage_from_pixbuf(GdkPixbuf *pixbuf)
+nsimage_from_pixbuf (GdkPixbuf *pixbuf)
 {
   CGImageRef image = NULL;
-  NSRect imageRect = NSMakeRect(0.0, 0.0, 0.0, 0.0);
+  NSRect imageRect = NSMakeRect (0.0, 0.0, 0.0, 0.0);
   CGContextRef imageContext = nil;
   NSImage* newImage = nil;
 
   g_return_val_if_fail (pixbuf !=  NULL, NULL);
   image = gtkosx_create_cgimage_from_pixbuf (pixbuf);
   // Get the image dimensions.
-  imageRect.size.height = CGImageGetHeight(image);
-  imageRect.size.width = CGImageGetWidth(image);
+  imageRect.size.height = CGImageGetHeight (image);
+  imageRect.size.width = CGImageGetWidth (image);
 
   // Create a new image to receive the Quartz image data.
-  newImage = [[[NSImage alloc] initWithSize:imageRect.size] autorelease];
+  newImage = [[[NSImage alloc] initWithSize: imageRect.size] autorelease];
   [newImage lockFocus];
 
   // Get the Quartz context and draw.
   imageContext = (CGContextRef)[[NSGraphicsContext currentContext]
-                               graphicsPort];
-  CGContextDrawImage(imageContext, *(CGRect*)&imageRect, image);
+                                graphicsPort];
+  CGContextDrawImage (imageContext, * (CGRect*)&imageRect, image);
   [newImage unlockFocus];
   CGImageRelease (image);
   return newImage;
diff --git a/src/gtkosxapplication.c b/src/gtkosxapplication.c
index 7f4ab75..1892697 100644
--- a/src/gtkosxapplication.c
+++ b/src/gtkosxapplication.c
@@ -40,9 +40,9 @@
  *
  * Using GtkosxApplication is pretty simple.
  * First, create an instance at startup:
- * 
+ *
  * |[GtkosxApplication *theApp = g_object_new(GTKOSX_TYPE_APPLICATION, NULL);]|
- * 
+ *
  * Do this early in your program, shortly after you run
  * |[gtk_init()]|. Don't forget to guard it, and all other calls into
  * the library, with |[#ifdef MAC_INTEGRATION]|. You don't want your
@@ -110,7 +110,7 @@
  *   return gtk_widget_is_sensitive(widget);
  * }
  * ...
- *   g_signal_connect(menubar, "can-activate-accel", 
+ *   g_signal_connect(menubar, "can-activate-accel",
  *                    G_CALLBACK(can_activate_cb), NULL);
  * </programlisting>
  * </example>
@@ -161,8 +161,8 @@
  * and change the menu (perhaps because of a context change within a
  * window, as with changing pages in a GtkNotebook) you need to call
  * |[gtkosx_application_sync_menubar(theApp)]|
- * 
- * 
+ *
+ *
  * * The dock is that bar of icons that normally lives at the bottom of
  * the display on a Mac (though it can be moved to one of the other
  * sides; this author likes his on the left, which is where it was
@@ -178,8 +178,8 @@
  * task so that the user will know that it's finished if she's
  * switched to another application while she waits for yours.
  * They're all pretty simple, so you can just read the details below.
- * 
- * 
+ *
+ *
  * * The last feature to which GtkosxApplication provides an interface
  * is the bundle. Normally in OSX, graphical applications are packaged
  * along with their non-standard dependencies and their resources
@@ -217,7 +217,7 @@
  * return the value associated with an arbitrary key from Info.plist
  * as long as that value is a string. If it isn't, then the function
  * returns a null string ("").
- * 
+ *
  * Finally, notice the signals. These are emitted in response to the
  * indicated OSX notifications. Except for
  * #GtkosxApplication::NSApplicationBlockTermination, most programs
@@ -242,34 +242,34 @@ gtkosx_application_get (void)
 }
 
 
-/** 
+/**
  * gtkosx_application_use_quartz_accelerators:
  * @self: The GtkosxApplication pointer.
  *
- * Are we using Quartz or Gtk+ accelerator handling? 
+ * Are we using Quartz or Gtk+ accelerator handling?
  *
  * Returns: a gboolean
  */
 gboolean
-gtkosx_application_use_quartz_accelerators(GtkosxApplication *self)
+gtkosx_application_use_quartz_accelerators (GtkosxApplication *self)
 {
-    return self->priv->use_quartz_accelerators;
+  return self->priv->use_quartz_accelerators;
 }
 
-/** 
+/**
  * gtkosx_application_set_use_quartz_accelerators:
  * @self: The GtkosxApplication pointer.
- * @use_quartz_accelerators: Gboolean 
+ * @use_quartz_accelerators: Gboolean
  *
  * Set quartz accelerator handling; TRUE (default) uses quartz; FALSE
  * uses Gtk+. Quartz accelerator handling is required for normal OSX
  * accelerators (e.g., command-q to quit) to work.
  */
 void
-gtkosx_application_set_use_quartz_accelerators(GtkosxApplication *self,
-                                           gboolean use_quartz_accelerators)
+gtkosx_application_set_use_quartz_accelerators (GtkosxApplication *self,
+    gboolean use_quartz_accelerators)
 {
-    self->priv->use_quartz_accelerators = use_quartz_accelerators;
+  self->priv->use_quartz_accelerators = use_quartz_accelerators;
 }
 
 /*
@@ -279,7 +279,7 @@ gtkosx_application_set_use_quartz_accelerators(GtkosxApplication *self,
  * requests. Exists soley to satisfy the PyGObject codegen system.
  */
 GType
-gtkosx_type_application_attention_type_get_type(void)
+gtkosx_type_application_attention_type_get_type (void)
 {
   //Bogus GType, but there's no good reason to register this; it's only an enum
   return GTKOSX_TYPE_APPLICATION;
diff --git a/src/gtkosxapplication_quartz.c b/src/gtkosxapplication_quartz.c
index ebfe5a8..0386c39 100644
--- a/src/gtkosxapplication_quartz.c
+++ b/src/gtkosxapplication_quartz.c
@@ -1,4 +1,4 @@
-/* GTK+ application-level integration for the Mac OS X/Cocoa 
+/* GTK+ application-level integration for the Mac OS X/Cocoa
  *
  * Copyright (C) 2007 Pioneer Research Center USA, Inc.
  * Copyright (C) 2007 Imendio AB
@@ -40,7 +40,7 @@
 
 /* This is a private function in libgdk; we need to have is so that we
    can force new windows onto the Window menu */
-extern NSWindow* gdk_quartz_window_get_nswindow(GdkWindow*);
+extern NSWindow* gdk_quartz_window_get_nswindow (GdkWindow*);
 
 //#define DEBUG(format, ...) g_printerr ("%s: " format, G_STRFUNC, ## __VA_ARGS__)
 #define DEBUG(format, ...)
@@ -64,51 +64,55 @@ static GQuark emission_hook_quark = 0;
  * @param_values: A GValue[] containing the parameters
  * data: A gpointer to pass to the signal handler
  *
- * Sets an emission hook for all parent-set signals. 
+ * Sets an emission hook for all parent-set signals.
  */
 static gboolean
 parent_set_emission_hook (GSignalInvocationHint *ihint,
-                         guint                  n_param_values,
-                         const GValue          *param_values,
-                         gpointer               data)
+                          guint                  n_param_values,
+                          const GValue          *param_values,
+                          gpointer               data)
 {
   GtkWidget *instance = (GtkWidget*) g_value_get_object (param_values);
 
-  if (GTK_IS_MENU_ITEM (instance)) {
-    GtkWidget *old_parent = (GtkWidget*) g_value_get_object (param_values + 1);
-    GtkWidget *new_parent = gtk_widget_get_parent(instance);
-    _GNSMenuItem *cocoa_item = cocoa_menu_item_get(instance);
-/* If neither the old parent or the new parent has a cocoa menu, then
-   we're not really interested in this. */
-    if (!( (old_parent && GTK_IS_WIDGET(old_parent) 
-           && cocoa_menu_get(old_parent)) || 
-          (new_parent && GTK_IS_WIDGET(new_parent)
-           && cocoa_menu_get(new_parent))))
-      return TRUE;
-
-    if (GTK_IS_MENU_SHELL (old_parent)) {
-       _GNSMenuBar *cocoa_menu = (_GNSMenuBar*)cocoa_menu_get (old_parent);
-       [cocoa_item removeFromMenu: cocoa_menu];
-
-    }
-    /*This would be considerably more efficient if we could just
-      insert it into the menu, but we can't easily get the item's
-      position in the GtkMenu and even if we could we don't know that
-      there isn't some other item in the menu that's been moved to the
-      app-menu for quartz.  */
-    if (GTK_IS_MENU_SHELL (new_parent) && cocoa_menu_get(new_parent)) {
-       _GNSMenuBar *cocoa_menu = (_GNSMenuBar*)cocoa_menu_get (new_parent);
-       if (GTK_IS_MENU_BAR(new_parent) && cocoa_menu && 
-           [cocoa_menu respondsToSelector: @selector(resync)]) {
-         [cocoa_menu resync];
-       }
-       else
-         cocoa_menu_item_add_submenu (GTK_MENU_SHELL (new_parent),
-                                      cocoa_menu,
-                                      cocoa_menu == (NSMenu*) data,
-                                      FALSE);
+  if (GTK_IS_MENU_ITEM (instance))
+    {
+      GtkWidget *old_parent = (GtkWidget*) g_value_get_object (param_values + 1);
+      GtkWidget *new_parent = gtk_widget_get_parent (instance);
+      _GNSMenuItem *cocoa_item = cocoa_menu_item_get (instance);
+      /* If neither the old parent or the new parent has a cocoa menu, then
+         we're not really interested in this. */
+      if (! ( (old_parent && GTK_IS_WIDGET (old_parent)
+               && cocoa_menu_get (old_parent)) ||
+              (new_parent && GTK_IS_WIDGET (new_parent)
+               && cocoa_menu_get (new_parent))))
+        return TRUE;
+
+      if (GTK_IS_MENU_SHELL (old_parent))
+        {
+          _GNSMenuBar *cocoa_menu = (_GNSMenuBar*)cocoa_menu_get (old_parent);
+[cocoa_item removeFromMenu: cocoa_menu];
+
+        }
+      /*This would be considerably more efficient if we could just
+        insert it into the menu, but we can't easily get the item's
+        position in the GtkMenu and even if we could we don't know that
+        there isn't some other item in the menu that's been moved to the
+        app-menu for quartz.  */
+      if (GTK_IS_MENU_SHELL (new_parent) && cocoa_menu_get (new_parent))
+        {
+          _GNSMenuBar *cocoa_menu = (_GNSMenuBar*)cocoa_menu_get (new_parent);
+          if (GTK_IS_MENU_BAR (new_parent) && cocoa_menu &&
+    [cocoa_menu respondsToSelector: @selector (resync)])
+            {
+              [cocoa_menu resync];
+            }
+          else
+            cocoa_menu_item_add_submenu (GTK_MENU_SHELL (new_parent),
+                                         cocoa_menu,
+                                         cocoa_menu == (NSMenu*) data,
+                                         FALSE);
+        }
     }
-  }
   return TRUE;
 }
 
@@ -122,13 +126,13 @@ parent_set_emission_hook (GSignalInvocationHint *ihint,
  */
 static void
 parent_set_emission_hook_remove (GtkWidget *widget,
-                                gpointer   data)
+                                 gpointer   data)
 {
-  gulong hook_id = (gulong)g_object_get_qdata(G_OBJECT(widget), emission_hook_quark);
+  gulong hook_id = (gulong)g_object_get_qdata (G_OBJECT (widget), emission_hook_quark);
   if (hook_id == 0) return;
   g_signal_remove_emission_hook (g_signal_lookup ("parent-set",
-                                                 GTK_TYPE_WIDGET),
-                                hook_id);
+                                 GTK_TYPE_WIDGET),
+                                 hook_id);
 }
 
 /*
@@ -144,15 +148,15 @@ parent_set_emission_hook_remove (GtkWidget *widget,
 static _GNSMenuItem*
 add_to_menubar (GtkosxApplication *self, NSMenu *menu, int pos)
 {
-  _GNSMenuItem *dummyItem = [[_GNSMenuItem alloc] initWithTitle:@""
-                                             action:nil keyEquivalent:@""];
+  _GNSMenuItem *dummyItem = [[_GNSMenuItem alloc] initWithTitle: @""
+                            action: nil keyEquivalent: @""];
   NSMenu *menubar = [NSApp mainMenu];
 
-  [dummyItem setSubmenu:menu];
+  [dummyItem setSubmenu: menu];
   if (pos < 0)
-      [menubar addItem:dummyItem];
+    [menubar addItem: dummyItem];
   else
-      [menubar insertItem:dummyItem atIndex:pos];
+    [menubar insertItem: dummyItem atIndex: pos];
   return dummyItem;
 }
 
@@ -178,43 +182,43 @@ create_apple_menu (GtkosxApplication *self)
   NSMenuItem *menuitem;
   // Create the application (Apple) menu.
   NSMenu *app_menu = [[[NSMenu alloc] initWithTitle: @"Apple Menu"] autorelease];
-  NSString *title = NSLocalizedStringFromTable(@"Services",
-                                               @"GtkOSXApplication",
-                                               @"Services Menu title");
+  NSString *title = NSLocalizedStringFromTable (@"Services",
+                                               @"GtkOSXApplication",
+                                               @"Services Menu title");
   NSMenu *menuServices = [[[NSMenu alloc] initWithTitle: title] autorelease];
-  [NSApp setServicesMenu:menuServices];
+  [NSApp setServicesMenu: menuServices];
 
   [app_menu addItem: [NSMenuItem separatorItem]];
-  menuitem = [[NSMenuItem alloc] initWithTitle:  NSLocalizedStringFromTable(@"Services",  
@"GtkosxApplication", @"Services Menu Item title")
-                                action:nil keyEquivalent:@""];
-  [menuitem setSubmenu:menuServices];
+  menuitem = [[NSMenuItem alloc] initWithTitle:  NSLocalizedStringFromTable (@"Services",  
@"GtkosxApplication", @"Services Menu Item title")
+             action: nil keyEquivalent: @""];
+  [menuitem setSubmenu: menuServices];
   [app_menu addItem: menuitem];
   [menuitem release];
   [app_menu addItem: [NSMenuItem separatorItem]];
-  menuitem = [[NSMenuItem alloc] initWithTitle: NSLocalizedStringFromTable(@"Hide",  @"GtkosxApplication", 
@"Hide menu item title")
-                                action:@selector(hide:) keyEquivalent:@"h"];
+  menuitem = [[NSMenuItem alloc] initWithTitle: NSLocalizedStringFromTable (@"Hide",  @"GtkosxApplication", 
@"Hide menu item title")
+             action: @selector (hide: ) keyEquivalent: @"h"];
   [menuitem setTarget: NSApp];
   [app_menu addItem: menuitem];
   [menuitem release];
-  menuitem = [[NSMenuItem alloc] initWithTitle: NSLocalizedStringFromTable(@"Hide Others",  
@"GtkosxApplication", @"Hide Others menu item title")
-                                action:@selector(hideOtherApplications:) keyEquivalent:@"h"];
+  menuitem = [[NSMenuItem alloc] initWithTitle: NSLocalizedStringFromTable (@"Hide Others",  
@"GtkosxApplication", @"Hide Others menu item title")
+             action: @selector (hideOtherApplications: ) keyEquivalent: @"h"];
   [menuitem setKeyEquivalentModifierMask: NSCommandKeyMask | NSAlternateKeyMask];
   [menuitem setTarget: NSApp];
   [app_menu addItem: menuitem];
   [menuitem release];
-  menuitem = [[NSMenuItem alloc] initWithTitle: NSLocalizedStringFromTable( @"Show All", 
@"GtkosxApplication",  @"Show All menu item title")
-                                action:@selector(unhideAllApplications:) keyEquivalent:@""];
+  menuitem = [[NSMenuItem alloc] initWithTitle: NSLocalizedStringFromTable ( @"Show All", 
@"GtkosxApplication",  @"Show All menu item title")
+             action: @selector (unhideAllApplications: ) keyEquivalent: @""];
   [menuitem setTarget: NSApp];
   [app_menu addItem: menuitem];
   [menuitem release];
   [app_menu addItem: [NSMenuItem separatorItem]];
-  menuitem = [[NSMenuItem alloc] initWithTitle: NSLocalizedStringFromTable(@"Quit",  @"GtkosxApplication", 
@"Quit menu item title")
-                                action:@selector(terminate:) keyEquivalent:@"q"];
+  menuitem = [[NSMenuItem alloc] initWithTitle: NSLocalizedStringFromTable (@"Quit",  @"GtkosxApplication", 
@"Quit menu item title")
+             action: @selector (terminate: ) keyEquivalent: @"q"];
   [menuitem setTarget: NSApp];
   [app_menu addItem: menuitem];
   [menuitem release];
 
-  [NSApp performSelector:@selector(setAppleMenu:) withObject:app_menu];
+  [NSApp performSelector: @selector (setAppleMenu: ) withObject: app_menu];
   return add_to_menubar (self, app_menu, 0);
 }
 
@@ -236,9 +240,9 @@ create_apple_menu (GtkosxApplication *self)
 static _GNSMenuItem *
 create_window_menu (GtkosxApplication *self)
 {
-  NSString *title = NSLocalizedStringFromTable(@"Window",
-                                               @"GtkOSXApplication",
-                                               @"Window Menu title");
+  NSString *title = NSLocalizedStringFromTable (@"Window",
+                    @"GtkOSXApplication",
+                    @"Window Menu title");
   NSMenu *window_menu = [[[NSMenu alloc] initWithTitle: title] autorelease];
   GtkMenuBar *menubar = [(_GNSMenuBar*)[NSApp mainMenu] menuBar];
   GtkWidget *parent = NULL;
@@ -246,26 +250,26 @@ create_window_menu (GtkosxApplication *self)
   NSWindow *nswin = NULL;
   int pos;
 
-  g_return_val_if_fail(menubar != NULL, NULL);
-  g_return_val_if_fail(GTK_IS_MENU_BAR(menubar), NULL);
-  parent = gtk_widget_get_toplevel(GTK_WIDGET(menubar));
-  if (parent && GTK_IS_WIDGET(parent))
-    win = gtk_widget_get_window(parent);
-  if (win && GDK_IS_WINDOW(win))
-    nswin = gdk_quartz_window_get_nswindow(win);
+  g_return_val_if_fail (menubar != NULL, NULL);
+  g_return_val_if_fail (GTK_IS_MENU_BAR (menubar), NULL);
+  parent = gtk_widget_get_toplevel (GTK_WIDGET (menubar));
+  if (parent && GTK_IS_WIDGET (parent))
+    win = gtk_widget_get_window (parent);
+  if (win && GDK_IS_WINDOW (win))
+    nswin = gdk_quartz_window_get_nswindow (win);
 
-  [window_menu addItemWithTitle: NSLocalizedStringFromTable(@"Minimize", @"GtkosxApplication", 
@"Windows|Minimize menu item")
-               action:@selector(performMiniaturize:) keyEquivalent:@"m"];
+  [window_menu addItemWithTitle: NSLocalizedStringFromTable (@"Minimize", @"GtkosxApplication", 
@"Windows|Minimize menu item")
+   action: @selector (performMiniaturize: ) keyEquivalent: @"m"];
   [window_menu addItem: [NSMenuItem separatorItem]];
-  [window_menu addItemWithTitle: NSLocalizedStringFromTable(@"Bring All to Front", @"GtkosxApplication", 
@"Windows|Bring All To Front menu item title")
-               action:@selector(arrangeInFront:) keyEquivalent:@""];
+  [window_menu addItemWithTitle: NSLocalizedStringFromTable (@"Bring All to Front", @"GtkosxApplication", 
@"Windows|Bring All To Front menu item title")
+   action: @selector (arrangeInFront: ) keyEquivalent: @""];
 
-  [NSApp setWindowsMenu:window_menu];
+  [NSApp setWindowsMenu: window_menu];
   if (nswin)
     [NSApp addWindowsItem: nswin title: [nswin title] filename: NO];
   pos = [[NSApp mainMenu] indexOfItem: [(_GNSMenuBar*)[NSApp mainMenu] helpMenu]];
   return add_to_menubar (self, window_menu, pos);
-}  
+}
 
 /*
  * gtkosx_application_constructor:
@@ -284,15 +288,15 @@ create_window_menu (GtkosxApplication *self)
  */
 static GObject *
 gtkosx_application_constructor (GType gtype,
-                            guint n_properties,
-                            GObjectConstructParam *properties)
+                                guint n_properties,
+                                GObjectConstructParam *properties)
 {
   static GObject *self = NULL;
   static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
   g_static_mutex_lock (&mutex);
   if (self == NULL)
     {
-      self = G_OBJECT_CLASS(gtkosx_application_parent_class)->constructor(gtype, n_properties, properties);
+      self = G_OBJECT_CLASS (gtkosx_application_parent_class)->constructor (gtype, n_properties, properties);
       g_object_add_weak_pointer (self, (gpointer) &self);
 
     }
@@ -310,14 +314,14 @@ gtkosx_application_constructor (GType gtype,
  */
 static void
 g_cclosure_marshal_BOOLEAN__VOID (GClosure     *closure,
-                               GValue       *return_value G_GNUC_UNUSED,
-                               guint         n_param_values,
-                               const GValue *param_values,
-                               gpointer      invocation_hint G_GNUC_UNUSED,
-                               gpointer      marshal_data)
+                                  GValue       *return_value G_GNUC_UNUSED,
+                                  guint         n_param_values,
+                                  const GValue *param_values,
+                                  gpointer      invocation_hint G_GNUC_UNUSED,
+                                  gpointer      marshal_data)
 {
   typedef gboolean (*GMarshalFunc_BOOLEAN__VOID) (gpointer     data1,
-                                             gpointer     data2);
+      gpointer     data2);
   register GMarshalFunc_BOOLEAN__VOID callback;
   register GCClosure *cc = (GCClosure*) closure;
   register gpointer data1, data2;
@@ -337,8 +341,8 @@ g_cclosure_marshal_BOOLEAN__VOID (GClosure     *closure,
     }
   callback = (GMarshalFunc_BOOLEAN__VOID) (marshal_data ? marshal_data : cc->callback);
 
-    v_return = callback (data1, data2);
-    g_value_set_boolean (return_value, v_return);
+  v_return = callback (data1, data2);
+  g_value_set_boolean (return_value, v_return);
 }
 
 
@@ -350,15 +354,15 @@ g_cclosure_marshal_BOOLEAN__VOID (GClosure     *closure,
  */
 static void
 g_cclosure_marshal_BOOLEAN__STRING (GClosure     *closure,
-                               GValue       *return_value G_GNUC_UNUSED,
-                               guint         n_param_values,
-                               const GValue *param_values,
-                               gpointer      invocation_hint G_GNUC_UNUSED,
-                               gpointer      marshal_data)
+                                    GValue       *return_value G_GNUC_UNUSED,
+                                    guint         n_param_values,
+                                    const GValue *param_values,
+                                    gpointer      invocation_hint G_GNUC_UNUSED,
+                                    gpointer      marshal_data)
 {
   typedef gboolean (*GMarshalFunc_BOOLEAN__STRING) (gpointer     data1,
-                                                   const char     *arg1,
-                                                   gpointer     data2);
+      const char     * arg1,
+      gpointer     data2);
   register GMarshalFunc_BOOLEAN__STRING callback;
   register GCClosure *cc = (GCClosure*) closure;
   register gpointer data1, data2;
@@ -378,14 +382,14 @@ g_cclosure_marshal_BOOLEAN__STRING (GClosure     *closure,
     }
   callback = (GMarshalFunc_BOOLEAN__STRING) (marshal_data ? marshal_data : cc->callback);
 
-    v_return = callback (data1,            
-                        g_value_get_string (param_values + 1),
-                        data2);
-    g_value_set_boolean (return_value, v_return);
+  v_return = callback (data1,
+                       g_value_get_string (param_values + 1),
+                       data2);
+  g_value_set_boolean (return_value, v_return);
 }
 
 
-/* 
+/*
  * block_termination_accumulator:
  *
  * A signal accumulator function for the NSApplicationShouldTerminate
@@ -400,16 +404,17 @@ g_cclosure_marshal_BOOLEAN__STRING (GClosure     *closure,
  * Returns: gboolean
  */
 static gboolean
-block_termination_accumulator(GSignalInvocationHint *ihint, GValue *accum,
-                       const GValue *retval, gpointer data)
+block_termination_accumulator (GSignalInvocationHint *ihint, GValue *accum,
+                               const GValue *retval, gpointer data)
 {
-  if (g_value_get_boolean(retval)) {
-    g_value_set_boolean(accum, TRUE);
-    return FALSE; //Stop handling the signal
-  }
-  g_value_set_boolean(accum, FALSE);
+  if (g_value_get_boolean (retval))
+    {
+      g_value_set_boolean (accum, TRUE);
+      return FALSE; //Stop handling the signal
+    }
+  g_value_set_boolean (accum, FALSE);
   return TRUE; //Continue handling the signal
- }
+}
 
 /*
  * global_event_filter_func
@@ -438,23 +443,25 @@ global_event_filter_func (gpointer  windowing_event, GdkEvent *event,
    * environment!
    */
   if ([nsevent type] == NSKeyDown &&
-      gtkosx_application_use_quartz_accelerators(app) ) {
-    gboolean result;
-    gdk_threads_leave();
-    result = [[NSApp mainMenu] performKeyEquivalent: nsevent];
-    gdk_threads_enter();
-    if (result) return GDK_FILTER_TRANSLATE;
-  }
+      gtkosx_application_use_quartz_accelerators (app) )
+    {
+      gboolean result;
+      gdk_threads_leave ();
+      result = [[NSApp mainMenu] performKeyEquivalent: nsevent];
+      gdk_threads_enter ();
+      if (result) return GDK_FILTER_TRANSLATE;
+    }
   return GDK_FILTER_CONTINUE;
 }
 
-enum {
-    DidBecomeActive,
-    WillResignActive,
-    BlockTermination,
-    WillTerminate,
-    OpenFile,
-    LastSignal
+enum
+{
+  DidBecomeActive,
+  WillResignActive,
+  BlockTermination,
+  WillTerminate,
+  OpenFile,
+  LastSignal
 };
 
 static guint gtkosx_application_signals[LastSignal] = {0};
@@ -474,7 +481,7 @@ gtkosx_application_init (GtkosxApplication *self)
   self->priv->dock_menu = NULL;
   gdk_window_add_filter (NULL, global_event_filter_func, (gpointer)self);
   self->priv->notify = [[GtkApplicationNotificationObject alloc] init];
-  [ NSApp setDelegate: [GtkApplicationDelegate new]];
+  [NSApp setDelegate: [GtkApplicationDelegate new]];
   self->priv->delegate = [NSApp delegate];
 }
 
@@ -485,7 +492,7 @@ gtkosx_application_dispose (GObject *obj)
   [self->priv->dock_menu release];
   [self->priv->notify release];
   [self->priv->delegate release];
-  G_OBJECT_CLASS(gtkosx_application_parent_class)->dispose (obj);
+  G_OBJECT_CLASS (gtkosx_application_parent_class)->dispose (obj);
 }
 
 /**
@@ -494,106 +501,106 @@ gtkosx_application_dispose (GObject *obj)
  *
  * Not normaly called directly; Use g_object_new(GTK_TYPE_OSXAPPLICATION)
  */
-void 
-gtkosx_application_class_init(GtkosxApplicationClass *klass)
+void
+gtkosx_application_class_init (GtkosxApplicationClass *klass)
 {
-  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
-  g_type_class_add_private(klass, sizeof(GtkosxApplicationPrivate));
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  g_type_class_add_private (klass, sizeof (GtkosxApplicationPrivate));
   gobject_class->constructor = gtkosx_application_constructor;
-/**
- * GtkosxApplication::NSApplicationDidBecomeActive:
- * @app: The application object
- * #user_data: Data appended at connection
- *
- * Emitted by the Application Delegate when the application receives
- * an NSApplicationDidBecomeActive notification. Connect a handler if
- * there is anything you need to do when the application is activated.
- */
-gtkosx_application_signals[DidBecomeActive] =
-    g_signal_new("NSApplicationDidBecomeActive",
-              GTKOSX_TYPE_APPLICATION,
-              G_SIGNAL_NO_RECURSE | G_SIGNAL_ACTION,
-              0, NULL, NULL,
-              g_cclosure_marshal_VOID__VOID,
-              G_TYPE_NONE, 0);
-/**
- * GtkosxApplication::NSApplicationWillResignActive:
- * @app: The application object
- * @user_data: Data appended at connection
- *
- * This signal is emitted by the Application Delegate when the
- * application receives an NSApplicationWillResignActive
- * notification. Connect a handler to it if there's anything your
- * application needs to do to prepare for inactivity.
- */
-gtkosx_application_signals[WillResignActive] =
-    g_signal_new("NSApplicationWillResignActive",
-              GTKOSX_TYPE_APPLICATION,
-              G_SIGNAL_NO_RECURSE | G_SIGNAL_ACTION,
-              0, NULL, NULL,
-              g_cclosure_marshal_VOID__VOID,
-              G_TYPE_NONE, 0);
-
-/**
- * GtkosxApplication::NSApplicationBlockTermination:
- * @app: The application object
- * @user_data: Data appended at connection
- *
- * Emitted by the Application Delegate when the application reeeives
- * an NSApplicationShouldTerminate notification. Perform any cleanup
- * you need to do (e.g., saving files) before exiting. Returning FALSE
- * will allow further handlers to run and if none return TRUE, the
- * application to shut down. Returning TRUE will veto shutdown and
- * stop emission, so later handlers will not run.
- *
- * Returns: Boolean indicating that further emission and application
- * termination should be blocked.
- */
-gtkosx_application_signals[BlockTermination] =
-    g_signal_new("NSApplicationBlockTermination",
-              GTKOSX_TYPE_APPLICATION,
-              G_SIGNAL_NO_RECURSE | G_SIGNAL_ACTION,
-              0, block_termination_accumulator, NULL,
-              g_cclosure_marshal_BOOLEAN__VOID,
-              G_TYPE_BOOLEAN, 0);
-
-/**
- * GtkosxApplication::NSApplicationWillTerminate:
- * @app: The application object
- * @user_data: Data appended at connection
- *
- * Emitted by the Application Delegate when the application reeeives
- * an NSApplicationSWillTerminate notification. Connect your final
- * shutdown routine (the one that calls gtk_main_quit() here.
- */
-gtkosx_application_signals[WillTerminate] =
-    g_signal_new("NSApplicationWillTerminate",
-              GTKOSX_TYPE_APPLICATION,
-              G_SIGNAL_NO_RECURSE | G_SIGNAL_ACTION,
-              0, NULL, NULL,
-              g_cclosure_marshal_VOID__VOID,
-              G_TYPE_NONE, 0);
-
-/**
- * GtkosxApplication::NSApplicationOpenFile:
- * @app: The application object
- * @path: A UTF8-encoded file path to open.
- * @user_data: Data attached at connection
- *
- * Emitted when a OpenFile, OpenFiles, or OpenEmptyFile event is
- * received from the operating system. This signal does not implement
- * drops, but it does implement "open with" events from Finder. An
- * OpenEmptyFile is received at launch in Python applications.
- *
- * Returns: Boolean indicating success at opening the file.
- */
-gtkosx_application_signals[OpenFile] =
-    g_signal_new("NSApplicationOpenFile",
-              GTKOSX_TYPE_APPLICATION,
-              G_SIGNAL_NO_RECURSE | G_SIGNAL_ACTION,
-              0, NULL, NULL,
-              g_cclosure_marshal_BOOLEAN__STRING,
-              G_TYPE_BOOLEAN, 1, G_TYPE_STRING);
+  /**
+   * GtkosxApplication::NSApplicationDidBecomeActive:
+   * @app: The application object
+   * #user_data: Data appended at connection
+   *
+   * Emitted by the Application Delegate when the application receives
+   * an NSApplicationDidBecomeActive notification. Connect a handler if
+   * there is anything you need to do when the application is activated.
+   */
+  gtkosx_application_signals[DidBecomeActive] =
+    g_signal_new ("NSApplicationDidBecomeActive",
+                  GTKOSX_TYPE_APPLICATION,
+                  G_SIGNAL_NO_RECURSE | G_SIGNAL_ACTION,
+                  0, NULL, NULL,
+                  g_cclosure_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+  /**
+   * GtkosxApplication::NSApplicationWillResignActive:
+   * @app: The application object
+   * @user_data: Data appended at connection
+   *
+   * This signal is emitted by the Application Delegate when the
+   * application receives an NSApplicationWillResignActive
+   * notification. Connect a handler to it if there's anything your
+   * application needs to do to prepare for inactivity.
+   */
+  gtkosx_application_signals[WillResignActive] =
+    g_signal_new ("NSApplicationWillResignActive",
+                  GTKOSX_TYPE_APPLICATION,
+                  G_SIGNAL_NO_RECURSE | G_SIGNAL_ACTION,
+                  0, NULL, NULL,
+                  g_cclosure_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+
+  /**
+   * GtkosxApplication::NSApplicationBlockTermination:
+   * @app: The application object
+   * @user_data: Data appended at connection
+   *
+   * Emitted by the Application Delegate when the application reeeives
+   * an NSApplicationShouldTerminate notification. Perform any cleanup
+   * you need to do (e.g., saving files) before exiting. Returning FALSE
+   * will allow further handlers to run and if none return TRUE, the
+   * application to shut down. Returning TRUE will veto shutdown and
+   * stop emission, so later handlers will not run.
+   *
+   * Returns: Boolean indicating that further emission and application
+   * termination should be blocked.
+   */
+  gtkosx_application_signals[BlockTermination] =
+    g_signal_new ("NSApplicationBlockTermination",
+                  GTKOSX_TYPE_APPLICATION,
+                  G_SIGNAL_NO_RECURSE | G_SIGNAL_ACTION,
+                  0, block_termination_accumulator, NULL,
+                  g_cclosure_marshal_BOOLEAN__VOID,
+                  G_TYPE_BOOLEAN, 0);
+
+  /**
+   * GtkosxApplication::NSApplicationWillTerminate:
+   * @app: The application object
+   * @user_data: Data appended at connection
+   *
+   * Emitted by the Application Delegate when the application reeeives
+   * an NSApplicationSWillTerminate notification. Connect your final
+   * shutdown routine (the one that calls gtk_main_quit() here.
+   */
+  gtkosx_application_signals[WillTerminate] =
+    g_signal_new ("NSApplicationWillTerminate",
+                  GTKOSX_TYPE_APPLICATION,
+                  G_SIGNAL_NO_RECURSE | G_SIGNAL_ACTION,
+                  0, NULL, NULL,
+                  g_cclosure_marshal_VOID__VOID,
+                  G_TYPE_NONE, 0);
+
+  /**
+   * GtkosxApplication::NSApplicationOpenFile:
+   * @app: The application object
+   * @path: A UTF8-encoded file path to open.
+   * @user_data: Data attached at connection
+   *
+   * Emitted when a OpenFile, OpenFiles, or OpenEmptyFile event is
+   * received from the operating system. This signal does not implement
+   * drops, but it does implement "open with" events from Finder. An
+   * OpenEmptyFile is received at launch in Python applications.
+   *
+   * Returns: Boolean indicating success at opening the file.
+   */
+  gtkosx_application_signals[OpenFile] =
+    g_signal_new ("NSApplicationOpenFile",
+                  GTKOSX_TYPE_APPLICATION,
+                  G_SIGNAL_NO_RECURSE | G_SIGNAL_ACTION,
+                  0, NULL, NULL,
+                  g_cclosure_marshal_BOOLEAN__STRING,
+                  G_TYPE_BOOLEAN, 1, G_TYPE_STRING);
 
 }
 
@@ -601,12 +608,12 @@ gtkosx_application_signals[OpenFile] =
  * gtkosx_application_ready:
  * @self: The GtkosxApplication object
  *
- * Inform Cocoa that application initialization is complete. 
+ * Inform Cocoa that application initialization is complete.
  */
 void
 gtkosx_application_ready (GtkosxApplication *self)
 {
-  [ NSApp finishLaunching ];
+  [NSApp finishLaunching];
 }
 
 /*
@@ -643,22 +650,23 @@ gtkosx_application_set_menu_bar (GtkosxApplication *self, GtkMenuShell *menu_she
 {
   _GNSMenuBar* cocoa_menubar;
   NSMenu* old_menubar = [NSApp mainMenu];
-  GtkWidget *parent = gtk_widget_get_toplevel(GTK_WIDGET(menu_shell));
+  GtkWidget *parent = gtk_widget_get_toplevel (GTK_WIDGET (menu_shell));
   gulong emission_hook_id;
- 
+
   g_return_if_fail (GTK_IS_MENU_SHELL (menu_shell));
 
-  cocoa_menubar = (_GNSMenuBar*)cocoa_menu_get(GTK_WIDGET (menu_shell));
-  if (!cocoa_menubar) {
-    cocoa_menubar = [[[_GNSMenuBar alloc] initWithGtkMenuBar: 
-                      GTK_MENU_BAR(menu_shell)] autorelease];
-    cocoa_menu_connect(GTK_WIDGET (menu_shell), cocoa_menubar);
-  /* turn off auto-enabling for the menu - its silly and slow and
-     doesn't really make sense for a Gtk/Cocoa hybrid menu.
-  */
-    [cocoa_menubar setAutoenablesItems:NO];
-
-  }
+  cocoa_menubar = (_GNSMenuBar*)cocoa_menu_get (GTK_WIDGET (menu_shell));
+  if (!cocoa_menubar)
+    {
+      cocoa_menubar = [[[_GNSMenuBar alloc] initWithGtkMenuBar:
+                        GTK_MENU_BAR (menu_shell)] autorelease];
+      cocoa_menu_connect (GTK_WIDGET (menu_shell), cocoa_menubar);
+      /* turn off auto-enabling for the menu - its silly and slow and
+         doesn't really make sense for a Gtk/Cocoa hybrid menu.
+      */
+      [cocoa_menubar setAutoenablesItems: NO];
+
+    }
   if (cocoa_menubar != [NSApp mainMenu])
     [NSApp setMainMenu: cocoa_menubar];
 
@@ -666,26 +674,27 @@ gtkosx_application_set_menu_bar (GtkosxApplication *self, GtkMenuShell *menu_she
 
   emission_hook_id =
     g_signal_add_emission_hook (g_signal_lookup ("parent-set",
-                                                GTK_TYPE_WIDGET),
-                               0,
-                               parent_set_emission_hook,
-                               cocoa_menubar, NULL);
+                                GTK_TYPE_WIDGET),
+                                0,
+                                parent_set_emission_hook,
+                                cocoa_menubar, NULL);
   if (emission_hook_quark == 0)
-    emission_hook_quark = g_quark_from_static_string("GtkosxApplicationEmissionHook");
-  g_object_set_qdata(G_OBJECT(menu_shell), emission_hook_quark,
-                    (gpointer)emission_hook_id);
+    emission_hook_quark = g_quark_from_static_string ("GtkosxApplicationEmissionHook");
+  g_object_set_qdata (G_OBJECT (menu_shell), emission_hook_quark,
+                      (gpointer)emission_hook_id);
 
-  g_signal_connect (parent, "focus-in-event", 
-                   G_CALLBACK(window_focus_cb),
-                   cocoa_menubar);
+  g_signal_connect (parent, "focus-in-event",
+                    G_CALLBACK (window_focus_cb),
+                    cocoa_menubar);
 
   cocoa_menu_item_add_submenu (menu_shell, cocoa_menubar, TRUE, FALSE);
   /* Stupid hack to force the menubar to look right when a window is
      opened after starting the main loop. */
-  if (old_menubar != NULL) {
-    [NSApp setMainMenu: old_menubar];
-    [NSApp setMainMenu: cocoa_menubar];
-  }
+  if (old_menubar != NULL)
+    {
+      [NSApp setMainMenu: old_menubar];
+      [NSApp setMainMenu: cocoa_menubar];
+    }
 }
 
 /**
@@ -724,12 +733,13 @@ gtkosx_application_sync_menubar (GtkosxApplication *self)
  */
 void
 gtkosx_application_insert_app_menu_item (GtkosxApplication* self,
-                                        GtkWidget* item,
-                                        gint index) {
-    cocoa_menu_item_add_item ([[[NSApp mainMenu] itemAtIndex: 0] submenu],
-                             item, index);
-    [(_GNSMenuItem*)[[[[NSApp mainMenu] itemAtIndex: 0] submenu] 
-      itemAtIndex: index] setHidden: NO];
+    GtkWidget* item,
+    gint index)
+{
+  cocoa_menu_item_add_item ([[[NSApp mainMenu] itemAtIndex: 0] submenu],
+                            item, index);
+  [(_GNSMenuItem*)[[[[NSApp mainMenu] itemAtIndex: 0] submenu]
+                  itemAtIndex: index] setHidden: NO];
 }
 
 /**
@@ -743,28 +753,30 @@ gtkosx_application_insert_app_menu_item (GtkosxApplication* self,
  * and zoom the current window and to bring all windows to the
  * front. Call this after gtk_osx_application_set_menu_bar(). It
  * operates on the currently active menubar. If @nenu_item is NULL, it
- * will create a new menu for you, which will not be gettext translatable. 
+ * will create a new menu for you, which will not be gettext translatable.
  */
 void
-gtkosx_application_set_window_menu(GtkosxApplication *self,
-                                  GtkMenuItem *menu_item)
+gtkosx_application_set_window_menu (GtkosxApplication *self,
+                                    GtkMenuItem *menu_item)
 {
   _GNSMenuBar *cocoa_menubar = (_GNSMenuBar*)[NSApp mainMenu];
-  g_return_if_fail(cocoa_menubar != NULL);
-
-  if (menu_item) {
-    GtkWidget *parent = NULL;
-    GdkWindow *win = NULL;
-    NSWindow *nswin = NULL;
-    _GNSMenuItem *cocoa_item = cocoa_menu_item_get(GTK_WIDGET(menu_item));
-     g_return_if_fail(cocoa_item != NULL);
-    [cocoa_menubar setWindowsMenu: cocoa_item];
-    [NSApp setWindowsMenu: [cocoa_item submenu]];
- }
-  else {
-    _GNSMenuItem *cocoa_item = create_window_menu (self);
-    [cocoa_menubar setWindowsMenu:  cocoa_item];
-  }
+  g_return_if_fail (cocoa_menubar != NULL);
+
+  if (menu_item)
+    {
+      GtkWidget *parent = NULL;
+      GdkWindow *win = NULL;
+      NSWindow *nswin = NULL;
+      _GNSMenuItem *cocoa_item = cocoa_menu_item_get (GTK_WIDGET (menu_item));
+      g_return_if_fail (cocoa_item != NULL);
+      [cocoa_menubar setWindowsMenu: cocoa_item];
+      [NSApp setWindowsMenu: [cocoa_item submenu]];
+    }
+  else
+    {
+      _GNSMenuItem *cocoa_item = create_window_menu (self);
+      [cocoa_menubar setWindowsMenu:  cocoa_item];
+    }
 }
 
 /**
@@ -782,27 +794,29 @@ gtkosx_application_set_window_menu(GtkosxApplication *self,
  */
 void
 gtkosx_application_set_help_menu (GtkosxApplication *self,
-                                 GtkMenuItem *menu_item)
+                                  GtkMenuItem *menu_item)
 {
   _GNSMenuBar *cocoa_menubar = (_GNSMenuBar*)[NSApp mainMenu];
-  g_return_if_fail(cocoa_menubar != NULL);
-
-  if (menu_item) {
-    _GNSMenuItem *cocoa_item = cocoa_menu_item_get(GTK_WIDGET(menu_item));
-     g_return_if_fail(cocoa_item != NULL);
-    [cocoa_menubar setHelpMenu: cocoa_item];
-  }
-  else {
-    _GNSMenuItem *menuitem = [[[_GNSMenuItem alloc] initWithTitle: @"Help"
-                              action: NULL keyEquivalent: @""] autorelease];
-    [cocoa_menubar setHelpMenu: menuitem];
-    [cocoa_menubar addItem: [cocoa_menubar helpMenu]];
-  }
+  g_return_if_fail (cocoa_menubar != NULL);
+
+  if (menu_item)
+    {
+      _GNSMenuItem *cocoa_item = cocoa_menu_item_get (GTK_WIDGET (menu_item));
+      g_return_if_fail (cocoa_item != NULL);
+      [cocoa_menubar setHelpMenu: cocoa_item];
+    }
+  else
+    {
+      _GNSMenuItem *menuitem = [[[_GNSMenuItem alloc] initWithTitle: @"Help"
+                                action: NULL keyEquivalent: @""] autorelease];
+      [cocoa_menubar setHelpMenu: menuitem];
+      [cocoa_menubar addItem: [cocoa_menubar helpMenu]];
+    }
 }
 
 /* Dock support */
 /* A bogus prototype to shut up a compiler warning. This function is for GtkApplicationDelegate and is not 
public. */
-NSMenu* _gtkosx_application_dock_menu(GtkosxApplication *self);
+NSMenu* _gtkosx_application_dock_menu (GtkosxApplication *self);
 
 /**
  * _gtkosx_application_dock_menu:
@@ -814,9 +828,9 @@ NSMenu* _gtkosx_application_dock_menu(GtkosxApplication *self);
  * Returns: NSMenu*
  */
 NSMenu*
-_gtkosx_application_dock_menu(GtkosxApplication *self)
+_gtkosx_application_dock_menu (GtkosxApplication *self)
 {
-  return(self->priv->dock_menu);
+  return (self->priv->dock_menu);
 }
 
 /**
@@ -825,7 +839,7 @@ _gtkosx_application_dock_menu(GtkosxApplication *self)
  * @menu_shell: A GtkMenu (cast it with GTK_MENU_SHELL() when you
  * pass it in
  *
- * Set a GtkMenu as the dock menu.  
+ * Set a GtkMenu as the dock menu.
  *
  * This menu does not have a "sync" function, so changes made while
  * signals are disconnected will not update the menu which appears in
@@ -834,15 +848,17 @@ _gtkosx_application_dock_menu(GtkosxApplication *self)
  * deallocated.
  */
 void
-gtkosx_application_set_dock_menu(GtkosxApplication *self,
-                             GtkMenuShell *menu_shell)
+gtkosx_application_set_dock_menu (GtkosxApplication *self,
+                                  GtkMenuShell *menu_shell)
 {
   g_return_if_fail (GTK_IS_MENU_SHELL (menu_shell));
-  if (!self->priv->dock_menu) {
-    self->priv->dock_menu = [[NSMenu alloc] initWithTitle: @""]; 
-    cocoa_menu_item_add_submenu(menu_shell, self->priv->dock_menu, FALSE, FALSE);
-    [self->priv->dock_menu retain];
-  }
+  if (!self->priv->dock_menu)
+    {
+      self->priv->dock_menu = [[NSMenu alloc] initWithTitle: @""];
+      cocoa_menu_item_add_submenu (menu_shell, self->priv->dock_menu,
+                                  FALSE, FALSE);
+      [self->priv->dock_menu retain];
+    }
 }
 
 /**
@@ -853,13 +869,13 @@ gtkosx_application_set_dock_menu(GtkosxApplication *self,
  * Set the dock icon from a GdkPixbuf
  */
 void
-gtkosx_application_set_dock_icon_pixbuf(GtkosxApplication *self,
-                                         GdkPixbuf *pixbuf)
+gtkosx_application_set_dock_icon_pixbuf (GtkosxApplication *self,
+    GdkPixbuf *pixbuf)
 {
   if (!pixbuf)
     [NSApp setApplicationIconImage: nil];
   else
-    [NSApp setApplicationIconImage: nsimage_from_pixbuf(pixbuf)];
+    [NSApp setApplicationIconImage: nsimage_from_pixbuf (pixbuf)];
 
 }
 
@@ -874,12 +890,12 @@ gtkosx_application_set_dock_icon_pixbuf(GtkosxApplication *self,
  * Set the dock icon from an image file in the bundle/
  */
 void
-gtkosx_application_set_dock_icon_resource(GtkosxApplication *self,
-                                           const gchar  *name,
-                                           const gchar  *type,
-                                           const gchar  *subdir)
+gtkosx_application_set_dock_icon_resource (GtkosxApplication *self,
+    const gchar  *name,
+    const gchar  *type,
+    const gchar  *subdir)
 {
-  NSImage *image = nsimage_from_resource(name, type, subdir);
+  NSImage *image = nsimage_from_resource (name, type, subdir);
   [NSApp setApplicationIconImage: image];
   [image release];
 }
@@ -899,8 +915,8 @@ gtkosx_application_set_dock_icon_resource(GtkosxApplication *self,
  * gtkosx_application_cancel_attention_request.
  */
 gint
-gtkosx_application_attention_request(GtkosxApplication *self,
-                                 GtkosxApplicationAttentionType type)
+gtkosx_application_attention_request (GtkosxApplication *self,
+                                      GtkosxApplicationAttentionType type)
 {
   return (gint)[NSApp requestUserAttention: (NSRequestUserAttentionType)type];
 }
@@ -915,7 +931,7 @@ gtkosx_application_attention_request(GtkosxApplication *self,
  * gtkosx_application_attention_request.
  */
 void
-gtkosx_application_cancel_attention_request(GtkosxApplication *self, gint id)
+gtkosx_application_cancel_attention_request (GtkosxApplication *self, gint id)
 {
   [NSApp cancelUserAttentionRequest: id];
 }
@@ -929,14 +945,14 @@ gtkosx_application_cancel_attention_request(GtkosxApplication *self, gint id)
  * Returns: path The bundle's absolute path or %NULL on error. g_free() it when done.
  */
 gchar*
-gtkosx_application_get_bundle_path(void)
+gtkosx_application_get_bundle_path (void)
 {
   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
   gchar *str = NULL;
   NSString *path = [[NSBundle mainBundle] bundlePath];
   if (!path)
     return NULL;
-  str = strdup([path UTF8String]);
+  str = strdup ([path UTF8String]);
   [pool release];
   return str;
 }
@@ -954,14 +970,14 @@ gtkosx_application_get_bundle_path(void)
  * Returns: The string value of CFBundleIdentifier, or %NULL if there is none. g_free() it when done.
  */
 gchar*
-gtkosx_application_get_bundle_id(void)
+gtkosx_application_get_bundle_id (void)
 {
   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
   gchar *str = NULL;
   NSString *path = [[NSBundle mainBundle] bundleIdentifier];
   if (!path)
     return NULL;
-  str = strdup([path UTF8String]);
+  str = strdup ([path UTF8String]);
   [pool release];
   return str;
 }
@@ -975,14 +991,14 @@ gtkosx_application_get_bundle_id(void)
  * Returns: path The absolute resource path. or %NULL on error. g_free() it when done.
  */
 gchar*
-gtkosx_application_get_resource_path(void)
+gtkosx_application_get_resource_path (void)
 {
   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
   gchar *str = NULL;
   NSString *path = [[NSBundle mainBundle] resourcePath];
   if (!path)
     return NULL;
-  str = strdup([path UTF8String]);
+  str = strdup ([path UTF8String]);
   [pool release];
   return str;
 }
@@ -996,14 +1012,14 @@ gtkosx_application_get_resource_path(void)
  * Returns: The path to the primary executable, or %NULL if it can't find one. g_free() it when done
  */
 gchar*
-gtkosx_application_get_executable_path(void)
+gtkosx_application_get_executable_path (void)
 {
   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
   gchar *str = NULL;
   NSString *path = [[NSBundle mainBundle] executablePath];
   if (!path)
     return NULL;
-  str = strdup([path UTF8String]);
+  str = strdup ([path UTF8String]);
   [pool release];
   return str;
 }
@@ -1018,16 +1034,17 @@ gtkosx_application_get_executable_path(void)
  * Returns: A UTF8-encoded string. g_free() it when done.
  */
 gchar*
-gtkosx_application_get_bundle_info(const gchar *key)
+gtkosx_application_get_bundle_info (const gchar *key)
 {
   gchar *result = NULL;
   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
   NSObject *id = [[NSBundle mainBundle] objectForInfoDictionaryKey:
                  [NSString stringWithUTF8String: key]];
 
-  if ([id respondsToSelector: @selector(UTF8String)]) {
-    result = g_strdup( [(NSString*)id UTF8String]);
-  }
+  if ([id respondsToSelector: @selector (UTF8String)])
+    {
+      result = g_strdup ([(NSString*)id UTF8String]);
+    }
 
   [pool release];
   return result;
diff --git a/src/test-integration.c b/src/test-integration.c
index 1a5ee82..0d6678b 100644
--- a/src/test-integration.c
+++ b/src/test-integration.c
@@ -89,7 +89,8 @@
 #endif
 #include <config.h>
 
-typedef struct {
+typedef struct
+{
   GtkWindow *window;
   GtkWidget *open_item;
   GtkWidget *edit_item;
@@ -104,33 +105,38 @@ typedef struct {
 static GQuark menu_items_quark = 0;
 
 static MenuItems *
-menu_items_new() {
-    return g_slice_new0 (MenuItems);
+menu_items_new ()
+{
+  return g_slice_new0 (MenuItems);
 }
 
 static void
-menu_items_destroy(MenuItems *items) {
-    g_slice_free(MenuItems, items);
+menu_items_destroy (MenuItems *items)
+{
+  g_slice_free (MenuItems, items);
 }
 
-typedef struct {
-    gchar *label;
-    gpointer item;
+typedef struct
+{
+  gchar *label;
+  gpointer item;
 } MenuCBData;
 
 static MenuCBData *
-menu_cbdata_new (gchar *label, gpointer item) {
-    MenuCBData *datum =  g_slice_new0 (MenuCBData);
-    datum->label = label;
-    datum->item = item;
-    g_object_ref (datum->item);
-    return datum;
+menu_cbdata_new (gchar *label, gpointer item)
+{
+  MenuCBData *datum =  g_slice_new0 (MenuCBData);
+  datum->label = label;
+  datum->item = item;
+  g_object_ref (datum->item);
+  return datum;
 }
 
 static void
-menu_cbdata_delete (MenuCBData *datum) {
-    g_object_unref (datum->item);
-    g_slice_free (MenuCBData, datum);
+menu_cbdata_delete (MenuCBData *datum)
+{
+  g_object_unref (datum->item);
+  g_slice_free (MenuCBData, datum);
 }
 
 static void
@@ -139,12 +145,12 @@ menu_item_activate_cb (GtkWidget *item,
 {
   gboolean visible;
   gboolean sensitive;
-  MenuItems *items = g_object_get_qdata (G_OBJECT(datum->item),
-                                        menu_items_quark);
-  if (GTK_IS_WINDOW(G_OBJECT(datum->item)))
-      g_print ("Item activated: %s:%s\n",
-              gtk_window_get_title(GTK_WINDOW(datum->item)),
-              datum->label);
+  MenuItems *items = g_object_get_qdata (G_OBJECT (datum->item),
+                                         menu_items_quark);
+  if (GTK_IS_WINDOW (G_OBJECT (datum->item)))
+    g_print ("Item activated: %s:%s\n",
+             gtk_window_get_title (GTK_WINDOW (datum->item)),
+             datum->label);
   else
     g_print ("Item activated %s\n", datum->label);
 
@@ -156,91 +162,110 @@ menu_item_activate_cb (GtkWidget *item,
                 "sensitive", &sensitive,
                 NULL);
 
-  if (item == items->open_item) {
-    gtk_widget_set_sensitive (items->copy_item,
-                             !gtk_widget_get_sensitive(items->copy_item));
-  }
+  if (item == items->open_item)
+    {
+      gtk_widget_set_sensitive (items->copy_item,
+                                !gtk_widget_get_sensitive (items->copy_item));
+    }
 }
 
 #ifdef BUILT_UI
-static GtkWidget *create_window(const gchar *title);
+static GtkWidget *create_window (const gchar *title);
 
 static void
-action_activate_cb(GtkAction* action, gpointer data)
+action_activate_cb (GtkAction* action, gpointer data)
 {
   GtkWindow *window = data;
-  g_print("Window %s, Action %s\n", gtk_window_get_title(window),
-         gtk_action_get_name(action));
+  g_print ("Window %s, Action %s\n", gtk_window_get_title (window),
+           gtk_action_get_name (action));
 }
 
 static void
-new_window_cb(GtkAction* action, gpointer data)
+new_window_cb (GtkAction* action, gpointer data)
 {
   static guint serial = 2;
   gchar *title;
-  g_print("Create New Window\n");
-  title = g_strdup_printf( "Test Integration Window %d", serial++);
-  create_window(title);
-  g_free(title);
+  g_print ("Create New Window\n");
+  title = g_strdup_printf ( "Test Integration Window %d", serial++);
+  create_window (title);
+  g_free (title);
 
 }
 
 static void
-minimize_cb (GtkAction *action, gpointer data) {
-  g_return_if_fail(data != NULL);
-  gtk_window_iconify(GTK_WINDOW(data));
+minimize_cb (GtkAction *action, gpointer data)
+{
+  g_return_if_fail (data != NULL);
+  gtk_window_iconify (GTK_WINDOW (data));
 }
 
 static void
-front_cb (GtkAction *action, gpointer data) {
-  g_return_if_fail(data != NULL);
+front_cb (GtkAction *action, gpointer data)
+{
+  g_return_if_fail (data != NULL);
 }
 
 static GtkActionEntry test_actions[] =
+{
+  /*{Name, stock_id, label, accelerator, tooltip, callback} */
+  {"FileMenuAction", NULL, "_File", NULL, NULL, NULL},
   {
-    /*{Name, stock_id, label, accelerator, tooltip, callback} */
-    {"FileMenuAction", NULL, "_File", NULL, NULL, NULL},
-    {"OpenAction",  GTK_STOCK_OPEN, "_Open", NULL, NULL,
-     G_CALLBACK(action_activate_cb)},
-    {"QuitAction", GTK_STOCK_QUIT, "_Quit", NULL, NULL,
-     G_CALLBACK(gtk_main_quit)},
-    {"EditMenuAction", NULL, "_Edit", NULL, NULL, NULL },
-    {"WindowsMenuAction", NULL, "_Window", NULL, NULL, NULL },
-    {"CopyAction", GTK_STOCK_COPY, "_Copy", NULL, NULL,
-     G_CALLBACK(action_activate_cb)},
-    {"PasteAction", GTK_STOCK_PASTE, "_Paste", NULL, NULL,
-     G_CALLBACK(action_activate_cb)},
-    {"PrefsAction", GTK_STOCK_PREFERENCES, "Pr_eferences", NULL, NULL,
-     G_CALLBACK(action_activate_cb) },
-    {"MinimizeAction", NULL, "_Minimize", "<meta>m", NULL, G_CALLBACK(minimize_cb)},
-    {"FrontAction", NULL, "Bring All to Front", NULL, NULL, G_CALLBACK(front_cb)},
-    {"AddWindowAction", NULL, "_Add Window", NULL, NULL,
-     G_CALLBACK(new_window_cb)},
-    {"HelpMenuAction", NULL, "_Help", NULL, NULL, NULL },
-    {"AboutAction", GTK_STOCK_ABOUT, "_About", NULL, NULL,
-     G_CALLBACK(action_activate_cb)},
-    {"HelpAction", GTK_STOCK_HELP, "_Help", NULL, NULL,
-     G_CALLBACK(action_activate_cb)},
-  };
+    "OpenAction",  GTK_STOCK_OPEN, "_Open", NULL, NULL,
+    G_CALLBACK (action_activate_cb)
+  },
+  {
+    "QuitAction", GTK_STOCK_QUIT, "_Quit", NULL, NULL,
+    G_CALLBACK (gtk_main_quit)
+  },
+  {"EditMenuAction", NULL, "_Edit", NULL, NULL, NULL },
+  {"WindowsMenuAction", NULL, "_Window", NULL, NULL, NULL },
+  {
+    "CopyAction", GTK_STOCK_COPY, "_Copy", NULL, NULL,
+    G_CALLBACK (action_activate_cb)
+  },
+  {
+    "PasteAction", GTK_STOCK_PASTE, "_Paste", NULL, NULL,
+    G_CALLBACK (action_activate_cb)
+  },
+  {
+    "PrefsAction", GTK_STOCK_PREFERENCES, "Pr_eferences", NULL, NULL,
+    G_CALLBACK (action_activate_cb)
+  },
+  {"MinimizeAction", NULL, "_Minimize", "<meta>m", NULL, G_CALLBACK (minimize_cb)},
+  {"FrontAction", NULL, "Bring All to Front", NULL, NULL, G_CALLBACK (front_cb)},
+  {
+    "AddWindowAction", NULL, "_Add Window", NULL, NULL,
+    G_CALLBACK (new_window_cb)
+  },
+  {"HelpMenuAction", NULL, "_Help", NULL, NULL, NULL },
+  {
+    "AboutAction", GTK_STOCK_ABOUT, "_About", NULL, NULL,
+    G_CALLBACK (action_activate_cb)
+  },
+  {
+    "HelpAction", GTK_STOCK_HELP, "_Help", NULL, NULL,
+    G_CALLBACK (action_activate_cb)
+  },
+};
 
 static void
 radio_item_changed_cb (GtkAction* action, GtkAction* current, MenuCBData *datum)
 {
-    g_print ("Radio group %s in window %s changed value: %s is now active.\n",
-            datum->label, gtk_window_get_title(GTK_WINDOW(datum->item)),
-            gtk_action_get_name(GTK_ACTION(current)));
+  g_print ("Radio group %s in window %s changed value: %s is now active.\n",
+           datum->label, gtk_window_get_title (GTK_WINDOW (datum->item)),
+           gtk_action_get_name (GTK_ACTION (current)));
 }
 
 static GtkActionEntry view_menu[] =
 {
-    {"ViewMenuAction", NULL, "_View", NULL, NULL, NULL},
+  {"ViewMenuAction", NULL, "_View", NULL, NULL, NULL},
 };
 
 static GtkRadioActionEntry view_actions[] =
 {
-/* Name, StockID, Label, Accelerator, Tooltip, Value */
-    {"HorizontalAction", NULL, "_Horizontal", NULL, NULL, 0},
-    {"VerticalAction", NULL, "_Vertical", NULL, NULL, 0},
+  /* Name, StockID, Label, Accelerator, Tooltip, Value */
+  {"HorizontalAction", NULL, "_Horizontal", NULL, NULL, 0},
+  {"VerticalAction", NULL, "_Vertical", NULL, NULL, 0},
 };
 #else //not BUILT_UI
 # if !defined QUARTZ_HANDLERS && defined GTKOSXAPPLICATION
@@ -250,9 +275,9 @@ static GtkRadioActionEntry view_actions[] =
  * GtkActions, otherwise hiding the menu disables accelerators. */
 
 static gboolean
-can_activate_cb(GtkWidget* widget, guint signal_id, gpointer data)
+can_activate_cb (GtkWidget* widget, guint signal_id, gpointer data)
 {
-  return gtk_widget_is_sensitive(widget);
+  return gtk_widget_is_sensitive (widget);
 }
 # endif //!QUARTZ_HANDLERS
 
@@ -267,30 +292,30 @@ test_setup_menu (MenuItems *items, GtkAccelGroup *accel)
   item = gtk_menu_item_new_with_label ("File");
   gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item);
   menu = gtk_menu_new ();
-  gtk_menu_set_accel_group(GTK_MENU(menu), accel);
-  gtk_menu_set_accel_path(GTK_MENU(menu), "<test-integration>/File");
+  gtk_menu_set_accel_group (GTK_MENU (menu), accel);
+  gtk_menu_set_accel_path (GTK_MENU (menu), "<test-integration>/File");
   gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu);
-  item = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
+  item = gtk_image_menu_item_new_from_stock (GTK_STOCK_OPEN, NULL);
   items->open_item = item;
-/* We're being fancy with our connection here so that we don't have to
- * have a separate callback function for each menu item, since each
- * one is going to print out a message saying what item got
- * selected. A real-life menu item usually uses just
- * g-signal_connect() to a dedicated callback -- or uses GuiManager
- * action closures.
- */
+  /* We're being fancy with our connection here so that we don't have to
+   * have a separate callback function for each menu item, since each
+   * one is going to print out a message saying what item got
+   * selected. A real-life menu item usually uses just
+   * g-signal_connect() to a dedicated callback -- or uses GuiManager
+   * action closures.
+   */
   g_signal_connect_data (item, "activate", G_CALLBACK (menu_item_activate_cb),
-                        menu_cbdata_new ("open", items->window),
-                        (GClosureNotify) menu_cbdata_delete, 0);
+                         menu_cbdata_new ("open", items->window),
+                         (GClosureNotify) menu_cbdata_delete, 0);
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
-  items->quit_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
+  items->quit_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL);
   g_signal_connect (items->quit_item, "activate", G_CALLBACK (gtk_main_quit), NULL);
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), items->quit_item);
 //Set accelerators
-  gtk_accel_map_add_entry("<test-integration>/File/Open", GDK_o,
-                         GDK_CONTROL_MASK);
-  gtk_accel_map_add_entry("<test-integration>/File/Quit", GDK_q,
-                         GDK_CONTROL_MASK);
+  gtk_accel_map_add_entry ("<test-integration>/File/Open", GDK_o,
+                           GDK_CONTROL_MASK);
+  gtk_accel_map_add_entry ("<test-integration>/File/Quit", GDK_q,
+                           GDK_CONTROL_MASK);
   items->edit_item = item = gtk_menu_item_new_with_label ("Edit");
 
   gtk_menu_shell_append (GTK_MENU_SHELL (menubar), item);
@@ -299,21 +324,21 @@ test_setup_menu (MenuItems *items, GtkAccelGroup *accel)
   item = gtk_menu_item_new_with_label ("Copy");
   items->copy_item = item;
   g_signal_connect_data (item, "activate", G_CALLBACK (menu_item_activate_cb),
-                        menu_cbdata_new ("copy", items->window),
-                        (GClosureNotify) menu_cbdata_delete, 0);
+                         menu_cbdata_new ("copy", items->window),
+                         (GClosureNotify) menu_cbdata_delete, 0);
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
   item = gtk_menu_item_new_with_label ("Paste");
   g_signal_connect_data (item, "activate", G_CALLBACK (menu_item_activate_cb),
-                        menu_cbdata_new ( "paste", items->window),
-                        (GClosureNotify) menu_cbdata_delete, 0);
+                         menu_cbdata_new ( "paste", items->window),
+                         (GClosureNotify) menu_cbdata_delete, 0);
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
   items->preferences_item = gtk_menu_item_new_with_label ("Preferences");
   g_signal_connect_data (items->preferences_item, "activate",
-                        G_CALLBACK (menu_item_activate_cb),
-                        menu_cbdata_new ("preferences", items->window),
-                        (GClosureNotify) menu_cbdata_delete, 0);
+                         G_CALLBACK (menu_item_activate_cb),
+                         menu_cbdata_new ("preferences", items->window),
+                         (GClosureNotify) menu_cbdata_delete, 0);
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), items->preferences_item);
 
   item = gtk_menu_item_new_with_label ("Help");
@@ -324,9 +349,9 @@ test_setup_menu (MenuItems *items, GtkAccelGroup *accel)
 
   items->about_item = gtk_menu_item_new_with_label ("About");
   g_signal_connect_data (items->about_item, "activate",
-                        G_CALLBACK (menu_item_activate_cb),
-                        menu_cbdata_new ("about", items->window),
-                        (GClosureNotify) menu_cbdata_delete, 0);
+                         G_CALLBACK (menu_item_activate_cb),
+                         menu_cbdata_new ("about", items->window),
+                         (GClosureNotify) menu_cbdata_delete, 0);
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), items->about_item);
 
   return menubar;
@@ -356,12 +381,13 @@ change_icon_cb (GtkWidget  *button,
   static gboolean   changed;
   static GdkPixbuf *pixbuf;
 
-  if (!pixbuf) {
+  if (!pixbuf)
+    {
       char filename[PATH_MAX];
-      snprintf (filename, sizeof(filename), "%s/%s", PREFIX,
-                "share/gtk-2.0/demo/gnome-foot.png");
+      snprintf (filename, sizeof (filename), "%s/%s", PREFIX,
+                "share/gtk-2.0/demo/gnome-foot.png");
       pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
-  }
+    }
 
   if (changed)
     gtk_mac_dock_set_icon_from_pixbuf (dock, NULL);
@@ -371,16 +397,17 @@ change_icon_cb (GtkWidget  *button,
   changed = !changed;
 }
 #elif defined GTKOSXAPPLICATION
-typedef struct {
+typedef struct
+{
   GtkosxApplication *app;
   GtkosxApplicationAttentionType type;
 } AttentionRequest;
 
 static gboolean
-attention_cb(AttentionRequest* req)
+attention_cb (AttentionRequest* req)
 {
-  gtkosx_application_attention_request(req->app, req->type);
-  g_free(req);
+  gtkosx_application_attention_request (req->app, req->type);
+  g_free (req);
   return FALSE;
 }
 
@@ -391,8 +418,8 @@ bounce_cb (GtkWidget  *button,
   AttentionRequest *req = g_new0 (AttentionRequest, 1);
   req->app = app;
   req->type = CRITICAL_REQUEST;
-  g_timeout_add_seconds(2, (GSourceFunc)attention_cb, req);
-  g_print("Now switch to some other application\n");
+  g_timeout_add_seconds (2, (GSourceFunc)attention_cb, req);
+  g_print ("Now switch to some other application\n");
 }
 
 static void
@@ -401,12 +428,13 @@ change_icon_cb (GtkWidget  *button,
 {
   static gboolean   changed;
   static GdkPixbuf *pixbuf;
-  if (!pixbuf) {
+  if (!pixbuf)
+    {
       char filename[PATH_MAX];
-      snprintf (filename, sizeof(filename), "%s/%s", PREFIX,
-                "share/gtk-2.0/demo/gnome-foot.png");
+      snprintf (filename, sizeof (filename), "%s/%s", PREFIX,
+                "share/gtk-2.0/demo/gnome-foot.png");
       pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
-  }
+    }
 
   if (changed)
     gtkosx_application_set_dock_icon_pixbuf (app, NULL);
@@ -417,7 +445,7 @@ change_icon_cb (GtkWidget  *button,
 }
 #else //Neither GTKMACINTEGRATION nor GTKOSXAPPLICATION
 static gboolean
-attention_cb(gpointer req)
+attention_cb (gpointer req)
 {
 }
 static void
@@ -436,82 +464,89 @@ static void
 change_menu_cb (GtkWidget  *button,
                 gpointer    user_data)
 {
-  GtkWidget *window = gtk_widget_get_toplevel(button);
-  MenuItems *items = g_object_get_qdata(G_OBJECT(window), menu_items_quark);
+  GtkWidget *window = gtk_widget_get_toplevel (button);
+  MenuItems *items = g_object_get_qdata (G_OBJECT (window), menu_items_quark);
   const gchar* open_accel_path =
-      gtk_menu_item_get_accel_path(GTK_MENU_ITEM(items->open_item));
+    gtk_menu_item_get_accel_path (GTK_MENU_ITEM (items->open_item));
   const gchar* quit_accel_path =
-      gtk_menu_item_get_accel_path(GTK_MENU_ITEM(items->quit_item));
-
-  if (gtk_widget_get_visible(items->edit_item)) {
-      gtk_widget_set_visible(items->edit_item, FALSE);
-      gtk_accel_map_change_entry(open_accel_path, GDK_o,
-                                GDK_MOD1_MASK, TRUE);
-      gtk_accel_map_change_entry(quit_accel_path, GDK_q,
-                                GDK_MOD1_MASK, TRUE);
-  } else {
-     gtk_widget_set_visible(items->edit_item, TRUE);
-     gtk_accel_map_change_entry(open_accel_path, GDK_o,
-                               GDK_CONTROL_MASK, TRUE);
-     gtk_accel_map_change_entry(quit_accel_path, GDK_q,
-                               GDK_CONTROL_MASK, TRUE);
-  }
+    gtk_menu_item_get_accel_path (GTK_MENU_ITEM (items->quit_item));
+
+  if (gtk_widget_get_visible (items->edit_item))
+    {
+      gtk_widget_set_visible (items->edit_item, FALSE);
+      gtk_accel_map_change_entry (open_accel_path, GDK_o,
+                                  GDK_MOD1_MASK, TRUE);
+      gtk_accel_map_change_entry (quit_accel_path, GDK_q,
+                                  GDK_MOD1_MASK, TRUE);
+    }
+  else
+    {
+      gtk_widget_set_visible (items->edit_item, TRUE);
+      gtk_accel_map_change_entry (open_accel_path, GDK_o,
+                                  GDK_CONTROL_MASK, TRUE);
+      gtk_accel_map_change_entry (quit_accel_path, GDK_q,
+                                  GDK_CONTROL_MASK, TRUE);
+    }
 }
 
 static void
 view_menu_cb (GtkWidget *button, gpointer user_data)
 {
 #ifdef BUILT_UI
-  GtkToggleButton *toggle = GTK_TOGGLE_BUTTON(button);
+  GtkToggleButton *toggle = GTK_TOGGLE_BUTTON (button);
   static guint mergeid = 0;
   static GtkActionGroup* view_action_group = NULL;
   GtkUIManager *mgr = user_data;
-  GtkWidget *window = gtk_widget_get_toplevel(button);
-  GtkosxApplication *theApp = g_object_new(GTKOSX_TYPE_APPLICATION, NULL);
+  GtkWidget *window = gtk_widget_get_toplevel (button);
+  GtkosxApplication *theApp = g_object_new (GTKOSX_TYPE_APPLICATION, NULL);
   GError *err = NULL;
-  if (view_action_group == NULL) {
-    view_action_group = gtk_action_group_new("ViewAction");
-    gtk_action_group_add_actions(view_action_group, view_menu,
-                                sizeof(view_menu)/sizeof(GtkActionEntry),
-                                NULL);
-    gtk_action_group_add_radio_actions_full(
-           view_action_group, view_actions,
-           sizeof(view_actions)/sizeof(GtkRadioActionEntry),
-           0, G_CALLBACK(radio_item_changed_cb),
-           menu_cbdata_new ("View", GTK_WINDOW(window)),
-           (GDestroyNotify) menu_cbdata_delete );
-  }
-  if (gtk_toggle_button_get_active(toggle)) {
-    mergeid = gtk_ui_manager_add_ui_from_file(mgr, "src/addedui.xml", &err);
-    if (err) {
-      g_print("Error retrieving file: %d %s\n", mergeid, err->message);
+  if (view_action_group == NULL)
+    {
+      view_action_group = gtk_action_group_new ("ViewAction");
+      gtk_action_group_add_actions (view_action_group, view_menu,
+                                    sizeof (view_menu) / sizeof (GtkActionEntry),
+                                    NULL);
+      gtk_action_group_add_radio_actions_full (
+        view_action_group, view_actions,
+        sizeof (view_actions) / sizeof (GtkRadioActionEntry),
+        0, G_CALLBACK (radio_item_changed_cb),
+        menu_cbdata_new ("View", GTK_WINDOW (window)),
+        (GDestroyNotify) menu_cbdata_delete );
     }
-    gtk_ui_manager_insert_action_group(mgr, view_action_group, 0);
+  if (gtk_toggle_button_get_active (toggle))
     {
-      GtkWidget *menu = gtk_menu_new();
-      GtkWidget *item;
-      item = gtk_menu_item_new_with_label("Framish");
-      g_signal_connect_data (item, "activate",
-                            G_CALLBACK (menu_item_activate_cb),
-                            menu_cbdata_new ( "Framish", item),
-                            (GClosureNotify) menu_cbdata_delete, 0);
-      gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
-      item = gtk_menu_item_new_with_label("Freebish");
-      g_signal_connect_data (item, "activate",
-                            G_CALLBACK (menu_item_activate_cb),
-                            menu_cbdata_new ( "Freebish", item),
-                            (GClosureNotify) menu_cbdata_delete, 0);
-      gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
-      gtkosx_application_set_dock_menu(theApp, GTK_MENU_SHELL(menu));
+      mergeid = gtk_ui_manager_add_ui_from_file (mgr, "src/addedui.xml", &err);
+      if (err)
+        {
+          g_print ("Error retrieving file: %d %s\n", mergeid, err->message);
+        }
+      gtk_ui_manager_insert_action_group (mgr, view_action_group, 0);
+      {
+        GtkWidget *menu = gtk_menu_new ();
+        GtkWidget *item;
+        item = gtk_menu_item_new_with_label ("Framish");
+        g_signal_connect_data (item, "activate",
+                               G_CALLBACK (menu_item_activate_cb),
+                               menu_cbdata_new ( "Framish", item),
+                               (GClosureNotify) menu_cbdata_delete, 0);
+        gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+        item = gtk_menu_item_new_with_label ("Freebish");
+        g_signal_connect_data (item, "activate",
+                               G_CALLBACK (menu_item_activate_cb),
+                               menu_cbdata_new ( "Freebish", item),
+                               (GClosureNotify) menu_cbdata_delete, 0);
+        gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+        gtkosx_application_set_dock_menu (theApp, GTK_MENU_SHELL (menu));
+      }
+    }
+  else if (mergeid)
+    {
+      gtk_ui_manager_remove_action_group (mgr, view_action_group);
+      gtk_ui_manager_remove_ui (mgr, mergeid);
+      mergeid = 0;
     }
-  }
-  else if (mergeid) {
-    gtk_ui_manager_remove_action_group(mgr, view_action_group);
-    gtk_ui_manager_remove_ui(mgr, mergeid);
-    mergeid = 0;
-  }
 #else //Not BUILT_UI
-  g_print("View Menu Toggle Button doesn't actually do anything in the hand-built menu build\n");
+  g_print ("View Menu Toggle Button doesn't actually do anything in the hand-built menu build\n");
 #endif //BUILT_UI
 }
 
@@ -519,7 +554,7 @@ view_menu_cb (GtkWidget *button, gpointer user_data)
 static void
 app_active_cb (GtkosxApplication* app, gboolean* data)
 {
-  g_print("Application became %s\n", *data ? "active" : "inactive");
+  g_print ("Application became %s\n", *data ? "active" : "inactive");
 }
 
 static gboolean
@@ -530,7 +565,7 @@ app_should_quit_cb (GtkosxApplication *app, gpointer data)
   answer = abort;
   abort = FALSE;
   g_print ("Application has been requested to quit, %s\n", answer ? "but no!" :
-          "it's OK.");
+           "it's OK.");
   return answer;
 }
 
@@ -538,14 +573,14 @@ static void
 app_will_quit_cb (GtkosxApplication *app, gpointer data)
 {
   g_print ("Quitting Now\n");
-  gtk_main_quit();
+  gtk_main_quit ();
 }
 
 static gboolean
 app_open_file_cb (GtkosxApplication *app, gchar *path, gpointer user_data)
 {
-    g_print("File open event for %s", path);
-    return FALSE;
+  g_print ("File open event for %s", path);
+  return FALSE;
 }
 
 #endif //GTKOSXAPPLICATION
@@ -554,11 +589,11 @@ app_open_file_cb (GtkosxApplication *app, gchar *path, gpointer user_data)
 gboolean _gtk_mac_menu_is_quit_menu_item_handled (void);
 
 static GtkWidget *
-create_window(GtkMacDock *dock, const gchar *title)
+create_window (GtkMacDock *dock, const gchar *title)
 {
 #else
 static GtkWidget *
-create_window(const gchar *title)
+create_window (const gchar *title)
 {
   gpointer     dock = NULL;
 #endif //not GTKMACINTEGRATION
@@ -568,25 +603,25 @@ create_window(const gchar *title)
   GtkWidget       *bbox;
   GtkWidget       *button;
   GtkWidget      *textentry;
-  MenuItems       *items = menu_items_new();
+  MenuItems       *items = menu_items_new ();
 #ifdef BUILT_UI
-  GtkUIManager *mgr = gtk_ui_manager_new();
-  GtkActionGroup *actions = gtk_action_group_new("TestActions");
+  GtkUIManager *mgr = gtk_ui_manager_new ();
+  GtkActionGroup *actions = gtk_action_group_new ("TestActions");
   guint mergeid;
   GError *err = NULL;
   GtkAccelGroup *accel_group;
 #else //not BUILT_UI
-  GtkAccelGroup *accel_group = gtk_accel_group_new();
+  GtkAccelGroup *accel_group = gtk_accel_group_new ();
 #endif //not BUILT_UI
 #ifdef GTKMACINTEGRATION
   GtkMacMenuGroup *group;
 #endif //GTKMACINTEGRATION
 #ifdef GTKOSXAPPLICATION
-  GtkosxApplication *theApp = g_object_new(GTKOSX_TYPE_APPLICATION, NULL);
+  GtkosxApplication *theApp = g_object_new (GTKOSX_TYPE_APPLICATION, NULL);
 #endif //GTKOSXAPPLICATION
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   if (title)
-      gtk_window_set_title (GTK_WINDOW (window), title);
+    gtk_window_set_title (GTK_WINDOW (window), title);
   gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
   items->window = GTK_WINDOW (window);
 #if GTK_CHECK_VERSION(3, 0, 0)
@@ -596,30 +631,31 @@ create_window(const gchar *title)
 #endif
   gtk_container_add (GTK_CONTAINER (window), vbox);
 #ifdef BUILT_UI
-  mergeid = gtk_ui_manager_add_ui_from_file(mgr, "src/testui.xml", &err);
-  if (err) {
-    g_print("Error retrieving file: %d %s\n", mergeid, err->message);
-    exit (1);
-  }
-  gtk_action_group_add_actions(actions, test_actions,
-                              G_N_ELEMENTS (test_actions),
-                              (gpointer)window);
-  gtk_ui_manager_insert_action_group(mgr, actions, 0);
-  menubar = gtk_ui_manager_get_widget(mgr, "/menubar");
-  items->open_item = gtk_ui_manager_get_widget(mgr, "/menubar/File/Open");
-  items->edit_item = gtk_ui_manager_get_widget(mgr, "/menubar/Edit");
-  items->copy_item = gtk_ui_manager_get_widget(mgr, "/menubar/Edit/Copy");
-  items->help_menu = gtk_ui_manager_get_widget(mgr, "/menubar/Help");
-  items->quit_item = gtk_ui_manager_get_widget(mgr, "/menubar/File/Quit");
-  items->about_item = gtk_ui_manager_get_widget(mgr, "/menubar/Help/About");
-  items->window_menu = gtk_ui_manager_get_widget(mgr, "/menubar/Window");
-  items->preferences_item = gtk_ui_manager_get_widget(mgr, "/menubar/Edit/Preferences");
-  accel_group = gtk_ui_manager_get_accel_group(mgr);
+  mergeid = gtk_ui_manager_add_ui_from_file (mgr, "src/testui.xml", &err);
+  if (err)
+    {
+      g_print ("Error retrieving file: %d %s\n", mergeid, err->message);
+      exit (1);
+    }
+  gtk_action_group_add_actions (actions, test_actions,
+                                G_N_ELEMENTS (test_actions),
+                                (gpointer)window);
+  gtk_ui_manager_insert_action_group (mgr, actions, 0);
+  menubar = gtk_ui_manager_get_widget (mgr, "/menubar");
+  items->open_item = gtk_ui_manager_get_widget (mgr, "/menubar/File/Open");
+  items->edit_item = gtk_ui_manager_get_widget (mgr, "/menubar/Edit");
+  items->copy_item = gtk_ui_manager_get_widget (mgr, "/menubar/Edit/Copy");
+  items->help_menu = gtk_ui_manager_get_widget (mgr, "/menubar/Help");
+  items->quit_item = gtk_ui_manager_get_widget (mgr, "/menubar/File/Quit");
+  items->about_item = gtk_ui_manager_get_widget (mgr, "/menubar/Help/About");
+  items->window_menu = gtk_ui_manager_get_widget (mgr, "/menubar/Window");
+  items->preferences_item = gtk_ui_manager_get_widget (mgr, "/menubar/Edit/Preferences");
+  accel_group = gtk_ui_manager_get_accel_group (mgr);
 #else //not BUILT_UI
   menubar = test_setup_menu (items, accel_group);
   items->window_menu = NULL;
 #endif //not BUILT_UI
-  gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
+  gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
   gtk_box_pack_start (GTK_BOX (vbox),
                       menubar,
                       FALSE, TRUE, 0);
@@ -657,27 +693,27 @@ create_window(const gchar *title)
   gtk_box_pack_start (GTK_BOX (bbox),
                       button,
                       FALSE, FALSE, 0);
-  button = gtk_toggle_button_new_with_label("View Menu");
-  textentry = gtk_entry_new();
-  gtk_box_pack_start(GTK_BOX (vbox), textentry, TRUE, TRUE, 2);
+  button = gtk_toggle_button_new_with_label ("View Menu");
+  textentry = gtk_entry_new ();
+  gtk_box_pack_start (GTK_BOX (vbox), textentry, TRUE, TRUE, 2);
 #ifdef BUILT_UI
-  g_signal_connect(button, "toggled", G_CALLBACK (view_menu_cb), (gpointer)mgr);
+  g_signal_connect (button, "toggled", G_CALLBACK (view_menu_cb), (gpointer)mgr);
 #else //not BUILT_UI
-  g_signal_connect(button, "toggled", G_CALLBACK (view_menu_cb), NULL);
+  g_signal_connect (button, "toggled", G_CALLBACK (view_menu_cb), NULL);
 #endif //not BUILT_UI
-  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE);
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
   gtk_box_pack_start (GTK_BOX (bbox),
-                     button,
-                     FALSE, FALSE, 0);
+                      button,
+                      FALSE, FALSE, 0);
 
   gtk_widget_show_all (window);
 #if defined GTK_MAC_MENU || defined GTKOSXAPPLICATION
   gtk_widget_hide (menubar);
 # ifdef GTKOSXAPPLICATION
-/* Not really necessary unless quartz accelerator handling is turned off. */
+  /* Not really necessary unless quartz accelerator handling is turned off. */
 #  if !defined QUARTZ_HANDLERS && !defined BUILT_UI
-  g_signal_connect(menubar, "can-activate-accel",
-                  G_CALLBACK(can_activate_cb), NULL);
+  g_signal_connect (menubar, "can-activate-accel",
+                    G_CALLBACK (can_activate_cb), NULL);
 #  endif // !defined QUARTZ_HANDLERS && !defined BUILT_UI
 # endif  //GTKOSXAPPLICATION
 #endif //defined GTK_MAC_MENU || defined GTKOSXAPPLICATION
@@ -686,35 +722,35 @@ create_window(const gchar *title)
   gtk_mac_menu_set_quit_menu_item (GTK_MENU_ITEM (items->quit_item));
   group = gtk_mac_menu_add_app_menu_group ();
   gtk_mac_menu_add_app_menu_item  (group,
-                                  GTK_MENU_ITEM (items->about_item),
-                                  "About");
+                                   GTK_MENU_ITEM (items->about_item),
+                                   "About");
   group = gtk_mac_menu_add_app_menu_group ();
   gtk_mac_menu_add_app_menu_item  (group,
-                                  GTK_MENU_ITEM (items->preferences_item),
-                                  "Preferences");
+                                   GTK_MENU_ITEM (items->preferences_item),
+                                   "Preferences");
 #endif //GTKMACINTEGRATION
 #ifdef GTKOSXAPPLICATION
   GtkWidget *sep;
-  gtkosx_application_set_menu_bar(theApp, GTK_MENU_SHELL(menubar));
+  gtkosx_application_set_menu_bar (theApp, GTK_MENU_SHELL (menubar));
   gtkosx_application_insert_app_menu_item  (theApp, items->about_item,
-                                           0);
-  sep = gtk_separator_menu_item_new();
-  g_object_ref(sep);
+      0);
+  sep = gtk_separator_menu_item_new ();
+  g_object_ref (sep);
   gtkosx_application_insert_app_menu_item  (theApp, sep, 1);
   gtkosx_application_insert_app_menu_item  (theApp,
-                                           items->preferences_item,
-                                           2);
-  sep = gtk_separator_menu_item_new();
-  g_object_ref(sep);
+      items->preferences_item,
+      2);
+  sep = gtk_separator_menu_item_new ();
+  g_object_ref (sep);
   gtkosx_application_insert_app_menu_item  (theApp, sep, 3);
 
-  gtkosx_application_set_help_menu(theApp, GTK_MENU_ITEM(items->help_menu));
-  gtkosx_application_set_window_menu(theApp, GTK_MENU_ITEM(items->window_menu));
+  gtkosx_application_set_help_menu (theApp, GTK_MENU_ITEM (items->help_menu));
+  gtkosx_application_set_window_menu (theApp, GTK_MENU_ITEM (items->window_menu));
 #endif //GTKOSXAPPLICATION
   if (!menu_items_quark)
-      menu_items_quark = g_quark_from_static_string("MenuItem");
-  g_object_set_qdata_full(G_OBJECT(window), menu_items_quark,
-                         items, (GDestroyNotify)menu_items_destroy);
+    menu_items_quark = g_quark_from_static_string ("MenuItem");
+  g_object_set_qdata_full (G_OBJECT (window), menu_items_quark,
+                           items, (GDestroyNotify)menu_items_destroy);
   return window;
 }
 
@@ -732,15 +768,15 @@ main (int argc, char **argv)
   GtkosxApplication *theApp;
 #endif //GTKOSXAPPLICATION
 #ifndef HAVE_GLIB_2_31
-  g_thread_init(NULL);
+  g_thread_init (NULL);
 #endif
 #if ! GTK_CHECK_VERSION(3, 0, 0)
-  gdk_threads_init();
+  gdk_threads_init ();
 #endif //not Gtk3
   gtk_init (&argc, &argv);
 #ifdef GTKMACINTEGRATION
   dock = gtk_mac_dock_get_default ();
-  window1 = create_window(dock, "Test Integration Window 1");
+  window1 = create_window (dock, "Test Integration Window 1");
   dock = gtk_mac_dock_new ();
   g_signal_connect (dock,
                     "clicked",
@@ -753,43 +789,44 @@ main (int argc, char **argv)
                     window1);
 #elif defined(GTKOSXAPPLICATION)
 
-  theApp  = g_object_new(GTKOSX_TYPE_APPLICATION, NULL);
-  window1 = create_window("Test Integration Window 1");
+  theApp  = g_object_new (GTKOSX_TYPE_APPLICATION, NULL);
+  window1 = create_window ("Test Integration Window 1");
 # ifndef BUILT_UI
-  window2 = create_window("Test Integration Window 2");
+  window2 = create_window ("Test Integration Window 2");
 # endif
   {
     gboolean falseval = FALSE;
     gboolean trueval = TRUE;
-    g_signal_connect(theApp, "NSApplicationDidBecomeActive",
-                    G_CALLBACK(app_active_cb), &trueval);
-    g_signal_connect(theApp, "NSApplicationWillResignActive",
-                    G_CALLBACK(app_active_cb), &falseval);
-    g_signal_connect(theApp, "NSApplicationBlockTermination",
-                    G_CALLBACK(app_should_quit_cb), NULL);
-    g_signal_connect(theApp, "NSApplicationWillTerminate",
-                    G_CALLBACK(app_will_quit_cb), NULL);
-    g_signal_connect(theApp, "NSApplicationOpenFile",
-                    G_CALLBACK(app_open_file_cb), NULL);
+    g_signal_connect (theApp, "NSApplicationDidBecomeActive",
+                      G_CALLBACK (app_active_cb), &trueval);
+    g_signal_connect (theApp, "NSApplicationWillResignActive",
+                      G_CALLBACK (app_active_cb), &falseval);
+    g_signal_connect (theApp, "NSApplicationBlockTermination",
+                      G_CALLBACK (app_should_quit_cb), NULL);
+    g_signal_connect (theApp, "NSApplicationWillTerminate",
+                      G_CALLBACK (app_will_quit_cb), NULL);
+    g_signal_connect (theApp, "NSApplicationOpenFile",
+                      G_CALLBACK (app_open_file_cb), NULL);
   }
 # ifndef QUARTZ_HANDLERS
-  gtkosx_application_set_use_quartz_accelerators(theApp, FALSE);
+  gtkosx_application_set_use_quartz_accelerators (theApp, FALSE);
 # endif //QUARTZ_HANDLERS
-  gtkosx_application_ready(theApp);
+  gtkosx_application_ready (theApp);
   {
-    const gchar *id = gtkosx_application_get_bundle_id();
-    if (id != NULL) {
-      g_print ("TestIntegration Error! Bundle Has ID %s\n", id);
-    }
+    const gchar *id = gtkosx_application_get_bundle_id ();
+    if (id != NULL)
+      {
+        g_print ("TestIntegration Error! Bundle Has ID %s\n", id);
+      }
   }
 #else //i.e., no integration
-  window1 = create_window("Test Integration Window 1");
-  window2 = create_window("Test Integration Window 2");
+  window1 = create_window ("Test Integration Window 1");
+  window2 = create_window ("Test Integration Window 2");
 #endif //GTKOSXAPPLICATION
-  gtk_accel_map_load("accel_map");
+  gtk_accel_map_load ("accel_map");
   gtk_main ();
 #ifdef GTKOSXAPPLICATION
-  g_object_unref(theApp);
+  g_object_unref (theApp);
 #endif //GTKOSXAPPLICATION
   return 0;
 }


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]