--- ige-mac-menu.c.orig	2010-07-21 15:00:57.000000000 -0400
+++ ige-mac-menu.c	2010-07-21 15:01:08.000000000 -0400
@@ -1,15 +1,16 @@
 /* GTK+ Integration for the Mac OS X Menubar.
  *
  * Copyright (C) 2007 Pioneer Research Center USA, Inc.
- * Copyright (C) 2007 Imendio AB
+ * Copyright (C) 2007, 2008 Imendio AB
+ * Copyright © 2009, 2010 John Ralls
  *
  * For further information, see:
- * http://developer.imendio.com/projects/gtk-macosx/menubar
+ * http://sourceforge.net/apps/trac/gtk-osx/wiki/Integrate
  *
- * This library is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; version 2.1
- * of the License.
+ * This library is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -17,20 +18,22 @@
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see
- * <http://www.gnu.org/licenses/>.
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
  */
 
+#ifndef __x86_64__
 #include "config.h"
 
 #include <gtk/gtk.h>
-
-#ifdef GDK_WINDOWING_QUARTZ
-
 #include <gdk/gdkkeysyms.h>
+#include <gdk/gdkquartz.h>
 #include <Carbon/Carbon.h>
+#import <Cocoa/Cocoa.h>
 
 #include "ige-mac-menu.h"
+#include "ige-mac-private.h"
 
 /* TODO
  *
@@ -38,453 +41,634 @@
  * - Sync reordering items? Does that work now?
  * - Create on demand? (can this be done with gtk+? ie fill in menu
      items when the menu is opened)
- * - Figure out what to do per app/window...
  *
+ * - Deleting a menu item that is not the last one in a menu doesn't work
  */
 
 #define IGE_QUARTZ_MENU_CREATOR 'IGEC'
 #define IGE_QUARTZ_ITEM_WIDGET  'IWID'
 
+#define IGE_MAC_KEY_HANDLER     "ige-mac-key-handler"
 
-static void   sync_menu_shell (GtkMenuShell *menu_shell,
-			       MenuRef       carbon_menu,
-			       gboolean      toplevel,
-			       gboolean      debug);
+#define DEBUG FALSE
+#define DEBUG_SET FALSE
+#define DEBUG_SYNC FALSE
+#define DEBUG_SIGNAL FALSE
+#define DEBUG_CARBON FALSE
+
+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);
+
+/* A category that exposes the protected carbon event for an NSEvent. */
+@interface NSEvent (GdkQuartzNSEvent)
+- (void *)gdk_quartz_event_ref;
+@end
+
+@implementation NSEvent (GdkQuartzNSEvent)
+- (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;
+}
 
 /*
  * utility functions
  */
 
 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;
