sync-menu.c

Go to the documentation of this file.

/* GTK+ Integration for the Mac OS X Menubar.
 *
 * Copyright (C) 2007 Pioneer Research Center USA, Inc.
 * Copyright (C) 2007 Imendio AB
 *
 * For further information, see:
 * http://developer.imendio.com/projects/gtk-macosx/menubar
 *
 * 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 distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>

#include <Carbon/Carbon.h>

#include <gtkmm2ext/sync-menu.h>


/* TODO
 *
 * - Sync adding/removing/reordering items
 * - 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...
 *
 */

#define IGE_QUARTZ_MENU_CREATOR 'IGEC'
#define IGE_QUARTZ_ITEM_WIDGET  'IWID'


static void   sync_menu_shell (GtkMenuShell *menu_shell,
                               MenuRef       carbon_menu,
                               gboolean      toplevel,
                               gboolean      debug);


/*
 * 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;
        }

      g_list_free (children);
    }

  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;
}

static gboolean
accel_find_func (GtkAccelKey *key,
                 GClosure    *closure,
                 gpointer     data)
{
  return (GClosure *) data == closure;
}


/*
 * CarbonMenu functions
 */

typedef struct
{
  MenuRef menu;
} CarbonMenu;

static GQuark carbon_menu_quark = 0;

static CarbonMenu *
carbon_menu_new (void)
{
  return g_slice_new0 (CarbonMenu);
}

static void
carbon_menu_free (CarbonMenu *menu)
{
  g_slice_free (CarbonMenu, menu);
}

static CarbonMenu *
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)
{
  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;
}


/*
 * CarbonMenuItem functions
 */

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);
}

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);
}

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_state (CarbonMenuItem *carbon_item,
                               GtkWidget      *widget)
{
  gboolean sensitive;
  gboolean visible;
  UInt32   set_attrs = 0;
  UInt32   clear_attrs = 0;

  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;

  ChangeMenuItemAttributes (carbon_item->menu, carbon_item->index,
                            set_attrs, clear_attrs);
}

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);
}

static void
carbon_menu_item_update_submenu (CarbonMenuItem *carbon_item,
                                 GtkWidget      *widget)
{
  GtkWidget *submenu;

  submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));

  if (submenu)
    {
      const gchar *label_text;
      CFStringRef  cfstr = NULL;

      label_text = get_menu_label_text (widget, NULL);
      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)
        CFRelease (cfstr);
    }
  else
    {
      SetMenuItemHierarchicalMenu (carbon_item->menu, carbon_item->index,
                                   NULL);
      carbon_item->submenu = NULL;
    }
}

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);
}

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;
          gint             use_command;
          gboolean         add_modifiers = FALSE;
          UInt8            modifiers = 0; /* implies Command key */

          if (gdk_keymap_get_entries_for_keyval (keymap, key->accel_key,
                                                 &keys, &n_keys) == 0)
            {
                  gint realkey = -1;

                  switch (key->accel_key) {
                  case GDK_rightarrow:
                  case GDK_Right:
                          realkey = kRightArrowCharCode;
                          break;
                  case GDK_leftarrow:
                  case GDK_Left:
                          realkey = kLeftArrowCharCode;
                          break;
                  case GDK_uparrow:
                  case GDK_Up:
                          realkey = kUpArrowCharCode;
                          break;
                  case GDK_downarrow:
                  case GDK_Down:
                          realkey = kDownArrowCharCode;
                          break;
                  default:
                          break;
                  }
          
                  if (realkey != -1) {
                          SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
                                                 false, realkey);
                          add_modifiers = TRUE;
                  }

            } else {
                 SetMenuItemCommandKey (carbon_item->menu, carbon_item->index, true, keys[0].keycode);
                 if (keys[0].level == 1) {
                         /* regular key, but it needs shift to make it work */
                         modifiers |= kMenuShiftModifier;
                 }

                 g_free (keys);
                 add_modifiers = TRUE;
            }

          if (add_modifiers)
            {
             UInt8 modifiers = 0; /* implies Command key */

              use_command = 0;

              if (key->accel_mods)
                {
                  if (key->accel_mods & GDK_SHIFT_MASK) {
                    modifiers |= kMenuShiftModifier;
                  }

                  /* gdk/quartz maps Alt/Option to Mod1 */

                  if (key->accel_mods & (GDK_MOD1_MASK)) {
                    modifiers |= kMenuOptionModifier;
                  }

                  if (key->accel_mods & GDK_CONTROL_MASK) {
                    modifiers |= kMenuControlModifier;
                  }

                  /* gdk/quartz maps Command to Meta */
                  
                  if (key->accel_mods & GDK_META_MASK) {
                          use_command = 1;
                  }
                }  

              if (!use_command)
                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);
}

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;

  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);
}

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);
    }

  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));
    }
}

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));
    }
}

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_item->menu  = menu;
  carbon_item->index = index;

  return carbon_item;
}


/*
 * carbon event handler
 */

static int _in_carbon_menu_event_handler = 0;

int 
gdk_quartz_in_carbon_menu_event_handler ()
{
        return _in_carbon_menu_event_handler;
}

static gboolean
dummy_gtk_menu_item_activate (gpointer *arg)
{
        gtk_menu_item_activate (GTK_MENU_ITEM(arg));
        return FALSE;
}

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;
  OSStatus ret;

  _in_carbon_menu_event_handler = 1;

  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))
                {
                  g_idle_add ((GSourceFunc) dummy_gtk_menu_item_activate, widget);
                  // gtk_menu_item_activate (GTK_MENU_ITEM (widget));
                  _in_carbon_menu_event_handler = 0;
                  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;

        default:
          break;
        }

      break;

    default:
      break;
    }

  ret = CallNextEventHandler (event_handler_call_ref, event_ref);
  _in_carbon_menu_event_handler = 0;
  return ret;
}

static void
setup_menu_event_handler (void)
{
  EventHandlerUPP menu_event_handler_upp;
  EventHandlerRef menu_event_handler_ref;
  const EventTypeSpec menu_events[] = {
    { kEventClassCommand, kEventCommandProcess },
    { kEventClassMenu, kEventMenuTargetItem },
    { kEventClassMenu, kEventMenuOpening },
    { kEventClassMenu, kEventMenuClosed }
  };

  /* FIXME: We might have to install one per window? */

  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);

#if 0
  /* FIXME: Remove the handler with: */
  RemoveEventHandler(menu_event_handler_ref);
  DisposeEventHandlerUPP(menu_event_handler_upp);
#endif
}

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);

  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;
        }

      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))
            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_index++;
    }

  g_list_free (children);
}


static gulong emission_hook_id = 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)));
#endif

              sync_menu_shell (GTK_MENU_SHELL (menu_shell),
                               carbon_menu->menu,
                               carbon_menu->menu == (MenuRef) data,
                               FALSE);
            }
        }
    }

  return TRUE;
}

static void
parent_set_emission_hook_remove (GtkWidget *widget,
                                 gpointer   data)
{
  g_signal_remove_emission_hook (g_signal_lookup ("parent-set",
                                                  GTK_TYPE_WIDGET),
                                 emission_hook_id);
}


/*
 * public functions
 */

void
ige_mac_menu_set_menu_bar (GtkMenuShell *menu_shell)
{
  MenuRef carbon_menubar;

  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");

  CreateNewMenu (0 /*id*/, 0 /*options*/, &carbon_menubar);
  SetRootMenu (carbon_menubar);

  setup_menu_event_handler ();

  emission_hook_id =
    g_signal_add_emission_hook (g_signal_lookup ("parent-set",
                                                 GTK_TYPE_WIDGET),
                                0,
                                parent_set_emission_hook,
                                carbon_menubar, NULL);

  g_signal_connect (menu_shell, "destroy",
                    G_CALLBACK (parent_set_emission_hook_remove),
                    NULL);

  sync_menu_shell (menu_shell, carbon_menubar, TRUE, FALSE);
}

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));

  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));
    }
}


struct _IgeMacMenuGroup
{
  GList *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);

  return group;
}

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));

  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)
            label = get_menu_label_text (GTK_WIDGET (menu_item), NULL);

          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);
}