+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);
+	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);
+
+  GClosure *closure = NULL;
+  g_object_get(G_OBJECT(label), "accel-closure", &closure, NULL);
+  return closure;
+}
 
 /*
  * CarbonMenu functions
+ *
+ * A CarbonMenu contains a reference to the OSX menu; connect attaches
+ * it to the GtkMenu so that sync_menu will know which OSX menu to
+ * synchronise as it recurses through the GtkMenu tree. There is no
+ * back-pointer from the OSX Menu to the GtkMenu. Note that Gtk
+ * doesn't have an "App" menu (the one named after the application),
+ * 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)
-{
-  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;
 }
 
 
 /*
  * CarbonMenuItem functions
+ *
+ * Like CarbonMenu, the CarbonMenuItem contains a reference to the OSX
+ * Menu which contains it and the index the menu item in that menu
+ * (there aren't pointers directly to menu items in Carbon like there
+ * are in Cocoa). If the item has a submenu, there's a reference for
+ * that object as well, and there's a pointer to the accelerator for
+ * connecting signals from. This structure is inserted into the
+ * GtkMenuItem, and pointer to the GtkMenuItem is attached to the OSX
+ * Menu at the indicated index. Much effort goes into ensuring that
+ * the indices stay synchronized, as interesting behavior will result
+ * 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)
-{
-  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 CarbonMenuItem *
-carbon_menu_item_get (GtkWidget *widget)
-{
-  return g_object_get_qdata (G_OBJECT (widget), carbon_menu_item_quark);
+static const gchar *
+carbon_menu_error_string(OSStatus err) {
+    switch (err) {
+    case 0:
+	return "No Error";
+    case -50:
+	return "User Parameter List";
+    case -5603:
+	return "Menu Property Reserved Creator Type";
+    case -5604:
+	return "Menu Property Not Found";
+    case -5620:
+	return "Menu Not Found";
+    case -5621:
+	return "Menu uses system definition";
+    case -5622:
+	return "Menu Item Not Found";
+    case -5623:
+	return "Menu Reference Invalid";
+    case -9860:
+	return "Event Already Posted";
+    case -9861:
+	return "Event Target Busy";
+    case -9862:
+	return "Invalid Event Class";
+    case -9864:
+	return "Incorrect Event Class";
+    case -9866:
+	return "Event Handler Already Installed";
+    case -9868:
+	return "Internal Event Error";
+    case -9869:
+	return "Incorrect Event Kind";
+    case -9870:
+	return "Event Parameter Not Found";
+    case -9874:
+	return "Event Not Handled";
+    case -9875:
+	return "Event Loop Timeout";
+    case -9876:
+	return "Event Loop Quit";
+    case -9877:
+	return  "Event Not In Queue";
+    case -9878:
+	return "Hot Key Exists";
+    case -9879:
+	return "Invalid Hot Key";
+    default:
+	return "Invalid Error Code";
+    }
+    return "System Error: Unreachable";
 }
 
-static void
-carbon_menu_item_update_state (CarbonMenuItem *carbon_item,
-			       GtkWidget      *widget)
-{
-  gboolean sensitive;
-  gboolean visible;
-  UInt32   set_attrs = 0;
-  UInt32   clear_attrs = 0;
+#define carbon_menu_warn(err, msg) \
+    if (err && DEBUG_CARBON) \
+	g_printerr("%s: %s %s\n", G_STRFUNC, msg, carbon_menu_error_string(err));
+
+#define carbon_menu_warn_label(err, label, msg) \
+    if (err && DEBUG_CARBON) \
+	g_printerr("%s: %s %s %s\n", G_STRFUNC, label, msg, carbon_menu_error_string(err));
+
+#define carbon_menu_err_return(err, msg) \
+    if (err) { \
+    	if (DEBUG_CARBON) \
+	    g_printerr("%s: %s %s\n", G_STRFUNC, msg, carbon_menu_error_string(err)); \
+	return;\
+    }
 
-  g_object_get (widget,
-                "sensitive", &sensitive,
-                "visible",   &visible,
-                NULL);
+#define carbon_menu_err_return_val(err, msg, val) \
+    if (err) { \
+    	if (DEBUG_CARBON) \
+	    g_printerr("%s: %s %s\n", G_STRFUNC, msg, carbon_menu_error_string(err)); \
+	return val;\
+    }
 
-  if (!sensitive)
-    set_attrs |= kMenuItemAttrDisabled;
-  else
-    clear_attrs |= kMenuItemAttrDisabled;
+#define carbon_menu_err_return_label(err, label, msg)	\
+    if (err) { \
+    	if (DEBUG_CARBON) \
+	    g_printerr("%s: %s %s %s\n", G_STRFUNC, label, msg, carbon_menu_error_string(err)); \
+	return;\
+    }
 
-  if (!visible)
-    set_attrs |= kMenuItemAttrHidden;
-  else
-    clear_attrs |= kMenuItemAttrHidden;
+#define carbon_menu_err_return_label_val(err, label, msg, val)	\
+    if (err) { \
+    	if (DEBUG_CARBON) \
+	    g_printerr("%s: %s %s %s\n", G_STRFUNC, label, msg, carbon_menu_error_string(err)); \
+	return val;\
+    }
 
-  ChangeMenuItemAttributes (carbon_item->menu, carbon_item->index,
-                            set_attrs, clear_attrs);
+static CarbonMenuItem *
+carbon_menu_item_get (GtkWidget *widget) {
+    return g_object_get_qdata (G_OBJECT (widget), carbon_menu_item_quark);
 }
 
-static void
-carbon_menu_item_update_active (CarbonMenuItem *carbon_item,
-				GtkWidget      *widget)
-{
-  gboolean active;
+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);
 
-  g_object_get (widget,
-                "active", &active,
-                NULL);
+    if (!carbon_item)
+	return NULL;
 
-  CheckMenuItem (carbon_item->menu, carbon_item->index,
-		 active);
+    /* Get any GtkWidget associated with the item. */
+    err = GetMenuItemProperty (carbon_item->menu, carbon_item->index,
+			       IGE_QUARTZ_MENU_CREATOR,
+			       IGE_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;
+    }
+    return carbon_item;
 }
 
 static void
-carbon_menu_item_update_submenu (CarbonMenuItem *carbon_item,
-				 GtkWidget      *widget)
-{
-  GtkWidget *submenu;
-
-  submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
+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");
+}
 
-  if (submenu)
-    {
-      const gchar *label_text;
-      CFStringRef  cfstr = NULL;
+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);
+}
 
-      label_text = get_menu_label_text (widget, NULL);
-      if (label_text)
-        cfstr = CFStringCreateWithCString (NULL, label_text,
+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;
+    }
+    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);
 
-      CreateNewMenu (0, 0, &carbon_item->submenu);
-      SetMenuTitleWithCFString (carbon_item->submenu, cfstr);
-      SetMenuItemHierarchicalMenu (carbon_item->menu, carbon_item->index,
-				   carbon_item->submenu);
-
-      sync_menu_shell (GTK_MENU_SHELL (submenu), carbon_item->submenu, FALSE, FALSE);
-
-      if (cfstr)
+    err = SetMenuTitleWithCFString (carbon_item->submenu, cfstr);
+    if (cfstr)
 	CFRelease (cfstr);
-    }
-  else
-    {
-      SetMenuItemHierarchicalMenu (carbon_item->menu, carbon_item->index,
-				   NULL);
-      carbon_item->submenu = NULL;
-    }
+    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;
-
-  label_text = get_menu_label_text (widget, NULL);
-  if (label_text)
-    cfstr = CFStringCreateWithCString (NULL, label_text,
-				       kCFStringEncodingUTF8);
-
-  SetMenuItemTextWithCFString (carbon_item->menu, carbon_item->index,
-			       cfstr);
-
-  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)
-{
-  GtkWidget *label;
-
-  get_menu_label_text (widget, &label);
-
-  if (GTK_IS_ACCEL_LABEL (label) &&
-      GTK_ACCEL_LABEL (label)->accel_closure)
-    {
-      GtkAccelKey *key;
-
-      key = gtk_accel_group_find (GTK_ACCEL_LABEL (label)->accel_group,
-				  accel_find_func,
-				  GTK_ACCEL_LABEL (label)->accel_closure);
-
-      if (key            &&
-	  key->accel_key &&
-	  key->accel_flags & GTK_ACCEL_VISIBLE)
-	{
-	  GdkDisplay      *display = gtk_widget_get_display (widget);
-	  GdkKeymap       *keymap  = gdk_keymap_get_for_display (display);
-	  GdkKeymapKey    *keys;
-	  gint             n_keys;
-
-	  if (gdk_keymap_get_entries_for_keyval (keymap, key->accel_key,
-						 &keys, &n_keys))
-	    {
-	      UInt8 modifiers = 0;
-
-	      SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
-				     true, keys[0].keycode);
-
-	      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;
-		}
-
-	      SetMenuItemModifiers (carbon_item->menu, carbon_item->index,
-				    modifiers);
-
-	      return;
-	    }
-	}
-    }
-
-  /*  otherwise, clear the menu shortcut  */
-  SetMenuItemModifiers (carbon_item->menu, carbon_item->index,
-			kMenuNoModifiers | kMenuNoCommandModifier);
-  ChangeMenuItemAttributes (carbon_item->menu, carbon_item->index,
-			    0, kMenuItemAttrUseVirtualKey);
-  SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
-			 false, 0);
+				     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;
+    }
+    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;
+    }
+    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,
+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;
-
-  get_menu_label_text (widget, &label);
-
-  if (GTK_IS_ACCEL_LABEL (label) &&
-      GTK_ACCEL_LABEL (label)->accel_closure == accel_closure)
-    carbon_menu_item_update_accelerator (carbon_item, widget);
+				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);
 }
 
 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;
-    }
-
-  if (GTK_IS_ACCEL_LABEL (label))
-    carbon_item->accel_closure = GTK_ACCEL_LABEL (label)->accel_closure;
-
-  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);
+				       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);
     }
-
-  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));
-    }
-  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));
-    }
+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));
+    }
+    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 (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 (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));
+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;
+    }
+   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));
     }
 }
 
 static CarbonMenuItem *
-carbon_menu_item_connect (GtkWidget     *menu_item,
-			  GtkWidget     *label,
-			  MenuRef        menu,
-			  MenuItemIndex  index)
-{
-  CarbonMenuItem *carbon_item = carbon_menu_item_get (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_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);
+    }
+    carbon_item->menu  = menu;
+    carbon_item->index = index;
+    return carbon_item;
+}
 
-  carbon_item->menu  = menu;
-  carbon_item->index = index;
+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,
+			       IGE_QUARTZ_MENU_CREATOR,
+			       IGE_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;
+    }
+    return carbon_item;
+}
+
+
+typedef struct {
+    GtkWidget *widget;
+} ActivateIdleData;
+
+static void
+activate_destroy_cb (gpointer user_data) {
+    ActivateIdleData *data = user_data;
 
-  return carbon_item;
+    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;
+
+    if (data->widget)
+	gtk_menu_item_activate (GTK_MENU_ITEM (data->widget));
+    return FALSE;
+}
 
 /*
  * carbon event handler
@@ -492,287 +676,371 @@
 
 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);
-  MenuRef menu_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)
-    {
+    switch (event_class) {
     case kEventClassCommand:
-      /* This is called when activating (is that the right GTK+ term?)
-       * a menu item.
-       */
-      if (event_kind == kEventCommandProcess)
-	{
-	  HICommand command;
-	  OSStatus  err;
-
-	  /*g_printerr ("Menu: kEventClassCommand/kEventCommandProcess\n");*/
-
-	  err = GetEventParameter (event_ref, kEventParamDirectObject,
-				   typeHICommand, 0,
-				   sizeof (command), 0, &command);
-
-	  if (err == noErr)
-	    {
-	      GtkWidget *widget = NULL;
-
-	      /* Get any GtkWidget associated with the item. */
-	      err = GetMenuItemProperty (command.menu.menuRef,
-					 command.menu.menuItemIndex,
-					 IGE_QUARTZ_MENU_CREATOR,
-					 IGE_QUARTZ_ITEM_WIDGET,
-					 sizeof (widget), 0, &widget);
-	      if (err == noErr && GTK_IS_WIDGET (widget))
-		{
-		  gtk_menu_item_activate (GTK_MENU_ITEM (widget));
-		  return noErr;
-		}
-	    }
-	}
-      break;
-
-    case kEventClassMenu:
-      GetEventParameter (event_ref,
-			 kEventParamDirectObject,
-			 typeMenuRef,
-			 NULL,
-			 sizeof (menu_ref),
-			 NULL,
-			 &menu_ref);
-
-      switch (event_kind)
-	{
-	case kEventMenuTargetItem:
-	  /* This is called when an item is selected (what is the
-	   * GTK+ term? prelight?)
-	   */
-	  /*g_printerr ("kEventClassMenu/kEventMenuTargetItem\n");*/
-	  break;
-
-	case kEventMenuOpening:
-	  /* Is it possible to dynamically build the menu here? We
-	   * can at least set visibility/sensitivity.
-	   */
-	  /*g_printerr ("kEventClassMenu/kEventMenuOpening\n");*/
-	  break;
-
-	case kEventMenuClosed:
-	  /*g_printerr ("kEventClassMenu/kEventMenuClosed\n");*/
-	  break;
+	/* This is called when activating (is that the right GTK+ term?)
+	 * a menu item.
+	 */
+	if (event_kind != kEventCommandProcess)
+	    break;
 
-	default:
-	  break;
+#if DEBUG
+	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;
 	}
-
-      break;
-
+	/* Get any GtkWidget associated with the item. */
+	err = GetMenuItemProperty (command.menu.menuRef,
+				   command.menu.menuItemIndex,
+				   IGE_QUARTZ_MENU_CREATOR,
+				   IGE_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;
     default:
-      break;
+	break;
     }
-
-  return CallNextEventHandler (event_handler_call_ref, event_ref);
+    return eventNotHandledErr;
 }
 
-static void
-setup_menu_event_handler (void)
-{
-  static gboolean is_setup = FALSE;
+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;
+}
+
+gboolean
+ige_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;
+    }
+    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);
 
-  EventHandlerUPP menu_event_handler_upp;
-  EventHandlerRef menu_event_handler_ref;
-  const EventTypeSpec menu_events[] = {
-    { kEventClassCommand, kEventCommandProcess },
-    { kEventClassMenu, kEventMenuTargetItem },
-    { kEventClassMenu, kEventMenuOpening },
-    { kEventClassMenu, kEventMenuClosed }
-  };
+	/* FIXME: We could do something to skip menu events if there is a
+	 * modal dialog...
+	 */
+	if (!focus 
+	    || !g_object_get_data (G_OBJECT (focus), IGE_MAC_KEY_HANDLER)) {
+	    if (nsevent_handle_menu_key (nsevent))
+		return GDK_FILTER_REMOVE;
+        }
+    }
+    return GDK_FILTER_CONTINUE;
+}
 
-  if (is_setup)
-    return;
+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;
+
+    /* 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 = ige_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 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);
 
-  /* FIXME: We might have to install one per window? */
+    return handled;
+}
 
-  menu_event_handler_upp = NewEventHandlerUPP (menu_event_handler_func);
-  InstallEventHandler (GetApplicationEventTarget (), menu_event_handler_upp,
-		       GetEventTypeCount (menu_events), menu_events, 0,
-		       &menu_event_handler_ref);
+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");
 #if 0
-  /* FIXME: Remove the handler with: */
-  RemoveEventHandler(menu_event_handler_ref);
-  DisposeEventHandlerUPP(menu_event_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;
-
-  if (debug)
-    g_printerr ("%s: syncing shell %p\n", G_STRFUNC, 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;
-
-      if (GTK_IS_TEAROFF_MENU_ITEM (menu_item))
-	continue;
-
-      if (toplevel && g_object_get_data (G_OBJECT (menu_item),
-					 "gtk-empty-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, get_menu_label_text (menu_item, NULL),
-		    g_type_name (G_TYPE_FROM_INSTANCE (menu_item)));
-
-      if (carbon_item && carbon_item->index != carbon_index)
-	{
-	  if (debug)
-	    g_printerr ("%s:   -> not matching, deleting\n", G_STRFUNC);
-
-	  DeleteMenuItem (carbon_item->menu, carbon_index);
-	  carbon_item = NULL;
+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)
-	{
-	  GtkWidget          *label      = NULL;
-	  const gchar        *label_text;
-	  CFStringRef         cfstr      = NULL;
-	  MenuItemAttributes  attributes = 0;
-
-	  if (debug)
-	    g_printerr ("%s:   -> creating new\n", G_STRFUNC);
-
-	  label_text = get_menu_label_text (menu_item, &label);
-	  if (label_text)
-	    cfstr = CFStringCreateWithCString (NULL, label_text,
-					       kCFStringEncodingUTF8);
-
-	  if (GTK_IS_SEPARATOR_MENU_ITEM (menu_item))
-	    attributes |= kMenuItemAttrSeparator;
-
-	  if (!GTK_WIDGET_IS_SENSITIVE (menu_item))
-	    attributes |= kMenuItemAttrDisabled;
-
-	  if (!GTK_WIDGET_VISIBLE (menu_item))
-	    attributes |= kMenuItemAttrHidden;
-
-	  InsertMenuItemTextWithCFString (carbon_menu, cfstr,
-					  carbon_index - 1,
-					  attributes, 0);
-	  SetMenuItemProperty (carbon_menu, carbon_index,
-			       IGE_QUARTZ_MENU_CREATOR,
-			       IGE_QUARTZ_ITEM_WIDGET,
-			       sizeof (menu_item), &menu_item);
-
-	  if (cfstr)
-	    CFRelease (cfstr);
-
-	  carbon_item = carbon_menu_item_connect (menu_item, label,
-						  carbon_menu,
-						  carbon_index);
-
-	  if (GTK_IS_CHECK_MENU_ITEM (menu_item))
+	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);
+	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;
 	}
 
-      carbon_index++;
+/*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;
 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);
-
-  if (GTK_IS_MENU_ITEM (instance))
-    {
-      GtkWidget *previous_parent = g_value_get_object (param_values + 1);
-      GtkWidget *menu_shell      = NULL;
-
-      if (GTK_IS_MENU_SHELL (previous_parent))
-	{
-	  menu_shell = previous_parent;
-        }
-      else if (GTK_IS_MENU_SHELL (instance->parent))
-	{
-	  menu_shell = instance->parent;
-	}
-
-      if (menu_shell)
-        {
-	  CarbonMenu *carbon_menu = carbon_menu_get (menu_shell);
-
-	  if (carbon_menu)
-	    {
-#if 0
-	      g_printerr ("%s: item %s %p (%s, %s)\n", G_STRFUNC,
-			  previous_parent ? "removed from" : "added to",
-			  menu_shell,
-			  get_menu_label_text (instance, NULL),
-			  g_type_name (G_TYPE_FROM_INSTANCE (instance)));
+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;
+    }
+    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 (!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);
 #endif
-
-	      sync_menu_shell (GTK_MENU_SHELL (menu_shell),
-			       carbon_menu->menu,
-			       carbon_menu->toplevel,
-			       FALSE);
-	    }
-        }
-    }
-
-  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)
-{
-  emission_hook_count--;
-
-  if (emission_hook_count > 0)
-    return;
+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;
+}
 
-  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");
+    }
+    else if (DEBUG){
+	g_printerr("%s: Switched Menu\n", G_STRFUNC);
+    }
+    return FALSE;
 }
 
 
@@ -781,164 +1049,212 @@
  */
 
 void
-ige_mac_menu_set_menu_bar (GtkMenuShell *menu_shell)
-{
-  CarbonMenu *current_menu;
-  MenuRef     carbon_menubar;
-
-  g_return_if_fail (GTK_IS_MENU_SHELL (menu_shell));
+ige_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);
+    }
+    emission_hook_count++;
+    g_signal_connect (menu_shell, "destroy",
+		      G_CALLBACK (parent_set_emission_hook_remove), NULL);
 
-  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)
-    {
-      SetRootMenu (current_menu->menu);
-      return;
-    }
+#if DEBUG_SET
+    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)));
 
-  CreateNewMenu (0 /*id*/, 0 /*options*/, &carbon_menubar);
-  SetRootMenu (carbon_menubar);
+}
 
-  setup_menu_event_handler ();
+void
+ige_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, IGE_QUARTZ_MENU_CREATOR,
+			       IGE_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;
+}
 
-  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);
+void
+ige_mac_menu_connect_window_key_handler (GtkWindow *window) {
+    if (g_object_get_data (G_OBJECT (window), IGE_MAC_KEY_HANDLER)) {
+	g_warning ("Window %p is already connected", window);
+	return;
     }
 
-  emission_hook_count++;
-
-  g_signal_connect (menu_shell, "destroy",
-		    G_CALLBACK (parent_set_emission_hook_remove),
-		    NULL);
-
-  sync_menu_shell (menu_shell, carbon_menubar, TRUE, FALSE);
+    g_signal_connect (window, "key-press-event", 
+		      G_CALLBACK (key_press_event), NULL);
+    g_object_set_data (G_OBJECT (window), IGE_MAC_KEY_HANDLER, 
+		       GINT_TO_POINTER (1));
 }
 
+/* Most applications will want to have this enabled (which is the
+ * defalt). For apps that need to deal with the events themselves, the
+ * global handling can be disabled.
+ */
 void
-ige_mac_menu_set_quit_menu_item (GtkMenuItem *menu_item)
-{
-  MenuRef       appmenu;
-  MenuItemIndex index;
-
-  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
-
-  setup_menu_event_handler ();
-
-  if (GetIndMenuItemWithCommandID (NULL, kHICommandQuit, 1,
-                                   &appmenu, &index) == noErr)
-    {
-      SetMenuItemCommandID (appmenu, index, 0);
-      SetMenuItemProperty (appmenu, index,
-                           IGE_QUARTZ_MENU_CREATOR,
-                           IGE_QUARTZ_ITEM_WIDGET,
-                           sizeof (menu_item), &menu_item);
-
-      gtk_widget_hide (GTK_WIDGET (menu_item));
-    }
+ige_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
+_ige_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);
+}
 
-struct _IgeMacMenuGroup
-{
-  GList *items;
+/* Application Menu Functions
+ *
+ * The "application" menu (the one named the same as the application),
+ * is special because there isn't a corresponding Gtk menu, but OSX
+ * practice puts the About, Preferences, and Quit menu items in it, so
+ * we need to provide a way for app developers to move those items
+ * (and others, if they want) from their Gtk locations to the app
+ * menu.
+ */
+struct _IgeMacMenuGroup {
+    GList *items;
 };
-
+/* app_menu_groups is a list of IgeMacMenuGroups, itself a list of
+ * menu_items. They're provided to insert separators into the app
+ * menu, grouping the items. 
+*/
 static GList *app_menu_groups = NULL;
 
 IgeMacMenuGroup *
-ige_mac_menu_add_app_menu_group (void)
-{
-  IgeMacMenuGroup *group = g_slice_new0 (IgeMacMenuGroup);
-
-  app_menu_groups = g_list_append (app_menu_groups, group);
+ige_mac_menu_add_app_menu_group (void) {
+    IgeMacMenuGroup *group = g_slice_new0 (IgeMacMenuGroup);
 
-  return group;
+    app_menu_groups = g_list_append (app_menu_groups, group);
+    return group;
 }
 
+/** Move a menu item to the App menu (the one named with the
+ * application's name). This has issues with multiple window menubars,
+ * because the menu items are tied to a particular window's menu and
+ * because there's only one App menu in Carbon regardless of how many
+ * menubars there are. Don't use this for Quit, it has its own
+ * function.
+ */
 void
-ige_mac_menu_add_app_menu_item (IgeMacMenuGroup *group,
-				GtkMenuItem     *menu_item,
-				const gchar     *label)
-{
-  MenuRef  appmenu;
-  GList   *list;
-  gint     index = 0;
-
-  g_return_if_fail (group != NULL);
-  g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
-
-  setup_menu_event_handler ();
-
-  if (GetIndMenuItemWithCommandID (NULL, kHICommandHide, 1,
-                                   &appmenu, NULL) != noErr)
-    {
-      g_warning ("%s: retrieving app menu failed",
-		 G_STRFUNC);
-      return;
-    }
-
-  for (list = app_menu_groups; list; list = g_list_next (list))
-    {
-      IgeMacMenuGroup *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)
-	{
-	  CFStringRef cfstr;
-
-	  /*  add a separator before adding the first item, but not
-	   *  for the first group
-	   */
-	  if (!group->items && list->prev)
-	    {
-	      InsertMenuItemTextWithCFString (appmenu, NULL, index,
-					      kMenuItemAttrSeparator, 0);
-	      index++;
-	    }
-
-	  if (!label)
+ige_mac_menu_add_app_menu_item (IgeMacMenuGroup *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)) {
+	IgeMacMenuGroup *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,
+				   IGE_QUARTZ_MENU_CREATOR,
+				   IGE_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);
+//Bail out: The rest of the menu doesn't matter.
+	return;
 
-	  cfstr = CFStringCreateWithCString (NULL, label,
-					     kCFStringEncodingUTF8);
-
-	  InsertMenuItemTextWithCFString (appmenu, cfstr, index, 0, 0);
-	  SetMenuItemProperty (appmenu, index + 1,
-			       IGE_QUARTZ_MENU_CREATOR,
-			       IGE_QUARTZ_ITEM_WIDGET,
-			       sizeof (menu_item), &menu_item);
-
-	  CFRelease (cfstr);
-
-	  gtk_widget_hide (GTK_WIDGET (menu_item));
-
-	  group->items = g_list_append (group->items, menu_item);
-
-	  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);
+}
+/** Syncronize changes in the GtkMenuBar to an already-created Mac
+ * MenuBar. You must have already run ige_mac_menu_set_menu_bar on the
+ * GtkMenuBar to be synced.
+ */
+void
+ige_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);
+#endif
+    sync_menu_shell (menu_shell, carbon_menu->menu,
+		     carbon_menu->toplevel, DEBUG_SYNC);
 }
 
-#endif /* GDK_WINDOWING_QUARTZ */
+#endif __x86_64__
