path: root/tools/glade/glade/glade_menu_editor.c

/*  Gtk+ User Interface Builder
 *  Copyright (C) 1998  Damon Chaplin
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*
 * The Menu Editor window, based on initial work by Javier Arriero Pa��s
 * and John Looney.
 */

#include <string.h>
#include <time.h>

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtkarrow.h>
#include <gtk/gtkaccellabel.h>
#include <gtk/gtkclist.h>
#include <gtk/gtkcombo.h>
#include <gtk/gtkentry.h>
#include <gtk/gtkeventbox.h>
#include <gtk/gtkfilechooserdialog.h>
#include <gtk/gtkframe.h>
#include <gtk/gtkhbox.h>
#include <gtk/gtkhbbox.h>
#include <gtk/gtkhseparator.h>
#include <gtk/gtkiconfactory.h>
#include <gtk/gtkimage.h>
#include <gtk/gtkimagemenuitem.h>
#include <gtk/gtklist.h>
#include <gtk/gtkmain.h>
#include <gtk/gtkmenu.h>
#include <gtk/gtkmenubar.h>
#include <gtk/gtkradiobutton.h>
#include <gtk/gtkradiomenuitem.h>
#include <gtk/gtkscrolledwindow.h>
#include <gtk/gtkseparatormenuitem.h>
#include <gtk/gtkstock.h>
#include <gtk/gtktable.h>
#include <gtk/gtktearoffmenuitem.h>
#include <gtk/gtkvbox.h>

#include "gladeconfig.h"

#ifdef USE_GNOME
#include <gnome.h>
#include "glade_gnome.h"
#endif

#include "gb.h"
#include "glade_menu_editor.h"
#include "glade_keys_dialog.h"
#include "glade_project.h"
#include "gbwidget.h"
#include "tree.h"
#include "utils.h"

#define GladeMenuEditorIndexKey "glade-menu-editor-index-key"
#define GladeMenuEditorStockIDKey "glade-menu-editor-stock-id"

/* How many pixels to indent levels of the menu hierarchy in the clist. */
#define GB_INDENT	10

/* The text to display if the item is a separator. */
#define GB_SEPARATOR_TEXT "---"

/* This sets the order of the clist columns. */
#define GB_MENUED_NUM_COLS 8

#define GLD_COL_LABEL	0
#define GLD_COL_TYPE	1
#define GLD_COL_ACCEL	2
#define GLD_COL_NAME	3
#define GLD_COL_HANDLER	4
#define GLD_COL_ACTIVE	5
#define GLD_COL_GROUP	6
#define GLD_COL_ICON	7

typedef enum
  {
    GB_MENU_ITEM_NORMAL,
    GB_MENU_ITEM_CHECK,
    GB_MENU_ITEM_RADIO
  }
GbMenuItemType;


/* This holds information on one menu item. */
typedef struct _GbMenuItemData GbMenuItemData;
struct _GbMenuItemData
  {
    gint stock_item_index;	/* Stock menu item index, 0 == None. */
    gchar *label;		/* Text to display. */
    gchar *name;		/* Widget name. */
    gchar *handler;		/* Handler to call when selected. */
    time_t last_mod_time;	/* The time the handler was last updated. */
    gchar *icon;		/* Icon filename, or Stock icon name. */
    gchar *tooltip;		/* Tooltip text. */
    GbMenuItemType type;	/* Type - normal/check/radio. */
    gboolean active;		/* If the item is initially active. */
    GbMenuItemData *group;	/* Points to the item data of the first widget
				   in the radio group, or NULL if it is in its
				   own group or is the first item in group. */
    guint8 modifiers;		/* Control/Shift/Alt flags. */
    gchar *key;			/* Name of accelerator key. */

    gint level;			/* Level in menu hierarchy. */
    gboolean generate_name;	/* If the name should be auto-generated. */
    gboolean generate_handler;	/* If the handler should be auto-generated. */

    GladeWidgetData *wdata;	/* The widget data associated with the old
				   menu item, if there was one. */
  };


static void glade_menu_editor_class_init (GladeMenuEditorClass * klass);
static void glade_menu_editor_init (GladeMenuEditor * dialog);
static void glade_menu_editor_destroy (GtkObject *object);

/* If the menu widget we are editing is destroyed, the menu editor is destroyed
   as well. */
static void glade_menu_editor_on_menu_destroyed (GtkWidget *menu,
						 GtkWidget *menued);

static void on_menu_editor_ok (GtkWidget *button,
			       GladeMenuEditor *menued);
static void on_menu_editor_apply (GtkWidget *button,
				  GladeMenuEditor *menued);
static void on_menu_editor_close (GtkWidget *widget,
				  GladeMenuEditor *menued);

/* This sets the menubar/popup menu whose children are displayed in the
   menu editor, i.e. converted to items in the clist. */
static void glade_menu_editor_set_menu	 (GladeMenuEditor *menued,
					  GtkMenuShell    *menu);

/* This updates the given widget, based on the settings in the menu editor.
   It removes all the current children of the menu and recreates it. */
static void glade_menu_editor_update_menu (GladeMenuEditor *menued);


static gboolean on_key_press (GtkWidget * widget,
			      GdkEventKey * event,
			      gpointer user_data);
static void on_clist_select_row (GtkWidget * clist,
				 gint row,
				 gint column,
				 GdkEventButton * event,
				 gpointer user_data);
static void on_clist_unselect_row (GtkWidget * clist,
				   gint row,
				   gint column,
				   GdkEventButton * event,
				   gpointer user_data);
static void on_entry_changed (GtkWidget * entry,
			      gpointer user_data);
static void on_icon_button_clicked (GtkWidget * button,
				    gpointer user_data);
static void on_icon_filesel_response (GtkWidget * filesel,
				      gint response_id,
				      GladeMenuEditor *menued);
static void on_stock_item_entry_changed (GtkWidget * entry,
					 gpointer user_data);
static gboolean on_label_entry_key_press (GtkWidget * widget,
					  GdkEventKey * event,
					  gpointer user_data);
static void on_radiobutton_toggled (GtkWidget * togglebutton,
				    gpointer user_data);
static void on_checkbutton_toggled (GtkWidget * togglebutton,
				    gpointer user_data);
static void on_state_button_toggled (GtkToggleButton * togglebutton,
				     gpointer user_data);
static void on_accel_key_button_clicked (GtkButton * button,
					 gpointer user_data);
static void on_up_button_clicked (GtkButton * button,
				  gpointer user_data);
static void on_down_button_clicked (GtkButton * button,
				    gpointer user_data);
static void on_left_button_clicked (GtkButton * button,
				    gpointer user_data);
static void on_right_button_clicked (GtkButton * button,
				     gpointer user_data);
static void on_add_button_clicked (GtkWidget * button,
				   gpointer user_data);
static void on_add_child_button_clicked (GtkWidget * button,
					 gpointer user_data);
static void on_add_separator_button_clicked (GtkWidget * button,
					     gpointer user_data);
static void add_item (GladeMenuEditor * menued,
		      gboolean as_child,
		      gboolean separator);
static void on_delete_button_clicked (GtkWidget * widget,
				      gpointer user_data);

static void on_keys_dialog_clist_select (GtkWidget * widget,
					 gint row,
					 gint column,
					 GdkEventButton * bevent,
					 GladeMenuEditor * menued);
static void on_keys_dialog_response (GtkWidget * widget, gint response_id,
				     GladeMenuEditor * menued);

static gint get_selected_row (GladeMenuEditor * menued);
static GbMenuItemData* get_selected_item (GladeMenuEditor * menued);
static void set_interface_state (GladeMenuEditor * menued);
static gchar *get_accel_string (gchar * key,
				guint8 modifiers);
static void insert_item (GtkCList * clist,
			 GbMenuItemData * item,
			 gint row);
static void ensure_visible (GtkWidget *clist,
			    gint row);
static void update_current_item (GladeMenuEditor * menued);
static gboolean item_property_changed (gchar *new, gchar *old);
static gchar* copy_item_property (gchar *property);
static void clear_form (GladeMenuEditor * menued,
			gboolean full);
static void show_item_properties (GladeMenuEditor * menued);
static void insert_items (GtkWidget * clist,
			  GList * items,
			  gint row);
static GList *remove_item_and_children (GtkWidget * clist,
					gint row);
static GtkWidget* create_radio_menu_item (GtkMenuShell *menu,
					  GbMenuItemData *item,
					  GHashTable *group_hash);
static gchar* generate_name (GladeMenuEditor *menued,
			     gchar *label);
static gchar* generate_handler (GladeMenuEditor *menued,
				gint row,
				gchar *label,
				gchar *name);
static void check_generated_handlers (GladeMenuEditor *menued);
static gboolean is_parent (GladeMenuEditor *menued,
			   gint row);
static void set_submenu (GladeMenuEditor *menued,
			 GtkMenuShell    *menu,
			 gint	      level);
static void glade_menu_editor_reset (GladeMenuEditor *menued);
static void glade_menu_editor_free_item (GbMenuItemData *item);

static void update_radio_groups (GladeMenuEditor * menued);
static void normalize_radio_groups (GladeMenuEditor * menued);
static GbMenuItemData* find_radio_group (GtkRadioMenuItem *menuitem,
					 GList **groups,
					 GbMenuItemData *item);
static void remove_from_radio_group (GladeMenuEditor * menued,
				     GbMenuItemData *item);

static GtkWindowClass *parent_class = NULL;


GType
glade_menu_editor_get_type (void)
{
  static GType glade_menu_editor_type = 0;

  if (!glade_menu_editor_type)
    {
      GtkTypeInfo glade_menu_editor_info =
      {
	"GladeMenuEditor",
	sizeof (GladeMenuEditor),
	sizeof (GladeMenuEditorClass),
	(GtkClassInitFunc) glade_menu_editor_class_init,
	(GtkObjectInitFunc) glade_menu_editor_init,
	/* reserved_1 */ NULL,
	/* reserved_2 */ NULL,
	(GtkClassInitFunc) NULL,
      };

      glade_menu_editor_type = gtk_type_unique (gtk_window_get_type (),
						&glade_menu_editor_info);
    }

  return glade_menu_editor_type;
}

static void
glade_menu_editor_class_init (GladeMenuEditorClass * class)
{
  GtkObjectClass *object_class;
  GtkWidgetClass *widget_class;

  object_class = (GtkObjectClass *) class;
  widget_class = (GtkWidgetClass *) class;

  parent_class = gtk_type_class (gtk_window_get_type ());

  object_class->destroy = glade_menu_editor_destroy;
}


/* FIXME: This is mostly a temporary hack until GtkEntry is fixed in GTK+
   2.0.x so we don't get "changed" twice when we call gtk_entry_set_text().
   Though we also need this to set it to "" when NULL is passed in. */
static void
set_entry_text (GtkEntry *entry,
		const gchar *text)
{
  gint tmp_pos;

  GtkEditable *editable;

  g_return_if_fail (GTK_IS_ENTRY (entry));

  if (!text)
    text = "";

  editable = GTK_EDITABLE (entry);
  
  g_signal_handlers_block_by_func (editable, on_entry_changed, NULL);
  gtk_editable_delete_text (GTK_EDITABLE(entry), 0, -1);
  g_signal_handlers_unblock_by_func (editable, on_entry_changed, NULL);

  tmp_pos = 0;
  gtk_editable_insert_text (editable, text, strlen (text), &tmp_pos);
}


static void
glade_menu_editor_init (GladeMenuEditor * menued)
{
  menued->keys_dialog = NULL;
  menued->filesel = NULL;
  menued->project = NULL;
  menued->menu = NULL;
  menued->updating_widgets = FALSE;
  menued->gnome_support = FALSE;
}


static void
glade_menu_editor_construct (GladeMenuEditor * menued,
			     GladeProject * project)
{
  GtkWidget *vbox2, *vbox1, *scrolled_win;
  GtkWidget *hbox1;
  GtkWidget *vbox3;
  GtkWidget *table1;
  GtkWidget *eventbox3;
  GtkWidget *eventbox2;
  GtkWidget *eventbox1;
  GtkWidget *table2;
  GSList *table2_group = NULL;
  GtkWidget *table3;
  GtkWidget *accel_key_button;
  GtkWidget *hbox2;
  GtkWidget *label9;
  GtkWidget *label8;
  GtkWidget *hbuttonbox3;
  GtkWidget *arrow1;
  GtkWidget *arrow2;
  GtkWidget *arrow3;
  GtkWidget *arrow4;
  GtkWidget *button_table;
  GtkWidget *hseparator1;
  GtkWidget *hbuttonbox1;
  GtkWidget *listitem;
  GtkTooltips *tooltips;
  gchar *titles[GB_MENUED_NUM_COLS];
  gint row;
  GSList *elem;
  gchar *stock_id;
  GtkWidget *icon_hbox;
  gchar *label_text;
  gint idx;
#ifdef USE_GNOME
  GnomeUIInfo *uiinfo;
  GtkWidget *pixmap, *label, *hbox, *separator;
#endif

  menued->project = project;
#ifdef USE_GNOME
  if (glade_project_get_gnome_support (project))
    menued->gnome_support = TRUE;
#endif

  tooltips = gtk_tooltips_new ();

  gtk_container_set_border_width (GTK_CONTAINER (menued), 8);
  gtk_window_set_title (GTK_WINDOW (menued), _ ("Menu Editor"));
  gtk_window_set_policy (GTK_WINDOW (menued), FALSE, TRUE, FALSE);
  gtk_window_set_wmclass (GTK_WINDOW (menued), "menu_editor", "Glade");

  vbox2 = gtk_vbox_new (FALSE, 0);
  gtk_widget_show (vbox2);
  gtk_container_add (GTK_CONTAINER (menued), vbox2);

  hbox1 = gtk_hbox_new (FALSE, 6);
  gtk_widget_show (hbox1);
  gtk_box_pack_start (GTK_BOX (vbox2), hbox1, TRUE, TRUE, 0);

  vbox1 = gtk_vbox_new (FALSE, 4);
  gtk_widget_show (vbox1);
  gtk_box_pack_start (GTK_BOX (hbox1), vbox1, TRUE, TRUE, 0);

  titles[GLD_COL_LABEL]		= _("Label");
  titles[GLD_COL_TYPE]		= _("Type");
  titles[GLD_COL_ACCEL]		= _("Accelerator");
  titles[GLD_COL_NAME]		= _("Name");
  titles[GLD_COL_HANDLER]	= _("Handler");
  titles[GLD_COL_ACTIVE]	= _("Active");
  titles[GLD_COL_GROUP]		= _("Group");
  titles[GLD_COL_ICON]		= _("Icon");

  menued->clist = gtk_clist_new_with_titles (GB_MENUED_NUM_COLS, titles);
  gtk_widget_show (menued->clist);
  GTK_WIDGET_SET_FLAGS (menued->clist, GTK_CAN_FOCUS);
  gtk_signal_connect (GTK_OBJECT (menued->clist), "key_press_event",
		      GTK_SIGNAL_FUNC (on_key_press),
		      NULL);
  gtk_widget_set_usize (menued->clist, 300, -1);
  gtk_signal_connect (GTK_OBJECT (menued->clist), "select_row",
		      GTK_SIGNAL_FUNC (on_clist_select_row), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->clist), "unselect_row",
		      GTK_SIGNAL_FUNC (on_clist_unselect_row), NULL);
  gtk_clist_set_column_width (GTK_CLIST (menued->clist), GLD_COL_LABEL, 144);
  gtk_clist_set_column_width (GTK_CLIST (menued->clist), GLD_COL_TYPE, 42);
  gtk_clist_set_column_width (GTK_CLIST (menued->clist), GLD_COL_ACCEL, 120);
  gtk_clist_set_column_width (GTK_CLIST (menued->clist), GLD_COL_NAME, 100);
  gtk_clist_set_column_width (GTK_CLIST (menued->clist), GLD_COL_HANDLER, 172);
  gtk_clist_set_column_width (GTK_CLIST (menued->clist), GLD_COL_ICON, 172);
  gtk_clist_set_column_width (GTK_CLIST (menued->clist), GLD_COL_ACTIVE, 42);
  gtk_clist_set_column_width (GTK_CLIST (menued->clist), GLD_COL_GROUP, 75);
  gtk_clist_column_titles_show (GTK_CLIST (menued->clist));
  gtk_clist_column_titles_passive (GTK_CLIST (menued->clist));

  scrolled_win = gtk_scrolled_window_new (NULL, NULL);
  gtk_container_add (GTK_CONTAINER (scrolled_win), menued->clist);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
				  GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_box_pack_start (GTK_BOX (vbox1), scrolled_win, TRUE, TRUE, 0);
  gtk_widget_show (scrolled_win);

  hbuttonbox3 = gtk_hbutton_box_new ();
  gtk_widget_show (hbuttonbox3);
  gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox3, FALSE, TRUE, 0);
  gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox3),
			     GTK_BUTTONBOX_SPREAD);
  gtk_box_set_spacing (GTK_BOX (hbuttonbox3), 6);

  menued->up_button = gtk_button_new ();
  gtk_widget_show (menued->up_button);
  gtk_container_add (GTK_CONTAINER (hbuttonbox3), menued->up_button);
  gtk_tooltips_set_tip (tooltips, menued->up_button, _ ("Move the item and its children up one place in the list"), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->up_button), "clicked",
		      GTK_SIGNAL_FUNC (on_up_button_clicked),
		      NULL);

  arrow1 = gtk_arrow_new (GTK_ARROW_UP, GTK_SHADOW_OUT);
  gtk_widget_show (arrow1);
  gtk_container_add (GTK_CONTAINER (menued->up_button), arrow1);

  menued->down_button = gtk_button_new ();
  gtk_widget_show (menued->down_button);
  gtk_container_add (GTK_CONTAINER (hbuttonbox3), menued->down_button);
  gtk_tooltips_set_tip (tooltips, menued->down_button, _ ("Move the item and its children down one place in the list"), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->down_button), "clicked",
		      GTK_SIGNAL_FUNC (on_down_button_clicked),
		      NULL);

  arrow2 = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
  gtk_widget_show (arrow2);
  gtk_container_add (GTK_CONTAINER (menued->down_button), arrow2);

  menued->left_button = gtk_button_new ();
  gtk_widget_show (menued->left_button);
  gtk_container_add (GTK_CONTAINER (hbuttonbox3), menued->left_button);
  gtk_tooltips_set_tip (tooltips, menued->left_button, _ ("Move the item and its children up one level"), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->left_button), "clicked",
		      GTK_SIGNAL_FUNC (on_left_button_clicked),
		      NULL);

  arrow3 = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_OUT);
  gtk_widget_show (arrow3);
  gtk_container_add (GTK_CONTAINER (menued->left_button), arrow3);

  menued->right_button = gtk_button_new ();
  gtk_widget_show (menued->right_button);
  gtk_container_add (GTK_CONTAINER (hbuttonbox3), menued->right_button);
  gtk_tooltips_set_tip (tooltips, menued->right_button, _ ("Move the item and its children down one level"), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->right_button), "clicked",
		      GTK_SIGNAL_FUNC (on_right_button_clicked),
		      NULL);

  arrow4 = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
  gtk_widget_show (arrow4);
  gtk_container_add (GTK_CONTAINER (menued->right_button), arrow4);

  vbox3 = gtk_vbox_new (FALSE, 6);
  gtk_widget_show (vbox3);
  gtk_box_pack_start (GTK_BOX (hbox1), vbox3, FALSE, TRUE, 0);

  table1 = gtk_table_new (5, 3, FALSE);
  gtk_widget_show (table1);
  gtk_box_pack_start (GTK_BOX (vbox3), table1, FALSE, TRUE, 0);
  gtk_table_set_row_spacings (GTK_TABLE (table1), 2);
  gtk_table_set_col_spacings (GTK_TABLE (table1), 4);
  row = 0;

  menued->stock_items = gtk_stock_list_ids ();
  menued->stock_items = g_slist_sort (menued->stock_items,
				      glade_util_compare_stock_labels);

  if (!menued->gnome_support)
    {
      eventbox1 = gtk_event_box_new ();
      gtk_widget_show (eventbox1);
      gtk_table_attach (GTK_TABLE (table1), eventbox1, 0, 1, row, row + 1,
			GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
      gtk_tooltips_set_tip (tooltips, eventbox1, _ ("The stock item to use."),
			    NULL);

      menued->stock_label = gtk_label_new (_ ("Stock Item:"));
      gtk_widget_show (menued->stock_label);
      gtk_container_add (GTK_CONTAINER (eventbox1), menued->stock_label);
      gtk_misc_set_alignment (GTK_MISC (menued->stock_label), 0, 0.5);

      menued->stock_combo = gtk_combo_new ();
      gb_widget_set_usize (menued->stock_combo, 100, -1);
      gtk_table_attach (GTK_TABLE (table1), menued->stock_combo, 1, 3,
			row, row + 1, GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
      gtk_combo_set_value_in_list (GTK_COMBO (menued->stock_combo),
				   FALSE, FALSE);
      gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (menued->stock_combo)->entry),
			      FALSE);
      gtk_widget_show (menued->stock_combo);

      listitem = gtk_list_item_new_with_label (_("None"));
      gtk_widget_show (listitem);
      gtk_container_add (GTK_CONTAINER (GTK_COMBO (menued->stock_combo)->list),
			 listitem);

      for (elem = menued->stock_items, idx = 1; elem; elem = elem->next, idx++)
	{
	  GtkStockItem item;
	  GtkWidget *listitem, *hbox, *image, *label;
	  GtkIconSet *icon_set;
	  GtkIconSize *sizes;
	  gint n_sizes, i;
	  gboolean has_menu_size;

	  stock_id = elem->data;

#if 0
	  g_print ("Stock ID: %s\n", stock_id);
#endif

	  /* Only show GTK+ stock items. */
	  if (strncmp (stock_id, "gtk-", 4) != 0)
	    continue;

	  /* Check that the icon has a menu size. */
	  has_menu_size = FALSE;
	  icon_set = gtk_icon_factory_lookup_default (stock_id);
	  if (icon_set)
	    {
	      gtk_icon_set_get_sizes (icon_set, &sizes, &n_sizes);
	      for (i = 0; i < n_sizes; i++)
		{
		  if (sizes[i] == GTK_ICON_SIZE_MENU)
		    has_menu_size = TRUE;
		}
	      g_free (sizes);
	    }

	  if (!has_menu_size)
	    {
#if 0
	      g_print ("Skipping: %s\n", stock_id);
#endif
	      continue;
	    }

	  if (gtk_stock_lookup (stock_id, &item))
	    {
	      listitem = gtk_list_item_new ();
	      gtk_object_set_data (GTK_OBJECT (listitem),
				   GladeMenuEditorIndexKey,
				   GINT_TO_POINTER (idx));
	      gtk_widget_show (listitem);
	      hbox = gtk_hbox_new (FALSE, 3);
	      gtk_container_add (GTK_CONTAINER (listitem), hbox);
	      gtk_widget_show (hbox);

	      image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);

	      if (image)
		{
		  gtk_widget_show (image);
		  gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
		}

	      label = gtk_type_new (GTK_TYPE_ACCEL_LABEL);
	      gtk_label_set_text_with_mnemonic (GTK_LABEL (label), item.label);
	      gtk_widget_show (label);
	      gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

	      gtk_combo_set_item_string (GTK_COMBO (menued->stock_combo),
					 GTK_ITEM (listitem), stock_id);

	      gtk_container_add (GTK_CONTAINER (GTK_COMBO (menued->stock_combo)->list), listitem);
	    }
	  else
	    {
#if 0
	      g_print ("Lookup failed for stock_id: %s (probably a stock image only\n", stock_id);
#endif
	    }
	}
      gtk_signal_connect (GTK_OBJECT (GTK_COMBO (menued->stock_combo)->entry),
			  "changed",
			  GTK_SIGNAL_FUNC (on_stock_item_entry_changed),
			  NULL);
      row++;
    }

#ifdef USE_GNOME
  if (menued->gnome_support)
    {
      /* Gnome stock item. */
      eventbox1 = gtk_event_box_new ();
      gtk_widget_show (eventbox1);
      gtk_table_attach (GTK_TABLE (table1), eventbox1, 0, 1, row, row + 1,
			GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
      gtk_tooltips_set_tip (tooltips, eventbox1,
			    _ ("The stock Gnome item to use."), NULL);

      menued->stock_label = gtk_label_new (_ ("Stock Item:"));
      gtk_widget_show (menued->stock_label);
      gtk_container_add (GTK_CONTAINER (eventbox1), menued->stock_label);
      gtk_misc_set_alignment (GTK_MISC (menued->stock_label), 0, 0.5);

      menued->stock_combo = gtk_combo_new ();
      gb_widget_set_usize (menued->stock_combo, 100, -1);
      gtk_table_attach (GTK_TABLE (table1), menued->stock_combo, 1, 3,
			row, row + 1, GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
      gtk_combo_set_value_in_list (GTK_COMBO (menued->stock_combo),
				   FALSE, FALSE);
      gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (menued->stock_combo)->entry),
			      FALSE);
      gtk_widget_show (menued->stock_combo);

      for (uiinfo = GladeStockMenuItemValues;
	   uiinfo->type != GNOME_APP_UI_ENDOFINFO;
	   uiinfo++)
	{
	  pixmap = NULL;
	  label = NULL;
	  label_text = NULL;

	  if (uiinfo->type == GNOME_APP_UI_ITEM_CONFIGURABLE)
	    gnome_app_ui_configure_configurable (uiinfo);

	  uiinfo->widget = NULL;

	  switch (uiinfo->type) {
	  case GNOME_APP_UI_SEPARATOR:
	    uiinfo->widget = gtk_list_item_new ();
	    gtk_widget_show (uiinfo->widget);
	    separator = gtk_hseparator_new();
	    gtk_widget_show (separator);
	    gtk_container_add (GTK_CONTAINER (uiinfo->widget), separator);
	    gtk_widget_set_sensitive (uiinfo->widget, FALSE);
	    gtk_combo_set_item_string (GTK_COMBO (menued->stock_combo),
				       GTK_ITEM (uiinfo->widget), "");
	    gtk_container_add (GTK_CONTAINER (GTK_COMBO (menued->stock_combo)->list), uiinfo->widget);
	    break;
	  case GNOME_APP_UI_ITEM:
	  case GNOME_APP_UI_SUBTREE_STOCK:
	    if (uiinfo->pixmap_type == GNOME_APP_PIXMAP_STOCK)
	      pixmap = gtk_image_new_from_stock (uiinfo->pixmap_info, GTK_ICON_SIZE_MENU);

	    if (uiinfo->label && uiinfo->label[0])
	      {
		uiinfo->widget = gtk_list_item_new ();
		gtk_widget_show (uiinfo->widget);
		hbox = gtk_hbox_new (FALSE, 3);
		gtk_container_add (GTK_CONTAINER (uiinfo->widget), hbox);
		gtk_widget_show (hbox);

		if (!pixmap && uiinfo->type != GNOME_APP_UI_SUBTREE_STOCK)
		  {
		    /* Create a dummy widget to fill in the space. */
		    pixmap = gtk_alignment_new (0, 0, 0, 0);
		    gtk_widget_set_size_request (pixmap, 16, -1);
		  }

		if (pixmap)
		  {
		    gtk_widget_show (pixmap);
		    gtk_box_pack_start (GTK_BOX (hbox), pixmap,
					FALSE, FALSE, 0);
		  }

		label = gtk_accel_label_new ("");
		/* Most of the label text is from Gnome, but 2 of them are
		   ours, so we use a utility function to find the translation.
		*/
		label_text = glade_gnome_gettext (uiinfo->label);
		gtk_label_set_text_with_mnemonic (GTK_LABEL (label),
						  label_text);
		gtk_widget_show (label);
		gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

		gtk_combo_set_item_string (GTK_COMBO (menued->stock_combo),
					   GTK_ITEM (uiinfo->widget),
					   label_text);

		gtk_container_add (GTK_CONTAINER (GTK_COMBO (menued->stock_combo)->list), uiinfo->widget);
	      }
	    break;

	  default:
	    g_warning ("Invalid UIINFO item type");
	  }
	}
      gtk_signal_connect (GTK_OBJECT (GTK_COMBO (menued->stock_combo)->entry),
			  "changed",
			  GTK_SIGNAL_FUNC (on_stock_item_entry_changed),
			  NULL);

      row++;
    }
#endif /* USE_GNOME */

  /* Item Label. */
  eventbox1 = gtk_event_box_new ();
  gtk_widget_show (eventbox1);
  gtk_table_attach (GTK_TABLE (table1), eventbox1, 0, 1, row, row + 1,
		    GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_tooltips_set_tip (tooltips, eventbox1, _ ("The text of the menu item, or empty for separators."), NULL);

  menued->label_label = gtk_label_new (_ ("Label:"));
  gtk_widget_show (menued->label_label);
  gtk_container_add (GTK_CONTAINER (eventbox1), menued->label_label);
  gtk_misc_set_alignment (GTK_MISC (menued->label_label), 0, 0.5);

  menued->label_entry = gtk_entry_new ();
  gtk_widget_show (menued->label_entry);
  gtk_table_attach (GTK_TABLE (table1), menued->label_entry, 1, 3,
		    row, row + 1,
		    GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_signal_connect (GTK_OBJECT (menued->label_entry), "changed",
		      GTK_SIGNAL_FUNC (on_entry_changed), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->label_entry), "key_press_event",
		      GTK_SIGNAL_FUNC (on_label_entry_key_press),
		      NULL);
  row++;

  /* Item Name. */
  eventbox2 = gtk_event_box_new ();
  gtk_widget_show (eventbox2);
  gtk_table_attach (GTK_TABLE (table1), eventbox2, 0, 1, row, row + 1,
		    GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_tooltips_set_tip (tooltips, eventbox2, _ ("The name of the widget"),
			NULL);

  menued->name_label = gtk_label_new (_ ("Name:"));
  gtk_widget_show (menued->name_label);
  gtk_container_add (GTK_CONTAINER (eventbox2), menued->name_label);
  gtk_misc_set_alignment (GTK_MISC (menued->name_label), 0, 0.5);

  menued->name_entry = gtk_entry_new ();
  gtk_widget_show (menued->name_entry);
  gtk_table_attach (GTK_TABLE (table1), menued->name_entry, 1, 3, row, row + 1,
		    GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_signal_connect (GTK_OBJECT (menued->name_entry), "changed",
		      GTK_SIGNAL_FUNC (on_entry_changed), NULL);
  row++;

  /* Item Handler. */
  eventbox3 = gtk_event_box_new ();
  gtk_widget_show (eventbox3);
  gtk_table_attach (GTK_TABLE (table1), eventbox3, 0, 1, row, row + 1,
		    GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_tooltips_set_tip (tooltips, eventbox3, _ ("The function to be called when the item is selected"), NULL);

  menued->handler_label = gtk_label_new (_ ("Handler:"));
  gtk_widget_show (menued->handler_label);
  gtk_container_add (GTK_CONTAINER (eventbox3), menued->handler_label);
  gtk_misc_set_alignment (GTK_MISC (menued->handler_label), 0, 0.5);

  menued->handler_entry = gtk_entry_new ();
  gtk_widget_show (menued->handler_entry);
  gtk_table_attach (GTK_TABLE (table1), menued->handler_entry, 1, 3,
		    row, row + 1,
		    GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_signal_connect (GTK_OBJECT (menued->handler_entry), "changed",
		      GTK_SIGNAL_FUNC (on_entry_changed), NULL);
  row++;

  /* Item Icon. */
  eventbox1 = gtk_event_box_new ();
  gtk_widget_show (eventbox1);
  gtk_table_attach (GTK_TABLE (table1), eventbox1, 0, 1, row, row + 1,
		    GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_tooltips_set_tip (tooltips, eventbox1, _ ("An optional icon to show on the left of the menu item."), NULL);

  menued->icon_label = gtk_label_new (_ ("Icon:"));
  gtk_widget_show (menued->icon_label);
  gtk_container_add (GTK_CONTAINER (eventbox1), menued->icon_label);
  gtk_misc_set_alignment (GTK_MISC (menued->icon_label), 0, 0.5);

  icon_hbox = gtk_hbox_new (FALSE, 2);
  gtk_table_attach (GTK_TABLE (table1), icon_hbox, 1, 3, row, row + 1,
		    GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
  gtk_widget_show (icon_hbox);

  menued->icon_widget = gtk_combo_new ();
  gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (menued->icon_widget)->entry),
			     FALSE);
  gb_widget_set_usize (menued->icon_widget, 100, -1);

  /* Add a "None" item first, so it is easy to reset the pixmap. */
  listitem = gtk_list_item_new_with_label (_("None"));
  gtk_widget_show (listitem);
  gtk_container_add (GTK_CONTAINER (GTK_COMBO (menued->icon_widget)->list),
		     listitem);

  for (elem = menued->stock_items; elem; elem = elem->next)
    {
      GtkStockItem item;
      GtkWidget *listitem, *hbox, *image, *label;
      GtkIconSet *icon_set;
      GtkIconSize *sizes;
      gint n_sizes, i;
      gboolean has_menu_size;

      stock_id = elem->data;

#if 0
      g_print ("Stock ID: %s\n", stock_id);
#endif

      /* Show only GTK+ stock items in GTK+ projects. */
      if (!menued->gnome_support && (strncmp (stock_id, "gtk-", 4) != 0))
	continue;
#if 0
      /* Only show GnomeDB stock items if GnomeDB support is on. */
      if (!menued->gnome_db_support && !strncmp (stock_id, "gnome-db-", 9))
	continue;
#endif

      /* Check that the icon has a menu size. */
      has_menu_size = FALSE;
      icon_set = gtk_icon_factory_lookup_default (stock_id);
      if (icon_set)
	{
	  gtk_icon_set_get_sizes (icon_set, &sizes, &n_sizes);
	  for (i = 0; i < n_sizes; i++)
	    {
	      if (sizes[i] == GTK_ICON_SIZE_MENU)
		has_menu_size = TRUE;
	    }
	  g_free (sizes);
	}

      if (!has_menu_size)
	{
#if 0
	  g_print ("Skipping: %s\n", stock_id);
#endif
	  continue;
	}

      image = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
      if (image)
	{
	  listitem = gtk_list_item_new ();
	  /* We store a pointer to the stock_id from the stock_items list,
	     so we don't need to free it, but if stock_items is destroyed it
	     will no longer be valid. */
	  gtk_object_set_data (GTK_OBJECT (listitem),
			       GladeMenuEditorStockIDKey, stock_id);
	  gtk_widget_show (listitem);
	  hbox = gtk_hbox_new (FALSE, 3);
	  gtk_container_add (GTK_CONTAINER (listitem), hbox);
	  gtk_widget_show (hbox);
	  gtk_widget_show (image);
	  gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);

	  if (gtk_stock_lookup (stock_id, &item))
	    label_text = item.label;
	  else
	    /* FIXME: We have no name to use for the image. */
	    label_text = stock_id;

	  label = gtk_type_new (GTK_TYPE_ACCEL_LABEL);
	  gtk_label_set_text_with_mnemonic (GTK_LABEL (label), label_text);

	  gtk_widget_show (label);
	  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
	  gtk_combo_set_item_string (GTK_COMBO (menued->icon_widget),
				     GTK_ITEM (listitem), stock_id);
	  gtk_container_add (GTK_CONTAINER (GTK_COMBO (menued->icon_widget)->list),
			     listitem);
	}
    }

  gtk_signal_connect (GTK_OBJECT (GTK_COMBO (menued->icon_widget)->entry),
		      "changed", GTK_SIGNAL_FUNC (on_entry_changed), NULL);

  gtk_widget_show (menued->icon_widget);
  gtk_box_pack_start (GTK_BOX (icon_hbox), menued->icon_widget,
		      TRUE, TRUE, 0);

  menued->icon_button = gtk_button_new_with_label ("...");
  gtk_widget_show (menued->icon_button);
  gtk_box_pack_start (GTK_BOX (icon_hbox), menued->icon_button,
		      FALSE, FALSE, 0);
  gtk_signal_connect (GTK_OBJECT (menued->icon_button), "clicked",
		      GTK_SIGNAL_FUNC (on_icon_button_clicked), NULL);
  row++;

  /* Tooltip. */
  eventbox3 = gtk_event_box_new ();
  gtk_widget_show (eventbox3);
  gtk_table_attach (GTK_TABLE (table1), eventbox3, 0, 1, row, row + 1,
		    GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_tooltips_set_tip (tooltips, eventbox3, _ ("The tip to show when the mouse is over the item"), NULL);

  menued->tooltip_label = gtk_label_new (_ ("Tooltip:"));
  gtk_widget_show (menued->tooltip_label);
  gtk_container_add (GTK_CONTAINER (eventbox3), menued->tooltip_label);
  gtk_misc_set_alignment (GTK_MISC (menued->tooltip_label), 0, 0.5);

  menued->tooltip_entry = gtk_entry_new ();
  gtk_widget_show (menued->tooltip_entry);
  gtk_table_attach (GTK_TABLE (table1), menued->tooltip_entry, 1, 3,
		    row, row + 1,
		    GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_signal_connect (GTK_OBJECT (menued->tooltip_entry), "changed",
		      GTK_SIGNAL_FUNC (on_entry_changed), NULL);
  row++;

  /* Buttons to add/delete items. */
  button_table = gtk_table_new (2, 2, TRUE);
  gtk_table_set_row_spacings (GTK_TABLE (button_table), 1);
  gtk_table_set_col_spacings (GTK_TABLE (button_table), 2);
  gtk_widget_show (button_table);
  gtk_box_pack_start (GTK_BOX (vbox3), button_table, FALSE, TRUE, 0);

  menued->add_button = gtk_button_new_with_mnemonic (_("_Add"));
  gtk_widget_show (menued->add_button);
  gtk_table_attach (GTK_TABLE (button_table), menued->add_button,
		    0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
  gtk_tooltips_set_tip (tooltips, menued->add_button,
			_ ("Add a new item below the selected item."), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->add_button), "clicked",
		      GTK_SIGNAL_FUNC (on_add_button_clicked),
		      NULL);

  menued->add_child_button = gtk_button_new_with_mnemonic (_("Add _Child"));
  gtk_widget_show (menued->add_child_button);
  gtk_table_attach (GTK_TABLE (button_table), menued->add_child_button,
		    1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
  gtk_tooltips_set_tip (tooltips, menued->add_child_button,
			_ ("Add a new child item below the selected item."),
			NULL);
  gtk_signal_connect (GTK_OBJECT (menued->add_child_button), "clicked",
		      GTK_SIGNAL_FUNC (on_add_child_button_clicked),
		      NULL);

  menued->add_separator_button = gtk_button_new_with_mnemonic (_("Add _Separator"));
  gtk_widget_show (menued->add_separator_button);
  gtk_table_attach (GTK_TABLE (button_table), menued->add_separator_button,
		    0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
  gtk_tooltips_set_tip (tooltips, menued->add_separator_button,
			_ ("Add a separator below the selected item."), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->add_separator_button), "clicked",
		      GTK_SIGNAL_FUNC (on_add_separator_button_clicked),
		      NULL);

  menued->delete_button = gtk_button_new_with_mnemonic (_("_Delete"));
  gtk_widget_show (menued->delete_button);
  gtk_table_attach (GTK_TABLE (button_table), menued->delete_button,
		    1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
  gtk_tooltips_set_tip (tooltips, menued->delete_button,
			_ ("Delete the current item"), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->delete_button), "clicked",
		      GTK_SIGNAL_FUNC (on_delete_button_clicked),
		      NULL);

  /* Type radio options and toggle options. */
  menued->type_frame = gtk_frame_new (_ ("Item Type:"));
  gtk_widget_show (menued->type_frame);
  gtk_box_pack_start (GTK_BOX (vbox3), menued->type_frame, FALSE, TRUE, 0);

  table2 = gtk_table_new (3, 3, FALSE);
  gtk_table_set_col_spacings (GTK_TABLE (table2), 4);
  gtk_table_set_row_spacings (GTK_TABLE (table2), 1);
  gtk_widget_show (table2);
  gtk_container_add (GTK_CONTAINER (menued->type_frame), table2);
  gtk_container_set_border_width (GTK_CONTAINER (table2), 4);

  eventbox1 = gtk_event_box_new ();
  gtk_widget_show (eventbox1);
  gtk_table_attach (GTK_TABLE (table2), eventbox1, 1, 2, 1, 2,
		    GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_tooltips_set_tip (tooltips, eventbox1,
			_ ("If the item is initially on."), NULL);

  menued->state_label = gtk_label_new (_("Active:"));
  gtk_misc_set_alignment (GTK_MISC (menued->state_label), 0, 0.5);
  gtk_widget_show (menued->state_label);
  gtk_container_add (GTK_CONTAINER (eventbox1), menued->state_label);

  menued->state_togglebutton = gtk_toggle_button_new_with_label (_("No"));
  gtk_widget_show (menued->state_togglebutton);
  gtk_table_attach (GTK_TABLE (table2), menued->state_togglebutton, 2, 3, 1, 2,
		    GTK_EXPAND | GTK_FILL, 0, 0, 0);

  hbox2 = gtk_hbox_new (FALSE, 4);
  gtk_widget_show (hbox2);
  gtk_table_attach (GTK_TABLE (table2), hbox2, 1, 3, 2, 3,
		    GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

  eventbox1 = gtk_event_box_new ();
  gtk_widget_show (eventbox1);
  gtk_box_pack_start (GTK_BOX (hbox2), eventbox1, FALSE, TRUE, 0);
  gtk_tooltips_set_tip (tooltips, eventbox1,
			_ ("The radio menu item's group"), NULL);

  menued->group_label = gtk_label_new (_ ("Group:"));
  gtk_misc_set_alignment (GTK_MISC (menued->group_label), 0, 0.5);
  gtk_widget_show (menued->group_label);
  gtk_container_add (GTK_CONTAINER (eventbox1), menued->group_label);

  menued->group_combo = gtk_combo_new ();
  gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (menued->group_combo)->entry),
			     FALSE);
  gtk_widget_set_usize (GTK_COMBO (menued->group_combo)->entry, 60, -1);
  gtk_widget_show (menued->group_combo);
  gtk_box_pack_start (GTK_BOX (hbox2), menued->group_combo, TRUE, TRUE, 0);
  gtk_signal_connect (GTK_OBJECT (GTK_COMBO (menued->group_combo)->entry),
		      "changed", GTK_SIGNAL_FUNC (on_entry_changed), NULL);

  menued->radio_radiobutton = gtk_radio_button_new_with_label (table2_group,
							       _ ("Radio"));
  table2_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (menued->radio_radiobutton));
  gtk_widget_show (menued->radio_radiobutton);
  gtk_table_attach (GTK_TABLE (table2), menued->radio_radiobutton, 0, 1, 2, 3,
		    GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

  menued->check_radiobutton = gtk_radio_button_new_with_label (table2_group,
							       _ ("Check"));
  table2_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (menued->check_radiobutton));
  gtk_widget_show (menued->check_radiobutton);
  gtk_table_attach (GTK_TABLE (table2), menued->check_radiobutton, 0, 1, 1, 2,
		    GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

  menued->normal_radiobutton = gtk_radio_button_new_with_label (table2_group,
							      _ ("Normal"));
  table2_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (menued->normal_radiobutton));
  gtk_widget_show (menued->normal_radiobutton);
  gtk_table_attach (GTK_TABLE (table2), menued->normal_radiobutton, 0, 1, 0, 1,
		    GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->normal_radiobutton), TRUE);


  /* Accelerator key options. */
  menued->accel_frame = gtk_frame_new (_ ("Accelerator:"));
  gtk_widget_show (menued->accel_frame);
  gtk_box_pack_start (GTK_BOX (vbox3), menued->accel_frame, FALSE, TRUE, 0);

  table3 = gtk_table_new (2, 2, FALSE);
  gtk_widget_show (table3);
  gtk_container_add (GTK_CONTAINER (menued->accel_frame), table3);
  gtk_container_set_border_width (GTK_CONTAINER (table3), 4);
  gtk_table_set_row_spacings (GTK_TABLE (table3), 2);
  gtk_table_set_col_spacings (GTK_TABLE (table3), 4);

  hbox2 = gtk_hbox_new (FALSE, 2);
  gtk_widget_show (hbox2);
  gtk_table_attach (GTK_TABLE (table3), hbox2, 1, 2, 1, 2,
		    GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

  menued->accel_key_entry = gtk_entry_new ();
  gtk_widget_set_usize (menued->accel_key_entry, 100, -1);
  gtk_widget_show (menued->accel_key_entry);
  gtk_box_pack_start (GTK_BOX (hbox2), menued->accel_key_entry,
		      TRUE, TRUE, 0);
  gtk_signal_connect (GTK_OBJECT (menued->accel_key_entry), "changed",
		      GTK_SIGNAL_FUNC (on_entry_changed), NULL);

  accel_key_button = gtk_button_new_with_label ("...");
  gtk_widget_show (accel_key_button);
  gtk_box_pack_start (GTK_BOX (hbox2), accel_key_button,
		      FALSE, TRUE, 0);
  gtk_signal_connect (GTK_OBJECT (accel_key_button), "clicked",
		      GTK_SIGNAL_FUNC (on_accel_key_button_clicked),
		      NULL);

  hbox2 = gtk_hbox_new (TRUE, 0);
  gtk_widget_show (hbox2);
  gtk_table_attach (GTK_TABLE (table3), hbox2, 1, 2, 0, 1,
		    GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

  menued->accel_ctrl_checkbutton = gtk_check_button_new_with_label (_ ("Ctrl"));
  gtk_widget_show (menued->accel_ctrl_checkbutton);
  gtk_box_pack_start (GTK_BOX (hbox2), menued->accel_ctrl_checkbutton,
		      TRUE, TRUE, 0);

  menued->accel_shift_checkbutton = gtk_check_button_new_with_label (_ ("Shift"));
  gtk_widget_show (menued->accel_shift_checkbutton);
  gtk_box_pack_start (GTK_BOX (hbox2), menued->accel_shift_checkbutton,
		      TRUE, TRUE, 0);

  menued->accel_alt_checkbutton = gtk_check_button_new_with_label (_ ("Alt"));
  gtk_widget_show (menued->accel_alt_checkbutton);
  gtk_box_pack_start (GTK_BOX (hbox2), menued->accel_alt_checkbutton,
		      TRUE, TRUE, 0);

  label9 = gtk_label_new (_ ("Key:"));
  gtk_widget_show (label9);
  gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 1, 2,
		    GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5);

  label8 = gtk_label_new (_ ("Modifiers:"));
  gtk_widget_show (label8);
  gtk_table_attach (GTK_TABLE (table3), label8, 0, 1, 0, 1,
		    GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5);


  hseparator1 = gtk_hseparator_new ();
  gtk_widget_show (hseparator1);
  gtk_box_pack_start (GTK_BOX (vbox2), hseparator1, FALSE, TRUE, 8);


  /* OK, Apply & Cancel buttons. */
  hbuttonbox1 = gtk_hbutton_box_new ();
  gtk_widget_show (hbuttonbox1);
  gtk_box_pack_start (GTK_BOX (vbox2), hbuttonbox1, FALSE, TRUE, 0);
  gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_END);
  gtk_box_set_spacing (GTK_BOX (hbuttonbox1), 8);

  menued->cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
  gtk_widget_show (menued->cancel_button);
  gtk_container_add (GTK_CONTAINER (hbuttonbox1), menued->cancel_button);
  GTK_WIDGET_SET_FLAGS (menued->cancel_button, GTK_CAN_DEFAULT);

  menued->apply_button = gtk_button_new_from_stock (GTK_STOCK_APPLY);
  gtk_widget_show (menued->apply_button);
  gtk_container_add (GTK_CONTAINER (hbuttonbox1), menued->apply_button);
  GTK_WIDGET_SET_FLAGS (menued->apply_button, GTK_CAN_DEFAULT);

  menued->ok_button = gtk_button_new_from_stock (GTK_STOCK_OK);
  gtk_widget_show (menued->ok_button);
  gtk_container_add (GTK_CONTAINER (hbuttonbox1), menued->ok_button);
  GTK_WIDGET_SET_FLAGS (menued->ok_button, GTK_CAN_DEFAULT);
  gtk_widget_grab_default (menued->ok_button);


  /* Now set up all the signal handlers. */
  gtk_signal_connect_after (GTK_OBJECT (menued->normal_radiobutton), "toggled",
			    GTK_SIGNAL_FUNC (on_radiobutton_toggled), NULL);
  gtk_signal_connect_after (GTK_OBJECT (menued->check_radiobutton), "toggled",
			    GTK_SIGNAL_FUNC (on_radiobutton_toggled), NULL);
  gtk_signal_connect_after (GTK_OBJECT (menued->radio_radiobutton), "toggled",
			    GTK_SIGNAL_FUNC (on_radiobutton_toggled), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->state_togglebutton), "toggled",
		      GTK_SIGNAL_FUNC (on_state_button_toggled), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->accel_ctrl_checkbutton), "toggled",
		      GTK_SIGNAL_FUNC (on_checkbutton_toggled), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->accel_shift_checkbutton), "toggled",
		      GTK_SIGNAL_FUNC (on_checkbutton_toggled), NULL);
  gtk_signal_connect (GTK_OBJECT (menued->accel_alt_checkbutton), "toggled",
		      GTK_SIGNAL_FUNC (on_checkbutton_toggled), NULL);

  gtk_signal_connect (GTK_OBJECT (menued->ok_button), "clicked",
		      GTK_SIGNAL_FUNC (on_menu_editor_ok), menued);
  gtk_signal_connect (GTK_OBJECT (menued->apply_button), "clicked",
		      GTK_SIGNAL_FUNC (on_menu_editor_apply), menued);
  gtk_signal_connect (GTK_OBJECT (menued->cancel_button), "clicked",
		      GTK_SIGNAL_FUNC (on_menu_editor_close), menued);

  set_interface_state (menued);
}


GtkWidget*
glade_menu_editor_new         (GladeProject    *project,
			       GtkMenuShell    *menu)
{
  GladeMenuEditor *menued;

  menued = gtk_type_new (glade_menu_editor_get_type ());
  glade_menu_editor_construct (menued, project);
  glade_menu_editor_set_menu (menued, menu);

  return GTK_WIDGET (menued);
}

static void
glade_menu_editor_destroy (GtkObject *object)
{
  GladeMenuEditor *menued;
  GSList *elem;

  g_return_if_fail (object != NULL);
  g_return_if_fail (GLADE_IS_MENU_EDITOR (object));

  menued = GLADE_MENU_EDITOR (object);

  /* Free all the GbMenuItemData elements & disconnect our destroy handler
     on the menu widget. */
  glade_menu_editor_reset (menued);

  if (menued->keys_dialog)
    {
      gtk_widget_destroy (menued->keys_dialog);
      menued->keys_dialog = NULL;
    }

  if (menued->filesel)
    {
      gtk_widget_destroy (menued->filesel);
      menued->filesel = NULL;
    }

  for (elem = menued->stock_items; elem; elem = elem->next)
    g_free (elem->data);
  g_slist_free (menued->stock_items);
  menued->stock_items = NULL;
}


/**************************************************************************
 * Signal Handlers
 **************************************************************************/

static void
on_clist_select_row (GtkWidget * clist,
		     gint row,
		     gint column,
		     GdkEventButton * event,
		     gpointer user_data)
{
  GladeMenuEditor *menued;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (clist));

  show_item_properties (menued);

  if (event && !GTK_WIDGET_HAS_FOCUS (clist))
    gtk_widget_grab_focus (clist);

  set_interface_state (menued);
}

static void
on_clist_unselect_row (GtkWidget * clist,
		       gint row,
		       gint column,
		       GdkEventButton * event,
		       gpointer user_data)
{
  GladeMenuEditor *menued;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (clist));

  clear_form (menued, FALSE);

  if (event && !GTK_WIDGET_HAS_FOCUS (clist))
    gtk_widget_grab_focus (clist);

  set_interface_state (menued);
}

/* This will only call update_current_item if the text is different to the
   corresponding item field, since we don't want to propogate updates when
   we are setting the entry. */
static void
on_entry_changed (GtkWidget * entry,
		  gpointer user_data)
{
  GladeMenuEditor *menued;
  GtkCList *clist;
  GbMenuItemData *item;
  gchar *text, *item_text;
  gboolean changed = FALSE;
  gint row;

#if 0
  g_print ("In on_entry_changed\n");
#endif

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (entry));

  /* If we are setting the widget values, just return. */
#if 1
  if (menued->updating_widgets)
    return;
#endif

  clist = GTK_CLIST (menued->clist);
  row = get_selected_row (menued);
#if 0
  g_print ("Selected row: %i\n", row);
#endif
  if (row == -1)
    return;
  item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (menued->clist),
						    row);
#if 0
  g_print ("Item %p Label:%s Name:%s Handler:%s\n", item, item->label,
	   item->name, item->handler);
#endif

  text = (gchar*) gtk_entry_get_text (GTK_ENTRY (entry));

  if (entry == menued->label_entry)
    {
      item_text = item->label;
    }
  else if (entry == menued->name_entry)
    {    
      item_text = item->name;
    }
  else if (entry == menued->handler_entry)
    {
      item_text = item->handler;
    }
  else if (entry == GTK_COMBO (menued->icon_widget)->entry)
    {
      /* If the user selects the 'None' item from the combo, we reset the
	 text to "" and return. This callback will be called again. */
      if (!strcmp (text, _("None")))
	{
	  set_entry_text (GTK_ENTRY (entry), "");
	  return;
	}

      item_text = item->icon;
    }
  else if (entry == menued->tooltip_entry)
    {
      item_text = item->tooltip;
    }
  else if (entry == GTK_COMBO (menued->group_combo)->entry)
    {
      item_text = item->group ? item->group->name : item->name;
    }
  else if (entry == menued->accel_key_entry)
    {
      item_text = item->key;
    }
  else
    return;

  if (item_text == NULL)
    {
      if (strlen (text) > 0)
	changed = TRUE;
    }
  else
    {
      if (strcmp (text, item_text))
	changed = TRUE;
    }

  if (changed)
    {
      if (entry == menued->label_entry)
	{
	  if (item->generate_name)
	    {
	      glade_project_release_widget_name (menued->project, item->name);
	      g_free (item->name);
	      item->name = generate_name (menued, text);
	      set_entry_text (GTK_ENTRY (menued->name_entry),
			      item->name ? item->name : "");
	      gtk_clist_set_text (clist, row, GLD_COL_NAME,
				  item->name ? item->name : "");
	      if (item->generate_handler)
		{
		  g_free (item->handler);

		  item->handler = generate_handler (menued, row, text,
						    item->name);
		  set_entry_text (GTK_ENTRY (menued->handler_entry),
				  item->handler ? item->handler : "");
		  gtk_clist_set_text (clist, row, GLD_COL_HANDLER,
				      item->handler ? item->handler : "");
		}
	    }
	}
      else if (entry == menued->name_entry)
	{
	  item->generate_name = FALSE;
	  if (item->generate_handler)
	    {
	      g_free (item->handler);
	      item->handler = generate_handler (menued, row, item->label,
						text);
	      set_entry_text (GTK_ENTRY (menued->handler_entry),
			      item->handler ? item->handler : "");
	      gtk_clist_set_text (clist, row, GLD_COL_HANDLER,
				  item->handler ? item->handler : "");
	    }
	}
      else if (entry == menued->handler_entry)
	{
	  item->generate_handler = FALSE;
	}

      update_current_item (menued);
      set_interface_state (menued);
    }
}


/* This will only call update_current_item if the text is different to the
   corresponding item field, since we don't want to propogate updates when
   we are setting the entry. */
static void
on_stock_item_entry_changed (GtkWidget * entry,
			     gpointer user_data)
{
  GladeMenuEditor *menued;
  GtkCList *clist;
  GbMenuItemData *item;
  gint row;
  GtkListItem *listitem;
  gint stock_item_index = 0;
  const gchar *text;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (entry));

  text = gtk_entry_get_text (GTK_ENTRY (GTK_COMBO (menued->stock_combo)->entry));
  /* FIXME GTK+ 1.3.x bug workaround. It emits "changed" twice, once when the
     existing text is deleted. So we just return if the text is empty. */
  if (text[0] == '\0')
    return;

  clist = GTK_CLIST (menued->clist);
  row = get_selected_row (menued);
  if (row == -1)
    return;
  item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (menued->clist),
						    row);

  /* Find the index of the selected item. */
  listitem = glade_util_gtk_combo_find (GTK_COMBO (menued->stock_combo));
  g_return_if_fail (listitem != NULL);

  if (menued->gnome_support)
    {
#ifdef USE_GNOME
      stock_item_index = g_list_index (GTK_LIST (GTK_COMBO (menued->stock_combo)->list)->children, listitem);
#endif
    }
  else
    {
      GtkStockItem item;

      stock_item_index = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (listitem), GladeMenuEditorIndexKey));
      if (gtk_stock_lookup (text, &item))
	text = item.label;
      else
	stock_item_index = 0;
    }

  if (item->stock_item_index != stock_item_index)
    {
      item->stock_item_index = stock_item_index;

      /* If the stock item is reset to 'None', get a new item name, and reset
	 generate_name/handler to TRUE. */
      if (stock_item_index == 0)
	{
	  item->generate_name = TRUE;
	  item->generate_handler = TRUE;

	  item->label = glade_project_new_widget_name (menued->project,
						       "item");
	  item->name = g_strdup (item->label);
	  item->handler = generate_handler (menued, row, item->label,
					    item->name);
	  show_item_properties (menued);

	  gtk_clist_set_text (clist, row, GLD_COL_LABEL,
			      item->label ? item->label : GB_SEPARATOR_TEXT);
	  gtk_clist_set_text (clist, row, GLD_COL_NAME,
			      item->name ? item->name : "");
	  gtk_clist_set_text (clist, row, GLD_COL_HANDLER,
			      item->handler ? item->handler : "");
	}
      else
	{
	  /* These will trigger callbacks, and will generate the name
	     and handler if appropriate. */
	  set_entry_text (GTK_ENTRY (menued->label_entry), text);

	  /* Stock menu items are all normal items. */
	  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->normal_radiobutton), TRUE);
	  set_entry_text (GTK_ENTRY (GTK_COMBO (menued->group_combo)->entry), "");

	  /* Reset the accelerator keys, as that is handled automatically. */
	  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->accel_ctrl_checkbutton), FALSE);
	  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->accel_shift_checkbutton), FALSE);
	  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->accel_alt_checkbutton), FALSE);
	  set_entry_text (GTK_ENTRY (menued->accel_key_entry), "");
	}
    }

  set_interface_state (menued);
}


static gboolean
on_label_entry_key_press (GtkWidget * widget,
			  GdkEventKey * event,
			  gpointer user_data)
{
  GladeMenuEditor *menued;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (widget));

  /* If the Return key is pressed, we add a new item beneath the selected item.
     This makes it very easy to add several menus. If the Control key is
     pressed, we add the item as a child, otherwise we add it as a sibling. */
  if (event->keyval == GDK_Return)
    {
      if (event->state & GDK_CONTROL_MASK)
	{
	  add_item (menued, TRUE, FALSE);
	  /* Since we are added a child, we may need to set the parent's
	     handler to NULL if it has been auto-generated. */
	  check_generated_handlers (menued);
	}
      else
	{
	  add_item (menued, FALSE, FALSE);
	}
      return TRUE;
    }
  return FALSE;
}


static void
on_radiobutton_toggled (GtkWidget * togglebutton,
			gpointer user_data)
{
  GladeMenuEditor *menued;
  GbMenuItemData *item;
  GbMenuItemType type = 0;
  gboolean changed = FALSE;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (togglebutton)));
  item = get_selected_item (menued);
  if (item == NULL)
    return;

  if (togglebutton == menued->normal_radiobutton)
    type = GB_MENU_ITEM_NORMAL;
  else if (togglebutton == menued->check_radiobutton)
    type = GB_MENU_ITEM_CHECK;
  else if (togglebutton == menued->radio_radiobutton)
    type = GB_MENU_ITEM_RADIO;

  if (GTK_TOGGLE_BUTTON (togglebutton)->active)
    {
      if (type != item->type)
	changed = TRUE;
    }
  else
    {
      if (type == item->type)
	changed = TRUE;
    }

  if (changed)
    {
      update_current_item (menued);
      set_interface_state (menued);
    }
}

static void
on_checkbutton_toggled (GtkWidget * togglebutton,
			gpointer user_data)
{
  GladeMenuEditor *menued;
  GbMenuItemData *item;
  guint active;
  guint8 currently_active = 0;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (togglebutton)));
  active = GTK_TOGGLE_BUTTON (togglebutton)->active;
  item = get_selected_item (menued);
  if (item == NULL)
    return;
  if (togglebutton == menued->accel_ctrl_checkbutton)
    currently_active = item->modifiers & GDK_CONTROL_MASK;
  if (togglebutton == menued->accel_shift_checkbutton)
    currently_active = item->modifiers & GDK_SHIFT_MASK;
  if (togglebutton == menued->accel_alt_checkbutton)
    currently_active = item->modifiers & GDK_MOD1_MASK;

  if ((active && !currently_active) || (!active && currently_active))
    {
      update_current_item (menued);
      set_interface_state (menued);
    }
}

static void
on_state_button_toggled (GtkToggleButton * togglebutton,
			 gpointer user_data)
{
  GladeMenuEditor *menued;
  GbMenuItemData *item;
  GtkWidget *label;
  guint active;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (togglebutton)));
  active = GTK_TOGGLE_BUTTON (togglebutton)->active;
  label = GTK_BIN (togglebutton)->child;
  gtk_label_set_text (GTK_LABEL (label), active ? _("Yes") : _("No"));

  item = get_selected_item (menued);
  if (item == NULL)
    return;
  if ((item->active && !active) || (!item->active && active))
    update_current_item (menued);
}


/**************************************************************************
 * Accelerator Keys Dialog.
 **************************************************************************/
static void
on_accel_key_button_clicked (GtkButton * button,
			     gpointer user_data)
{
  GladeMenuEditor *menued;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (button)));

  if (menued->keys_dialog == NULL)
    {
      menued->keys_dialog = glade_keys_dialog_new ();
      gtk_window_set_position (GTK_WINDOW (menued->keys_dialog),
			       GTK_WIN_POS_MOUSE);
      gtk_window_set_transient_for (GTK_WINDOW (menued->keys_dialog),
				    GTK_WINDOW (menued));
      gtk_signal_connect (GTK_OBJECT (GLADE_KEYS_DIALOG (menued->keys_dialog)->clist),
			  "select_row",
			  GTK_SIGNAL_FUNC (on_keys_dialog_clist_select),
			  menued);
      gtk_signal_connect (GTK_OBJECT (GLADE_KEYS_DIALOG (menued->keys_dialog)),
			  "response",
			  GTK_SIGNAL_FUNC (on_keys_dialog_response),
			  menued);
    }

  gtk_widget_show (GTK_WIDGET (menued->keys_dialog));
}

static void
on_keys_dialog_clist_select (GtkWidget * widget, gint row, gint column,
			     GdkEventButton * bevent, GladeMenuEditor * menued)
{
  if (bevent && bevent->type == GDK_2BUTTON_PRESS)
    on_keys_dialog_response (widget, GTK_RESPONSE_OK, menued);
}

static void
on_keys_dialog_response (GtkWidget * widget, gint response_id,
			 GladeMenuEditor * menued)
{
  gchar *key_symbol;

  if (response_id == GTK_RESPONSE_OK)
    {
      key_symbol = glade_keys_dialog_get_key_symbol (GLADE_KEYS_DIALOG (menued->keys_dialog));
      if (key_symbol)
	{
	  set_entry_text (GTK_ENTRY (menued->accel_key_entry), key_symbol);
	}
    }

  glade_util_close_window (menued->keys_dialog);
}


/**************************************************************************
 * Arrow Button callbacks.
 **************************************************************************/

static void
on_up_button_clicked (GtkButton * button,
		      gpointer user_data)
{
  GladeMenuEditor *menued;
  GtkWidget *clist;
  GbMenuItemData *item, *prev_item;
  gint row, new_row, i, level;
  GList *items;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (button)));
  clist = menued->clist;
  row = get_selected_row (menued);
  if (row == -1 || row == 0)
    return;

  item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist), row);
  level = item->level;

  /* Find the new position of the item and its children. */
  new_row = -1;
  for (i = row - 1; i >= 0; i--)
    {
      prev_item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist),
							     i);
      if (prev_item->level == level)
	{
	  new_row = i;
	  break;
	}
      else if (prev_item->level < level)
	break;
    }

  /* Return if we can't move the item up. */
  if (new_row == -1)
    return;

  /* Remove item and children. */
  items = remove_item_and_children (clist, row);

  /* Now insert at new position. */
  insert_items (clist, items, new_row);
  ensure_visible (clist, new_row);

  g_list_free (items);

  /* Make sure all items in the group point to the first one. */
  normalize_radio_groups (menued);

  gtk_clist_select_row (GTK_CLIST (clist), new_row, 0);
  set_interface_state (menued);
}

static void
on_down_button_clicked (GtkButton * button,
			gpointer user_data)
{
  GladeMenuEditor *menued;
  GtkWidget *clist;
  GbMenuItemData *item, *next_item;
  gint row, new_row, i, level;
  gboolean found_next_item;
  GList *items;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (button)));
  clist = menued->clist;
  row = get_selected_row (menued);
  if (row == -1 || row == GTK_CLIST (clist)->rows - 1)
    return;

  item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist), row);
  level = item->level;

  /* Find the new position of the item and its children. */
  new_row = -1;
  found_next_item = FALSE;
  for (i = row + 1; i < GTK_CLIST (clist)->rows; i++)
    {
      next_item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist),
							     i);
      /* We have to skip all the children of the next item as well. */
      if (next_item->level == level)
	{
	  if (found_next_item)
	    {
	      new_row = i;
	      break;
	    }
	  else
	    found_next_item = TRUE;
	}
      else if (next_item->level < level)
	break;
    }

  /* Return if we can't move the item up. */
  if (new_row == -1)
    {
      if (found_next_item)
	new_row = i;
      else
	return;
    }

  /* Remove item and children. */
  items = remove_item_and_children (clist, row);
  /* Remember that the new_row needs to be shifted because we deleted items. */
  new_row -= g_list_length (items);

  /* Now insert at new position. */
  insert_items (clist, items, new_row);
  ensure_visible (clist, new_row);

  g_list_free (items);

  /* Make sure all items in the group point to the first one. */
  normalize_radio_groups (menued);

  gtk_clist_select_row (GTK_CLIST (clist), new_row, 0);
  set_interface_state (menued);
}

static void
on_left_button_clicked (GtkButton * button,
			gpointer user_data)
{
  GladeMenuEditor *menued;
  GtkWidget *clist;
  GbMenuItemData *item;
  gint row, i, level;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (button)));
  clist = menued->clist;
  row = get_selected_row (menued);
  if (row == -1)
    return;
  item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist), row);
  level = item->level;
  if (item->level > 0)
    item->level--;
  gtk_clist_set_shift (GTK_CLIST (clist), row, 0, 0, item->level * GB_INDENT);

  for (i = row + 1; i < GTK_CLIST (clist)->rows; i++)
    {
      item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist), i);
      if (item->level <= level)
	break;
      item->level--;
      gtk_clist_set_shift (GTK_CLIST (clist), i, 0, 0,
			   item->level * GB_INDENT);
    }
  check_generated_handlers (menued);
  set_interface_state (menued);
}

static void
on_right_button_clicked (GtkButton * button,
			 gpointer user_data)
{
  GladeMenuEditor *menued;
  GtkWidget *clist;
  GbMenuItemData *item, *prev_item;
  gint row, i, level;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (button)));
  clist = menued->clist;
  row = get_selected_row (menued);
  if (row == -1 || row == 0)
    return;
  item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist), row);
  prev_item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist),
							 row - 1);
  if (prev_item->level < item->level)
    return;

  level = item->level;
  item->level++;
  gtk_clist_set_shift (GTK_CLIST (clist), row, 0, 0, item->level * GB_INDENT);

  for (i = row + 1; i < GTK_CLIST (clist)->rows; i++)
    {
      item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist), i);
      if (item->level <= level)
	break;
      item->level++;
      gtk_clist_set_shift (GTK_CLIST (clist), i, 0, 0,
			   item->level * GB_INDENT);
    }

  check_generated_handlers (menued);
  set_interface_state (menued);
}

static void
on_add_button_clicked (GtkWidget * button,
		       gpointer user_data)
{
  GladeMenuEditor *menued;
  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (button)));
  add_item (menued, FALSE, FALSE);
}

static void
on_add_child_button_clicked (GtkWidget * button,
			     gpointer user_data)
{
  GladeMenuEditor *menued;
  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (button)));
  add_item (menued, TRUE, FALSE);
}


/**************************************************************************
 * 
 **************************************************************************/

static void
on_add_separator_button_clicked (GtkWidget * button,
				 gpointer user_data)
{
  GladeMenuEditor *menued;
  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (button)));
  add_item (menued, FALSE, TRUE);
}

static gboolean
on_key_press (GtkWidget * widget,
	      GdkEventKey * event,
	      gpointer user_data)
{
  switch (event->keyval)
    {
    case GDK_Delete:
      on_delete_button_clicked (widget, NULL);
      break;
    }

  return FALSE;
}

static void
on_delete_button_clicked (GtkWidget * widget,
			  gpointer user_data)
{
  GladeMenuEditor *menued;
  GtkWidget *clist;
  GbMenuItemData *item;
  gint row, level, i;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (widget)));
  clist = menued->clist;
  row = get_selected_row (menued);
  if (row == -1)
    return;
  item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist), row);
  level = item->level;

  gtk_clist_remove (GTK_CLIST (clist), row);

  /* Update any other items in the same radio group. */
  if (item->type == GB_MENU_ITEM_RADIO)
    remove_from_radio_group (menued, item);

  glade_menu_editor_free_item (item);

  /* Move all children up a level */
  for (i = row; i < GTK_CLIST (clist)->rows; i++)
    {
      item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist), i);
      if (item->level <= level)
	break;
      item->level--;
      gtk_clist_set_shift (GTK_CLIST (clist), i, 0, 0,
			   item->level * GB_INDENT);
    }

  gtk_clist_select_row (GTK_CLIST (clist), row, 0);
  set_interface_state (menued);
}


/**************************************************************************
 * File Selection for selecting icon xpm files.
 **************************************************************************/
#define GLADE_RESPONSE_CLEAR	1

static void
on_icon_button_clicked (GtkWidget * widget,
			gpointer user_data)
{
  GladeMenuEditor *menued;
  gchar *icon;

  menued = GLADE_MENU_EDITOR (gtk_widget_get_toplevel (GTK_WIDGET (widget)));

  if (menued->filesel == NULL)
    {
      menued->filesel = gtk_file_chooser_dialog_new (_("Select icon"),
						     GTK_WINDOW (menued),
						     GTK_FILE_CHOOSER_ACTION_OPEN,
						     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
						     GTK_STOCK_CLEAR, GLADE_RESPONSE_CLEAR,
						     GTK_STOCK_OK, GTK_RESPONSE_OK,
						     NULL);
      gtk_dialog_set_default_response (GTK_DIALOG (menued->filesel),
				       GTK_RESPONSE_OK);
 
      g_signal_connect (menued->filesel, "response",
			GTK_SIGNAL_FUNC (on_icon_filesel_response), menued);
      g_signal_connect (menued->filesel, "delete_event",
			G_CALLBACK (gtk_true), NULL);
    }

  icon = (gchar*) gtk_entry_get_text (GTK_ENTRY (GTK_COMBO (menued->icon_widget)->entry));
  if (icon && *icon)
    glade_util_set_file_selection_filename (menued->filesel, icon);
  
  gtk_window_present (GTK_WINDOW (menued->filesel));
}


static void
on_icon_filesel_response (GtkWidget * filesel,
			  gint response_id,
			  GladeMenuEditor *menued)
{
  gchar *filename;

  if (response_id == GTK_RESPONSE_OK)
    {
      filename = glade_util_get_file_selection_filename (filesel);
      set_entry_text (GTK_ENTRY (GTK_COMBO (menued->icon_widget)->entry),
		      filename);
      g_free (filename);
    }
  else if (response_id == GLADE_RESPONSE_CLEAR)
    {
      set_entry_text (GTK_ENTRY (GTK_COMBO (menued->icon_widget)->entry),
		      "");
    }

  glade_util_close_window (menued->filesel);
}


/**************************************************************************
 * Utility functions
 **************************************************************************/


/* This returns the index of the currently selected row in the clist, or -1
   if no item is currently selected. */
static gint
get_selected_row (GladeMenuEditor * menued)
{
  if (GTK_CLIST (menued->clist)->selection == NULL)
    return -1;
  return GPOINTER_TO_INT (GTK_CLIST (menued->clist)->selection->data);
}

/* This returns the currently selected item, or NULL if no item is currently
   selected. */
static GbMenuItemData*
get_selected_item (GladeMenuEditor * menued)
{
  GbMenuItemData *item;
  gint row;

  row = get_selected_row (menued);
  if (row == -1)
    return NULL;
  item = gtk_clist_get_row_data (GTK_CLIST (menued->clist), row);
  return item;
}

/* This set the sensitivity of the buttons according to the current state. */
static void
set_interface_state (GladeMenuEditor * menued)
{
  GbMenuItemData *item, *tmp_item;
  GtkCList *clist;
  gboolean up_button_sens = FALSE, down_button_sens = FALSE;
  gboolean left_button_sens = FALSE, right_button_sens = FALSE;
  gboolean add_button_sens = FALSE, delete_button_sens = FALSE;
  gboolean state_sens = FALSE, group_sens = FALSE;
  gboolean form_sens = FALSE, type_sens = FALSE, accel_sens = FALSE;
  gboolean label_sens = FALSE, icon_sens = FALSE;
  gint index;

  clist = GTK_CLIST (menued->clist);

  /* Figure out which of the arrow buttons should be sensitive. */

  /* The Add button is always sensitive, since empty labels are separators. */
  add_button_sens = TRUE;

  /* The Delete button and the entire form are sensitive if an item is
     selected in the clist. */
  index = get_selected_row (menued);
  if (index != -1)
    {
      form_sens = TRUE;
      type_sens = TRUE;
      label_sens = TRUE;
      icon_sens = TRUE;
      delete_button_sens = TRUE;

      if (index > 0)
	up_button_sens = TRUE;
      if (index < clist->rows - 1)
	down_button_sens = TRUE;

      item = (GbMenuItemData *) gtk_clist_get_row_data (clist, index);
      if (item->level > 0)
	left_button_sens = TRUE;

      /* The accelerator modifier and key are sensitive if this is not a
	 toplevel item on a menubar. */
      if (!GTK_IS_MENU_BAR (menued->menu) || item->level != 0)
	accel_sens = TRUE;

      if (index > 0)
	{
	  tmp_item = (GbMenuItemData *) gtk_clist_get_row_data (clist,
								index - 1);
	  if (tmp_item->level >= item->level)
	    right_button_sens = TRUE;
	}

      /* Figure out if the radio group widgets should be sensitive. */
      if (GTK_TOGGLE_BUTTON (menued->radio_radiobutton)->active)
	{
	  group_sens = TRUE;
	  state_sens = TRUE;
	  icon_sens = FALSE;
	}

      if (GTK_TOGGLE_BUTTON (menued->check_radiobutton)->active)
	{
	  state_sens = TRUE;
	  icon_sens = FALSE;
	}

      if (item->stock_item_index)
	{
	  /* For the 'New' menu item, a label and tooltip must be provided. */
	  if (menued->gnome_support)
	    {
#ifdef USE_GNOME
	      if (item->stock_item_index != GladeStockMenuItemNew)
		label_sens = FALSE;
#endif
	    }
	  else
	    {
	      /* We don't allow the "New" label to be changed for GTK+ stock
		 items now, to be compatable with libglade. It did make it a
		 bit too complicated anyway. */
#if 0
	      const char *stock_id = g_slist_nth_data (menued->stock_items,
						       item->stock_item_index - 1);
	      if (strcmp (stock_id, GTK_STOCK_NEW))
#endif
		label_sens = FALSE;
	    }

	  icon_sens = FALSE;
	  type_sens = FALSE;
	  accel_sens = FALSE;
	}
    }

  /* Now set the sensitivity of the widgets. */
  gtk_widget_set_sensitive (menued->stock_label, form_sens);
  gtk_widget_set_sensitive (menued->stock_combo, form_sens);

  gtk_widget_set_sensitive (menued->icon_label, icon_sens);
  gtk_widget_set_sensitive (menued->icon_widget, icon_sens);
  gtk_widget_set_sensitive (menued->icon_button, icon_sens);

  gtk_widget_set_sensitive (menued->name_label, form_sens);
  gtk_widget_set_sensitive (menued->name_entry, form_sens);
  gtk_widget_set_sensitive (menued->handler_label, form_sens);
  gtk_widget_set_sensitive (menued->handler_entry, form_sens);

  gtk_widget_set_sensitive (menued->label_label, label_sens);
  gtk_widget_set_sensitive (menued->label_entry, label_sens);
  gtk_widget_set_sensitive (menued->tooltip_label, label_sens);
  gtk_widget_set_sensitive (menued->tooltip_entry, label_sens);

  gtk_widget_set_sensitive (menued->add_button, add_button_sens);
  gtk_widget_set_sensitive (menued->add_separator_button, add_button_sens);
  gtk_widget_set_sensitive (menued->delete_button, delete_button_sens);

  gtk_widget_set_sensitive (menued->type_frame, type_sens);
  gtk_widget_set_sensitive (menued->state_label, state_sens);
  gtk_widget_set_sensitive (menued->state_togglebutton, state_sens);
  gtk_widget_set_sensitive (menued->group_label, group_sens);
  gtk_widget_set_sensitive (menued->group_combo, group_sens);

  gtk_widget_set_sensitive (menued->accel_frame, accel_sens);
}


/* This gets a string representing the accelerator key + modifiers.
   It returns a pointer to a static buffer. */
static gchar *
get_accel_string (gchar * key, guint8 modifiers)
{
  static gchar buffer[32];

  buffer[0] = '\0';
  if (modifiers & GDK_CONTROL_MASK)
    strcat (buffer, "C+");
  if (modifiers & GDK_SHIFT_MASK)
    strcat (buffer, "S+");
  if (modifiers & GDK_MOD1_MASK)
    strcat (buffer, "A+");
  if (key)
    strcat (buffer, key);
  return buffer;
}


static gchar*
get_stock_item_label (GladeMenuEditor * menued, gint stock_item_index)
{
  if (menued->gnome_support)
    {
#ifdef USE_GNOME
      /* Most of the label text is from Gnome, but 2 of them are ours,
	 so we use a utility function to find the translation. */
      return glade_gnome_gettext (GladeStockMenuItemValues[stock_item_index].label);
#else
      /* This shouldn't happen. */
      g_warning ("Trying to use GNOME stock items in GTK+ version of Glade");
      return NULL;
#endif
    }
  else
    {
      gchar *stock_id;

      if (stock_item_index <= 0)
	return _("None");

      stock_id = g_slist_nth_data (menued->stock_items, stock_item_index - 1);
      return stock_id;

#if 0
      GtkStockItem item;
      gtk_stock_lookup (stock_id, &item);
      return item.label;
#endif
    }
}


/* This shows the properties of the item currently selected in the clist. */
static void
show_item_properties (GladeMenuEditor * menued)
{
  GbMenuItemData *item;
  GtkWidget *clist;

  clist = menued->clist;
  item = get_selected_item (menued);
  if (item == NULL)
    return;

  menued->updating_widgets = TRUE;

  /* Now set them to the item's properties. */
  set_entry_text (GTK_ENTRY (GTK_COMBO (menued->stock_combo)->entry),
		  get_stock_item_label (menued, item->stock_item_index));
#if 0
  g_print ("Setting label_entry to: %s\n", item->label);
#endif
  set_entry_text (GTK_ENTRY (menued->label_entry), item->label);
#if 0
  g_print ("Setting name_entry to: %s\n", item->name);
#endif
  set_entry_text (GTK_ENTRY (menued->name_entry), item->name);
#if 0
  g_print ("Setting handler_entry to: %s\n", item->handler);
#endif
  set_entry_text (GTK_ENTRY (menued->handler_entry), item->handler);
  set_entry_text (GTK_ENTRY (GTK_COMBO (menued->icon_widget)->entry),
		  item->icon);
  set_entry_text (GTK_ENTRY (menued->tooltip_entry), item->tooltip);

  if (item->type == GB_MENU_ITEM_NORMAL)
    {
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->normal_radiobutton), TRUE);
      set_entry_text (GTK_ENTRY (GTK_COMBO (menued->group_combo)->entry), "");
    }
  else if (item->type == GB_MENU_ITEM_CHECK)
    {
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->check_radiobutton), TRUE);
      set_entry_text (GTK_ENTRY (GTK_COMBO (menued->group_combo)->entry), "");
    }
  else
    {
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->radio_radiobutton), TRUE);
      set_entry_text (GTK_ENTRY (GTK_COMBO (menued->group_combo)->entry),
		      item->group ? item->group->name : item->name);
    }

  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->state_togglebutton), item->active);

  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->accel_ctrl_checkbutton), (item->modifiers & GDK_CONTROL_MASK) ? TRUE : FALSE);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->accel_shift_checkbutton), (item->modifiers & GDK_SHIFT_MASK) ? TRUE : FALSE);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->accel_alt_checkbutton), (item->modifiers & GDK_MOD1_MASK) ? TRUE : FALSE);
  set_entry_text (GTK_ENTRY (menued->accel_key_entry),
		  item->key ? item->key : "");

  update_radio_groups (menued);

  menued->updating_widgets = FALSE;
}

/* This adds a new menuitem. If separator is FALSE, it adds a normal item
   with the label 'New Item'. If separator is TRUE it adds a separator.
   It is added to the clist beneath the currently selected item, or at the
   end of the list if no item is selected. If as_child is TRUE it adds the
   item as a child of the selected item, else it adds it as a sibling.
*/
static void
add_item (GladeMenuEditor * menued,
	  gboolean as_child,
	  gboolean separator)
{
  GbMenuItemData *item, *selected_item;
  GtkWidget *clist;
  gint row;

  item = g_new0 (GbMenuItemData, 1);
  item->stock_item_index = 0;
  if (separator)
    {
      item->label = NULL;
      item->name = glade_project_new_widget_name (menued->project,
						  _("separator"));
    }
  else
    {
      item->label = glade_project_new_widget_name (menued->project, "item");
      item->name = g_strdup (item->label);
    }
  item->handler = generate_handler (menued, -1, item->label, item->name);
  /* This is a flag to indicate that the last_mod_time should be set when
     the 'Apply' button is clicked. */
  item->last_mod_time = (time_t) -2;
  item->icon = NULL;
  item->tooltip = NULL;
  item->type = GB_MENU_ITEM_NORMAL;
  item->active = FALSE;
  item->group = NULL;
  item->modifiers = 0;
  item->key = NULL;
  item->level = 0;
  item->generate_name = TRUE;
  item->generate_handler = TRUE;

  clist = menued->clist;
  row = get_selected_row (menued);
  if (row != -1)
    {
      selected_item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist), row);
      item->level = selected_item->level + (as_child ? 1 : 0);
      insert_item (GTK_CLIST (clist), item, row + 1);
      gtk_clist_select_row (GTK_CLIST (clist), row + 1, 0);
      ensure_visible (clist, row + 1);
    }
  else
    {
      item->level = 0;
      insert_item (GTK_CLIST (clist), item, -1);
      gtk_clist_select_row (GTK_CLIST (clist), GTK_CLIST (clist)->rows - 1, 0);
      ensure_visible (clist, GTK_CLIST (clist)->rows - 1);
    }

  set_interface_state (menued);
  gtk_widget_grab_focus (menued->label_entry);
  gtk_editable_select_region (GTK_EDITABLE (menued->label_entry), 0, -1);
}

/* This adds the item to the clist at the given position. */
static void
insert_item (GtkCList * clist, GbMenuItemData * item, gint row)
{
  gchar *rowdata[GB_MENUED_NUM_COLS];

  /* Empty labels are understood to be separators. */
  if (item->label && strlen (item->label) > 0)
    rowdata[GLD_COL_LABEL] = item->label;
  else
    rowdata[GLD_COL_LABEL] = GB_SEPARATOR_TEXT;
  if (item->type == GB_MENU_ITEM_NORMAL)
    rowdata[GLD_COL_TYPE] = "";
  else if (item->type == GB_MENU_ITEM_CHECK)
    rowdata[GLD_COL_TYPE] = _("Check");
  else if (item->type == GB_MENU_ITEM_RADIO)
    rowdata[GLD_COL_TYPE] = _("Radio");
  rowdata[GLD_COL_ACCEL] = get_accel_string (item->key, item->modifiers);
  rowdata[GLD_COL_NAME] = item->name ? item->name : "";
  rowdata[GLD_COL_HANDLER] = item->handler ? item->handler : "";
  rowdata[GLD_COL_ICON] = item->icon ? item->icon : "";
  rowdata[GLD_COL_ACTIVE] = item->active ? _("Yes") : "";
  rowdata[GLD_COL_GROUP] = item->group ? item->group->name : item->name;
  if (item->type != GB_MENU_ITEM_RADIO || !rowdata[GLD_COL_GROUP])
    rowdata[GLD_COL_GROUP] = "";

  if (row >= 0)
    gtk_clist_insert (clist, row, rowdata);
  else
    row = gtk_clist_append (GTK_CLIST (clist), rowdata);

  gtk_clist_set_row_data (GTK_CLIST (clist), row, item);
  gtk_clist_set_shift (GTK_CLIST (clist), row, 0, 0, item->level * GB_INDENT);
}

/* This makes sure the given row is visible. */
static void
ensure_visible (GtkWidget *clist,
		gint row)
{
  if (gtk_clist_row_is_visible (GTK_CLIST (clist), row)
      != GTK_VISIBILITY_FULL)
    gtk_clist_moveto(GTK_CLIST(clist), row, -1, 0.5, 0);
}


static GbMenuItemData*
find_group_item (GladeMenuEditor * menued, char *group_name)
{
  gint rows, row;

  if (!group_name || !group_name[0])
    return NULL;

  rows = GTK_CLIST (menued->clist)->rows;

  for (row = 0; row < rows; row++)
    {
      GbMenuItemData *item;
      item = gtk_clist_get_row_data (GTK_CLIST (menued->clist), row);

      if (item->name && !strcmp (item->name, group_name))
	return item;
    }

  return NULL;
}


/* This updates the currently selected item in the clist, updating each field
   if it is different to the settings in the form elements. */
static void
update_current_item (GladeMenuEditor * menued)
{
  GbMenuItemData *item, *group_item;
  GtkCList *clist;
  gchar *name, *label, *handler, *tooltip, *group_name, *key;
  gchar *icon;
  GbMenuItemType type;
  gint row;
  guint8 modifiers;
  gboolean active, update_accelerator = FALSE;

  clist = GTK_CLIST (menued->clist);
  row = get_selected_row (menued);
  if (row == -1)
    return;
  item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (menued->clist),
						    row);

  name = (gchar*) gtk_entry_get_text (GTK_ENTRY (menued->name_entry));
  if (item_property_changed (name, item->name))
    {
      g_free (item->name);
      item->name = copy_item_property (name);
      gtk_clist_set_text (clist, row, GLD_COL_NAME,
			  item->name ? item->name : "");
    }

  label = (gchar*) gtk_entry_get_text (GTK_ENTRY (menued->label_entry));
  if (item_property_changed (label, item->label))
    {
      g_free (item->label);
      item->label = copy_item_property (label);
      gtk_clist_set_text (clist, row, GLD_COL_LABEL,
			  item->label ? item->label : GB_SEPARATOR_TEXT);
    }

  handler = (gchar*) gtk_entry_get_text (GTK_ENTRY (menued->handler_entry));
  if (item_property_changed (handler, item->handler))
    {
      g_free (item->handler);
      item->handler = copy_item_property (handler);
      gtk_clist_set_text (clist, row, GLD_COL_HANDLER,
			  item->handler ? item->handler : "");

      /* This is a flag to indicate that the last_mod_time should be set when
	 the 'Apply' button is clicked. */
      item->last_mod_time = (time_t) -2;
    }

  icon = (gchar*) gtk_entry_get_text (GTK_ENTRY (GTK_COMBO (menued->icon_widget)->entry));
  if (item_property_changed (icon, item->icon))
    {
      g_free (item->icon);
      item->icon = copy_item_property (icon);
      gtk_clist_set_text (clist, row, GLD_COL_ICON,
			  item->icon ? item->icon : "");
    }

  tooltip = (gchar*) gtk_entry_get_text (GTK_ENTRY (menued->tooltip_entry));
  if (item_property_changed (tooltip, item->tooltip))
    {
      g_free (item->tooltip);
      item->tooltip = copy_item_property (tooltip);
    }

  if (GTK_TOGGLE_BUTTON (menued->normal_radiobutton)->active)
    type = GB_MENU_ITEM_NORMAL;
  else if (GTK_TOGGLE_BUTTON (menued->check_radiobutton)->active)
    type = GB_MENU_ITEM_CHECK;
  else
    type = GB_MENU_ITEM_RADIO;
  if (item->type != type)
    {
      /* If the item is changing from a radio item to something else, make
	 sure other items in the same group no longer point to it. */
      if (item->type == GB_MENU_ITEM_RADIO)
	remove_from_radio_group (menued, item);

      item->type = type;
      if (type == GB_MENU_ITEM_NORMAL)
	gtk_clist_set_text (clist, row, GLD_COL_TYPE, "");
      else if (type == GB_MENU_ITEM_CHECK)
	gtk_clist_set_text (clist, row, GLD_COL_TYPE, _("Check"));
      else if (type == GB_MENU_ITEM_RADIO)
	gtk_clist_set_text (clist, row, GLD_COL_TYPE, _("Radio"));
    }

  active = GTK_TOGGLE_BUTTON (menued->state_togglebutton)->active
    ? TRUE : FALSE;
  if (active != item->active)
    {
      item->active = active;
      gtk_clist_set_text (clist, row, GLD_COL_ACTIVE, active ? _("Yes") : "");
    }

  group_name = (gchar*) gtk_entry_get_text (GTK_ENTRY (GTK_COMBO (menued->group_combo)->entry));
  group_item = find_group_item (menued, group_name);
  if (group_item != item->group)
    {
      char *group_text = group_item ? group_item->name : item->name;
      if (item->type != GB_MENU_ITEM_RADIO)
	group_text = NULL;
      item->group = group_item;
      gtk_clist_set_text (clist, row, GLD_COL_GROUP,
			  group_text ? group_text : "");
    }

  key = (gchar*) gtk_entry_get_text (GTK_ENTRY (menued->accel_key_entry));
  if (item_property_changed (key, item->key))
    {
      g_free (item->key);
      item->key = copy_item_property (key);
      update_accelerator = TRUE;
    }

  modifiers = 0;
  if (GTK_TOGGLE_BUTTON (menued->accel_ctrl_checkbutton)->active)
    modifiers |= GDK_CONTROL_MASK;
  if (GTK_TOGGLE_BUTTON (menued->accel_shift_checkbutton)->active)
    modifiers |= GDK_SHIFT_MASK;
  if (GTK_TOGGLE_BUTTON (menued->accel_alt_checkbutton)->active)
    modifiers |= GDK_MOD1_MASK;
  if (modifiers != item->modifiers)
    {
      item->modifiers = modifiers;
      update_accelerator = TRUE;
    }

  if (update_accelerator)
    gtk_clist_set_text (clist, row, GLD_COL_ACCEL,
			get_accel_string (item->key, item->modifiers));

  set_interface_state (menued);
}

/* This checks if the new value is different to the old, but an empty string
   in new is taken to be equal to NULL as well. */
static gboolean
item_property_changed (gchar *new, gchar *old)
{
  if (old == NULL)
    return (new == NULL || new[0] == '\0') ? FALSE : TRUE;
  if (new == NULL)
    return TRUE;
  if (!strcmp (old, new))
    return FALSE;
  return TRUE;
}

/* This returns a copy of the given property string, or NULL if it is an
   empty string. */
static gchar*
copy_item_property (gchar *property)
{
  if (property[0] == '\0')
    return NULL;
  return g_strdup (property);
}


/* This clears the form, ready to add a new item. If full is TRUE it resets
   the type checkbuttons, group and accelerator modifiers. When adding items
   full is set to FALSE so the user can add several items of the same type. */
static void
clear_form (GladeMenuEditor * menued,
	    gboolean full)
{
  gtk_list_select_item (GTK_LIST (GTK_COMBO (menued->stock_combo)->list), 0);
  set_entry_text (GTK_ENTRY (GTK_COMBO (menued->icon_widget)->entry), "");
  set_entry_text (GTK_ENTRY (menued->label_entry), "");
  set_entry_text (GTK_ENTRY (menued->name_entry), "");
  set_entry_text (GTK_ENTRY (menued->handler_entry), "");
  set_entry_text (GTK_ENTRY (menued->tooltip_entry), "");
  set_entry_text (GTK_ENTRY (menued->accel_key_entry), "");

  if (full)
    {
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->normal_radiobutton), TRUE);
      set_entry_text (GTK_ENTRY (GTK_COMBO (menued->group_combo)->entry),
		      "");
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->accel_ctrl_checkbutton), FALSE);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->accel_shift_checkbutton), FALSE);
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (menued->accel_alt_checkbutton), FALSE);
    }
}


/* This removes an item and its children from the clist, and returns a list
   of the removed items. */
static GList *
remove_item_and_children (GtkWidget * clist,
			  gint row)
{
  GList *items = NULL;
  GbMenuItemData *item;
  gint level;

  item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist), row);
  level = item->level;
  items = g_list_append (items, item);
  gtk_clist_remove (GTK_CLIST (clist), row);

  while (row < GTK_CLIST (clist)->rows)
    {
      item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (clist), row);
      if (item->level > level)
	{
	  items = g_list_append (items, item);
	  gtk_clist_remove (GTK_CLIST (clist), row);
	}
      else
	break;
    }
  return items;
}

/* This inserts the given list of items at the given position in the clist. */
static void
insert_items (GtkWidget * clist,
	      GList * items,
	      gint row)
{
  GbMenuItemData *item;

  while (items)
    {
      item = (GbMenuItemData *) items->data;
      insert_item (GTK_CLIST (clist), item, row++);
      items = items->next;
    }
}


/* This returns the default name of the widget, given its label. The returned
   string should be freed at some point. */
static gchar*
generate_name (GladeMenuEditor *menued,
	       gchar *label)
{
  gchar *prefix, *name, *src, *dest;

  /* For empty labels, i.e. separators, use 'separator'. */
  if (label == NULL || label[0] == '\0')
    {
      return glade_project_new_widget_name (menued->project, _("separator"));
    }

  prefix = g_malloc (strlen (label) + 1);
  /* Convert spaces to underscores, and ignore periods (e.g. in "Open...")
     and underscores (e.g. in "_Open"). */
  for (src = label, dest = prefix; *src; src++)
    {
      if (*src == ' ')
	*dest++ = '_';
      else if (*src == '.')
	continue;
      else if (*src == '_')
	continue;
      else
	*dest++ = *src;
    }
  *dest = '\0';

  if (dest >= prefix + strlen (label) + 1)
    g_warning ("Buffer overflow");

  /* Get rid of any trailing digits. */
  dest--;
  while (*dest >= '0' && *dest <= '9')
    {
      *dest = '\0';
      dest--;
    }

  name = glade_project_new_widget_name (menued->project, prefix);
  g_free (prefix);

  return name;
}

/* This returns the default 'activate' handler name, given the name of the
   item. The returned string should be freed at some point. */
static gchar*
generate_handler (GladeMenuEditor *menued, gint row, gchar *label, gchar *name)
{
  gchar *handler, *start = "on_", *end = "_activate";

  /* For empty labels, i.e. separators, and items with submenus, there is no
     handler by default. */
  if (label == NULL || label[0] == '\0' || is_parent (menued, row))
    return NULL;

  handler = g_malloc (strlen (name) + strlen (start) + strlen (end) + 1);
  strcpy (handler, start);
  strcat (handler, name);
  strcat (handler, end);

  return handler;
}


/* This makes sure the default handlers are updated as items are moved around.
 */
static void
check_generated_handlers (GladeMenuEditor *menued)
{
  GtkCList *clist;
  GbMenuItemData *item;
  gint row;
  gchar *handler;

  clist = GTK_CLIST (menued->clist);
  for (row = 0; row < clist->rows; row++)
    {
      item = (GbMenuItemData *) gtk_clist_get_row_data (clist, row);
      if (item->generate_handler)
	{
	  handler = generate_handler (menued, row, item->label, item->name);
	  if (item_property_changed (handler, item->handler))
	    {
	      g_free (item->handler);
	      item->handler = handler;
	      gtk_clist_set_text (clist, row, GLD_COL_HANDLER, handler);
	    }
	  else
	    {
	      g_free (handler);
	    }
	}
    }
}


/* This returns TRUE id the item in the given row is a parent, or FALSE
   if the row doesn't exist or isn't a parent. */
static gboolean
is_parent (GladeMenuEditor *menued,
	   gint row)
{
  GtkCList *clist;
  GbMenuItemData *item, *next_item;

  clist = GTK_CLIST (menued->clist);
  if (row < 0 || row >= clist->rows - 1)
    return FALSE;
  item = (GbMenuItemData *) gtk_clist_get_row_data (clist, row);
  next_item = (GbMenuItemData *) gtk_clist_get_row_data (clist, row + 1);
  if (next_item->level > item->level)
    return TRUE;
  return FALSE;
}


static void
on_menu_editor_ok (GtkWidget *button,
		   GladeMenuEditor *menued)
{
  glade_menu_editor_update_menu (menued);
  gtk_widget_destroy (GTK_WIDGET (menued));
}

static void
on_menu_editor_apply (GtkWidget *button,
		      GladeMenuEditor *menued)
{
  glade_menu_editor_update_menu (menued);
}


static void
on_menu_editor_close (GtkWidget *widget,
		      GladeMenuEditor *menued)
{
  gtk_widget_destroy (GTK_WIDGET (menued));
}


/**************************************************************************
 * Public functions
 **************************************************************************/

/* This checks if the given icon string is a stock icon name, and if it is
   it returns the stock ID instead. If not, it just returns the icon. */
static gchar*
get_stock_id_from_icon_name (GladeMenuEditor    *menued,
			     gchar		*icon)
{
  if (!icon || *icon == '\0')
    return NULL;

  /* We use the stock id instead of the text now, so we don't need this. */
#if 0
  GList *clist;

  clist = GTK_LIST (GTK_COMBO (menued->icon_widget)->list)->children;

  while (clist && clist->data)
    {
      gchar* ltext = glade_util_gtk_combo_func (GTK_LIST_ITEM (clist->data));
      if (!ltext)
	continue;
      if (!strcmp (ltext, icon))
	{
	  gchar *stock_id = gtk_object_get_data (GTK_OBJECT (clist->data),
						 GladeMenuEditorStockIDKey);
	  return stock_id;
	}
      clist = clist->next;
    }
#endif

  return icon;
}


/* This updates the menu, based on the settings in the menu editor.
   It removes all the current children of the menu and recreates it.
   Note that it has to reload all the xpm files for pixmaps, so its not
   very efficient, but they're small so it shouldn't be too bad. */
static void
glade_menu_editor_update_menu (GladeMenuEditor    *menued)
{
  GbMenuItemData *item;
  GtkWidget *menuitem, *label, *prev_item = NULL, *child_menu;
  GtkCList *clist;
  GtkMenuShell *current_menu;
  GList *menus;
  GHashTable *group_hash;
  gchar *child_name;
  gint i, level;
  GbWidget *gbwidget;
  GladeWidgetData *wdata;
  GtkAccelGroup *accel_group;
  GtkWidget *pixmap = NULL;
  gboolean use_pixmap_menu_item;
  gchar *stock_id, *icon_name;
#ifdef USE_GNOME
  GnomeUIInfo *uiinfo = NULL;
#endif

  /* Remove existing children of the menu. Note that this will result in the
     old widget names being released, so we need to reserve the new names,
     even if they are the same. */
  while (menued->menu->children)
    {
      menuitem = menued->menu->children->data;
      gtk_widget_destroy (menuitem);
    }

  /* FIXME: This seems to be necessary to re-initialise the menu. I don't know
     why. */
  menued->menu->menu_flag = TRUE;

  clist = GTK_CLIST (menued->clist);

  /* Now reserve all the the new widget names. */
  for (i = 0; i < clist->rows; i++)
    {
      item = (GbMenuItemData *) gtk_clist_get_row_data (clist, i);

      if (item->name && item->name[0])
	glade_project_reserve_name (menued->project, item->name);
    }

  /* Now add widgets according to the items in the menu editor clist. */
  level = 0;
  menus = g_list_append (NULL, menued->menu);
  group_hash = g_hash_table_new (NULL, NULL);

  /* Make sure all items in the group point to the first one. */
  normalize_radio_groups (menued);

  for (i = 0; i < clist->rows; i++)
    {
      item = (GbMenuItemData *) gtk_clist_get_row_data (clist, i);

      icon_name = get_stock_id_from_icon_name (menued, item->icon);
      stock_id = NULL;

      if (item->level > level)
	{
	  child_menu = gb_widget_new_full ("GtkMenu", FALSE, NULL, NULL, 0, 0,
					   NULL, GB_CREATING, NULL);
	  child_name = g_strdup_printf ("%s_menu", prev_item->name);
	  gtk_widget_set_name (child_menu, child_name);
	  g_free (child_name);
	  level = item->level;
	  /* We use the menus GList as a stack, pushing menus onto the
	     front. */
	  menus = g_list_prepend (menus, child_menu);
	  gtk_menu_item_set_submenu (GTK_MENU_ITEM (prev_item), child_menu);
	  tree_add_widget (child_menu);
	}
      while (item->level < level)
	{
	  /* This removes/pops the first menu in the list. */
	  menus = g_list_remove_link (menus, menus);
	  level--;
	}
      current_menu = GTK_MENU_SHELL (menus->data);

      pixmap = NULL;
      if (item->label && strlen (item->label) > 0)
	{
	  label = gtk_accel_label_new ("");
	  gtk_label_set_text_with_mnemonic (GTK_LABEL (label), item->label);
	  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	  gtk_widget_show (label);

	  use_pixmap_menu_item = FALSE;

	  if (menued->gnome_support)
	    {
#ifdef USE_GNOME
	      if (item->stock_item_index)
		{
		  uiinfo = &GladeStockMenuItemValues[item->stock_item_index];
		  if (uiinfo->pixmap_type == GNOME_APP_PIXMAP_STOCK)
		    {
		      pixmap = gtk_image_new_from_stock (uiinfo->pixmap_info,
							 GTK_ICON_SIZE_MENU);
		      use_pixmap_menu_item = TRUE;
		    }
		}
#endif
	    }
	  else
	    {
	      if (item->stock_item_index)
		{
		  stock_id = g_slist_nth_data (menued->stock_items,
					       item->stock_item_index - 1);
#if 0
		  g_print ("Stock ID for icon: %s\n", stock_id);
#endif
		  pixmap = gtk_image_new_from_stock (stock_id,
						     GTK_ICON_SIZE_MENU);
		  use_pixmap_menu_item = TRUE;
		}
	    }

	  if (!item->stock_item_index && icon_name)
	    {
	      pixmap = gb_widget_new ("GtkImage", NULL);
	      if (glade_util_check_is_stock_id (icon_name))
		{
		  gtk_image_set_from_stock (GTK_IMAGE (pixmap), icon_name,
					    GTK_ICON_SIZE_MENU);
		}
	      else
		{
		  gtk_image_set_from_file (GTK_IMAGE (pixmap), icon_name);

		  /* Add the pixmap to the project, so the file is copied.
		     It should be removed from the project in the menuitem
		     GbWidget.destroy function. */
		  glade_project_add_pixmap (menued->project, icon_name);
		}
	      gb_widget_set_child_name (pixmap, GladeChildMenuItemImage);
	      use_pixmap_menu_item = TRUE;
	    }

	  if (item->type == GB_MENU_ITEM_NORMAL)
	    {
	      if (use_pixmap_menu_item)
		{
		  menuitem = gtk_image_menu_item_new ();
		  if (pixmap)
		    {
		      gtk_widget_show (pixmap);
		      gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
						     pixmap);
		    }
		}
	      else
		{
		  menuitem = gtk_menu_item_new ();
		}
	      gtk_container_add (GTK_CONTAINER (menuitem), label);
	    }
	  else if (item->type == GB_MENU_ITEM_CHECK)
	    {
	      menuitem = gtk_check_menu_item_new ();
	      if (item->active)
		gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
						TRUE);
	      gtk_container_add (GTK_CONTAINER (menuitem), label);
	    }
	  else
	    {
	      menuitem = create_radio_menu_item (current_menu,
						 item, group_hash);
	      if (item->active)
		gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
						TRUE);
	      gtk_container_add (GTK_CONTAINER (menuitem), label);
	    }

	  gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), menuitem);
	}
      else
	{
	  /* This creates a separator. */
	  menuitem = gtk_separator_menu_item_new ();
	}
      gtk_widget_show (menuitem);

      /* Save the stock name and icon in the menuitem. */
      if (item->stock_item_index)
	{
	  if (menued->gnome_support)
	    {
#ifdef USE_GNOME
	      gtk_object_set_data (GTK_OBJECT (menuitem),
				   GladeMenuItemStockIndexKey,
				   GINT_TO_POINTER (item->stock_item_index));
#endif
	    }
	  else
	    {
	      gchar *stock_id;

	      stock_id = g_slist_nth_data (menued->stock_items,
					   item->stock_item_index - 1);

	      gtk_object_set_data_full (GTK_OBJECT (menuitem),
					GladeMenuItemStockIDKey,
					g_strdup (stock_id),
					g_free);
	    }
	}
      else if (item->icon && pixmap)
	{
	  gtk_object_set_data_full (GTK_OBJECT (pixmap), GladeIconKey,
				    g_strdup (icon_name), g_free);
	}


      /* Turn it into a GbWidget, and add the 'activate' handler and the
	 accelerator. */
      if (item->name == NULL || item->name[0] == '\0')
	{
	  g_free (item->name);
	  item->name = glade_project_new_widget_name (menued->project, "item");
	}

      gbwidget = gb_widget_lookup_class (gtk_type_name (GTK_OBJECT_TYPE (menuitem)));

      if (item->wdata)
	wdata = glade_widget_data_copy (item->wdata);
      else
	wdata = glade_widget_data_new (gbwidget);

      wdata->gbwidget = gbwidget;

      gb_widget_create_from_full (menuitem, NULL, wdata);
      gtk_widget_set_name (menuitem, item->name);

      if (item->active)
	wdata->flags |= GLADE_ACTIVE;
      else
	wdata->flags &= ~GLADE_ACTIVE;

      g_free (wdata->tooltip);
      wdata->tooltip = g_strdup (item->tooltip);
      /* FIXME: Should set tooltip? Or for Gnome install in appbar? */

      if (item->handler && strlen (item->handler) > 0)
	{
	  GladeSignal *signal = g_new (GladeSignal, 1);
	  signal->name = g_strdup ("activate");
	  signal->handler = g_strdup (item->handler);
	  signal->object = NULL;
	  signal->after = FALSE;
	  signal->data = NULL;

	  /* If the last mod time is set to the special value, we set it to
	     the current time now. */
	  if (item->last_mod_time == (time_t) -2) {
	    item->last_mod_time = time (NULL);
	    if (item->last_mod_time == (time_t) -1)
	      g_warning ("Can't get current time");
	  }

	  signal->last_modification_time = item->last_mod_time;
	  wdata->signals = g_list_append (wdata->signals, signal);
	}

      if (item->key && strlen (item->key) > 0)
	{
	  GladeAccelerator *accel = g_new (GladeAccelerator, 1);
	  guint key;
	  accel->modifiers = item->modifiers;
	  accel->key = g_strdup (item->key);
	  accel->signal = g_strdup ("activate");
	  wdata->accelerators = g_list_append (wdata->accelerators, accel);

	  /* We can only add accelerators to menus, not menubars. */
	  if (GTK_IS_MENU (current_menu))
	    {
	      key = glade_keys_dialog_find_key (item->key);
	      accel_group = GTK_MENU (current_menu)->accel_group;
	      gtk_widget_add_accelerator (menuitem, "activate", accel_group,
					  key, item->modifiers,
					  GTK_ACCEL_VISIBLE);
	    }
	}

      if (menued->gnome_support)
	{
#ifdef USE_GNOME
	  /* For stock menu items, we use the configured accelerator keys. */
	  if (GTK_IS_MENU (current_menu)
	      && item->stock_item_index && uiinfo->accelerator_key != 0)
	    {
	      accel_group = GTK_MENU (current_menu)->accel_group;
	      gtk_widget_add_accelerator (menuitem, "activate", accel_group,
					  uiinfo->accelerator_key,
					  uiinfo->ac_mods,
					  GTK_ACCEL_VISIBLE);
	    }
#endif
	}
      else
	{
	  /* For stock menu items, we use the configured accelerator keys. */
	  if (GTK_IS_MENU (current_menu) && item->stock_item_index && stock_id)
	    {
	      GtkStockItem item;

	      gtk_stock_lookup (stock_id, &item);
	      if (item.keyval)
		{
		  accel_group = GTK_MENU (current_menu)->accel_group;
		  gtk_widget_add_accelerator (menuitem, "activate",
					      accel_group,
					      item.keyval, item.modifier,
					      GTK_ACCEL_VISIBLE);
		}
	    }
	}

      /* Add the menuitem to the current menu. */
      gtk_menu_shell_append (current_menu, menuitem);
      tree_add_widget (menuitem);
      prev_item = menuitem;
    }
  g_list_free (menus);
  g_hash_table_destroy (group_hash);

  /* Make sure the displayed item is correct. */
  show_item_properties (menued);
}


/* This creates a radio menu item using the appropriate radio group.
   If the item's group is not NULL and doesn't points to the item itself,
   then it will search the list of groups to find the group. If it can't find
   a group, or it didn't have one it creates a new group.
   If it creates a new group it adds this item to the list of groups. */
static GtkWidget*
create_radio_menu_item (GtkMenuShell *menu,
			GbMenuItemData *item,
			GHashTable *group_hash)
{
  GtkWidget *menuitem;
  GSList *group = NULL;

  if (item->group && item->group != item)
    {
      GtkRadioMenuItem *group_widget = g_hash_table_lookup (group_hash,
							    item->group);
      if (group_widget)
	group = gtk_radio_menu_item_get_group (group_widget);
    }

  menuitem = gtk_radio_menu_item_new (group);
  if (!group)
    g_hash_table_insert (group_hash, item, menuitem);

  return menuitem;
}


static void
glade_menu_editor_on_menu_destroyed (GtkWidget *menu,
				     GtkWidget *menued)
{
  gtk_widget_destroy (menued);
}


/* This converts the given menu/menubar into the list of items displayed in
   the menu editor. */
static void
glade_menu_editor_set_menu	 (GladeMenuEditor *menued,
				  GtkMenuShell    *menu)
{
  /* First clear any current items and radio groups. */
  glade_menu_editor_reset (menued);

  /* Connect to the destroy signal of the menu widget, so we can destroy the
     menu editor when the widget is destroyed. */
  menued->menu_destroy_handler_id = gtk_signal_connect (GTK_OBJECT (menu),
							"destroy",
							GTK_SIGNAL_FUNC (glade_menu_editor_on_menu_destroyed),
							menued);

  /* Now add each of the menus/menuitems in the given menu. */
  menued->menu = menu;

  set_submenu (menued, menu, 0);
}


/* This checks if the given icon_name is a stock ID, and if it is it returns
   the text to display instead. If not, it returns icon_name. */
static gchar*
get_icon_name_from_stock_id (GladeMenuEditor *menued,
			     gchar	     *icon_name)
{
  /* We use the stock id instead of the text now. */
#if 0
  GtkStockItem item;
  if (icon_name && gtk_stock_lookup (icon_name, &item))
    return item.label;
  else
#endif

    return icon_name;
}


/* This recursively adds menus. */
static void
set_submenu (GladeMenuEditor *menued,
	     GtkMenuShell    *menu,
	     gint	      level)
{
  GbMenuItemData *item;
  GtkWidget *menuitem, *label;
  GList *child, *tmp_list;
  GladeWidgetData *wdata;
  gchar *icon_name;
  GList *groups = NULL;

  child = menu->children;
  while (child)
    {
      menuitem = GTK_WIDGET (child->data);

      if (!GTK_IS_MENU_ITEM (menuitem))
	{
	  g_warning ("Menu widget is not a menu item");
	  child = child->next;
	  continue;
	}
      /* FIXME: We can't handle tearoff menuitems at present. */
      if (GTK_IS_TEAROFF_MENU_ITEM (menuitem))
	{
	  child = child->next;
	  continue;
	}

      wdata = (GladeWidgetData*) gtk_object_get_data (GTK_OBJECT(menuitem),
						      GB_WIDGET_DATA_KEY);
      if (wdata == NULL)
	{
	  g_warning ("Menu widget has no GladeWidgetData");
	  child = child->next;
	  continue;
	}

      item = g_new0 (GbMenuItemData, 1);

      if (menued->gnome_support)
	{
#ifdef USE_GNOME
	  item->stock_item_index = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (menuitem), GladeMenuItemStockIndexKey));
#endif
	}
      else
	{
	  gchar *stock_id;
	  GSList *elem;
	  gint idx;

	  stock_id = gtk_object_get_data (GTK_OBJECT (menuitem),
					  GladeMenuItemStockIDKey);
	  item->stock_item_index = 0;
	  if (stock_id)
	    {
	      for (elem = menued->stock_items, idx = 1; elem;
		   elem = elem->next, idx++)
		{
		  if (!strcmp (elem->data, stock_id))
		    {
		      item->stock_item_index = idx;
		      break;
		    }
		}
	    }
	}

      item->name = g_strdup (gtk_widget_get_name (menuitem));
      item->label = NULL;
      item->handler = NULL;
      item->last_mod_time = 0;
      item->icon = NULL;

      /* If it isn't a stock item, we check if it has an icon set. */
      if (item->stock_item_index == 0 && GTK_IS_IMAGE_MENU_ITEM (menuitem))
	{
	  GtkWidget *image;
	  image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (menuitem));
	  if (image)
	    {
	      icon_name = gtk_object_get_data (GTK_OBJECT (image), GladeIconKey);
	      item->icon = g_strdup (get_icon_name_from_stock_id (menued, icon_name));
	    }
	}

      item->tooltip = g_strdup (wdata->tooltip);
      item->type = GB_MENU_ITEM_NORMAL;
      item->active = FALSE;
      item->group = NULL;
      item->modifiers = 0;
      item->key = NULL;
      item->level = level;
      item->generate_name = FALSE;
      item->generate_handler = FALSE;
      item->wdata = glade_widget_data_copy (wdata);

      if (GTK_IS_RADIO_MENU_ITEM (menuitem))
	{
	  item->type = GB_MENU_ITEM_RADIO;
	  item->group = find_radio_group (GTK_RADIO_MENU_ITEM (menuitem),
					  &groups, item);
	}
      else if (GTK_IS_CHECK_MENU_ITEM (menuitem))
	item->type = GB_MENU_ITEM_CHECK;

      label = GTK_BIN (menuitem)->child;
      if (label && GTK_IS_LABEL (label))
	item->label = glade_util_get_label_text (label);

      if (GTK_IS_CHECK_MENU_ITEM (menuitem)
	  && GTK_CHECK_MENU_ITEM (menuitem)->active)
	item->active = TRUE;
	
      /* Find 'activate' handler in widget data. */
      tmp_list = item->wdata->signals;
      while (tmp_list)
	{
	  GladeSignal *signal = (GladeSignal *) tmp_list->data;
	  if (!strcmp (signal->name, "activate"))
	    {
	      item->handler = g_strdup (signal->handler);
	      item->last_mod_time = signal->last_modification_time;

	      /* Remove the signal from our copy of the GladeWidgetData. */
	      glade_widget_data_free_signal (signal);
	      item->wdata->signals = g_list_remove (item->wdata->signals,
						    signal);
	      break;
	    }
	  tmp_list = tmp_list->next;
	}

      /* Find 'activate' accelerator in widget data. */
      tmp_list = item->wdata->accelerators;
      while (tmp_list)
	{
	  GladeAccelerator *accel = (GladeAccelerator *) tmp_list->data;
	  if (!strcmp (accel->signal, "activate"))
	    {
	      item->key = g_strdup (accel->key);
	      item->modifiers = accel->modifiers;

	      /* Remove the accel from our copy of the GladeWidgetData. */
	      glade_widget_data_free_accel (accel);
	      item->wdata->accelerators = g_list_remove (item->wdata->accelerators,
							 accel);
	      break;
	    }
	  tmp_list = tmp_list->next;
	}


      insert_item (GTK_CLIST (menued->clist), item, -1);

      if (GTK_MENU_ITEM (menuitem)->submenu)
	{
	  set_submenu (menued,
		       GTK_MENU_SHELL (GTK_MENU_ITEM (menuitem)->submenu),
		       level + 1);
	}

      child = child->next;
    }

  g_list_free (groups);
}


/* This clears the clist, freeing all GbMenuItemDatas, and resets the radio
   group combo, freeing all the current radio groups. */
static void
glade_menu_editor_reset (GladeMenuEditor *menued)
{
  GbMenuItemData *item;
  gint i;

  /* Disconnect our destroy handler on the menu widget. */
  if (menued->menu)
    {
      gtk_signal_disconnect (GTK_OBJECT (menued->menu),
			     menued->menu_destroy_handler_id);
      menued->menu = NULL;
    }

  for (i = 0; i < GTK_CLIST (menued->clist)->rows; i++)
    {
      item = (GbMenuItemData *) gtk_clist_get_row_data (GTK_CLIST (menued->clist), i);
      glade_menu_editor_free_item (item);

    }
  gtk_clist_clear (GTK_CLIST (menued->clist));

  gtk_list_clear_items (GTK_LIST (GTK_COMBO (menued->group_combo)->list),
			0, -1);
}


static void
glade_menu_editor_free_item (GbMenuItemData *item)
{
  g_free (item->name);
  g_free (item->label);
  g_free (item->handler);
  g_free (item->icon);
  g_free (item->tooltip);
  g_free (item->key);

  if (item->wdata)
    glade_widget_data_free (item->wdata);

  g_free (item);
}


/* Make sure all item group fields point to the first item in the group. */
static void
normalize_radio_groups (GladeMenuEditor * menued)
{
  GbMenuItemData *item, *group;
  GList *groups = NULL;
  gint rows, row;

  /* Step through each row checking each radio item. */
  rows = GTK_CLIST (menued->clist)->rows;
  for (row = 0; row < rows; row++)
    {
      item = gtk_clist_get_row_data (GTK_CLIST (menued->clist), row);
      if (item->type != GB_MENU_ITEM_RADIO)
	continue;

      /* Follow the chain of groups until we get the real one. */
      group = item->group;
      while (group && group->group && group->group != group)
	group = group->group;

      /* If it is a new group, add it to the list. */
      if (!group || group == item)
	{
	  groups = g_list_prepend (groups, item);
	  item->group = NULL;
	}
      /* Else check if the group item is after the current one. If it is,
	 then we make the current item the group leader. We assume that if
	 we haven't seen the group item yet, it must be after this one. */
      else if (!g_list_find (groups, group))
	{
	  groups = g_list_prepend (groups, item);
	  group->group = item;
	  item->group = NULL;
	}
      else
	{
	  item->group = group;
	}
    }

  g_list_free (groups);
}


/* This recreates the list of available radio groups, and puts them in the
   combo's drop-down list. */
static void
update_radio_groups (GladeMenuEditor * menued)
{
  GbMenuItemData *item, *tmp_item;
  GList *groups = NULL, *elem;
  gint item_row, row, parent_row, rows;
  GtkCombo *combo;
  GtkList *list;
  GtkWidget *li;

  /* Make sure all item group fields point to the first item in the group. */
  normalize_radio_groups (menued);

  item_row = get_selected_row (menued);
  if (item_row == -1)
    {
      gtk_list_clear_items (GTK_LIST (GTK_COMBO (menued->group_combo)->list),
			    0, -1);
      return;
    }

  item = gtk_clist_get_row_data (GTK_CLIST (menued->clist), item_row);

  /* Step backwards to find the parent item. */
  parent_row = -1;
  for (row = item_row - 1; row > 0; row--)
    {
      tmp_item = gtk_clist_get_row_data (GTK_CLIST (menued->clist), row);
      if (tmp_item->level < item->level)
	{
	  parent_row = row;
	  break;
	}
    }

  /* Now step through the items, checking all items that are on the same
     level as the current one, until we reach the end of the list or find an
     item on a higher level. */
  rows = GTK_CLIST (menued->clist)->rows;
  for (row = parent_row + 1; row < rows; row++)
    {
      tmp_item = gtk_clist_get_row_data (GTK_CLIST (menued->clist), row);
      if (tmp_item->level < item->level)
	break;

      if (tmp_item->level == item->level
	  && tmp_item->type == GB_MENU_ITEM_RADIO
	  && tmp_item->name && tmp_item->name[0])
	{
	  /* If the item has its group set to NULL or itself, then it is a new
	     group, so add its name. */
	  if (!tmp_item->group || tmp_item->group == tmp_item)
	    groups = g_list_prepend (groups, tmp_item->name);
	}
    }

  groups = g_list_sort (groups, (GCompareFunc)strcmp);

  combo = GTK_COMBO (menued->group_combo);
  list = GTK_LIST (combo->list);

  /* We have to block the combo's list's selection changed signal, or it
     causes problems. */
  gtk_signal_handler_block (GTK_OBJECT (list),
			    GTK_COMBO (menued->group_combo)->list_change_id);

  gtk_list_clear_items (list, 0, -1);

  /* Add the special 'New' item to create a new group. */
  li = gtk_list_item_new_with_label (_("New"));
  gtk_widget_show (li);
  gtk_container_add (GTK_CONTAINER (list), li);
  gtk_combo_set_item_string (combo, GTK_ITEM (li), "");

  /* Add a separator. */
  li = gtk_list_item_new ();
  gtk_widget_show (li);
  gtk_container_add (GTK_CONTAINER (list), li);

  for (elem = groups; elem; elem = elem->next)
    {
      li = gtk_list_item_new_with_label (elem->data);
      gtk_widget_show (li);
      gtk_container_add (GTK_CONTAINER (list), li);
    }

  gtk_signal_handler_unblock (GTK_OBJECT (list),
			    GTK_COMBO (menued->group_combo)->list_change_id);
  g_list_free (groups);
}


/* This finds the group item to use for the given radiomenuitem widget.
   It searches the list of group items to find the first one that is also in
   the radiomenuitem's group list. If none is found, it creates a new group
   and adds it to the list. */
static GbMenuItemData*
find_radio_group (GtkRadioMenuItem *menuitem, GList **groups,
		  GbMenuItemData *item)
{
  GSList *item_group_list;
  GList *elem;

  item_group_list = menuitem->group;

  /* The groups list contains pairs of GSList + GbMenuItemData*. */
  for (elem = *groups; elem; elem = elem->next->next)
    {
      GSList *elem_group = elem->data;
      GbMenuItemData *elem_item = elem->next->data;

      if (elem_group == item_group_list)
	return elem_item;
    }

  /* We couldn't find an existing group that matches, so we create a new one.
   */
  *groups = g_list_prepend (*groups, item);
  *groups = g_list_prepend (*groups, item_group_list);
  return NULL;
}


/* This is called to make sure that no items have the given item as their
   group leader. It is called when an item is removed, or when its type is
   changed from a radio item to something else.

   It steps through the list, checking for radio items with
   the group field set to the given item. The first time it finds one, it
   creates a new group. It sets the group field of all other items in the
   same group to the new first item in the group. */
static void
remove_from_radio_group (GladeMenuEditor * menued,
			 GbMenuItemData *item)
{
  GbMenuItemData *new_group_item = NULL;
  gint rows, row;

  rows = GTK_CLIST (menued->clist)->rows;
  for (row = 0; row < rows; row++)
    {
      GbMenuItemData *tmp_item;
      tmp_item = gtk_clist_get_row_data (GTK_CLIST (menued->clist), row);

      if (tmp_item->type == GB_MENU_ITEM_RADIO
	  && tmp_item->group == item && tmp_item != item)
	{
	  if (new_group_item)
	    {
	      tmp_item->group = new_group_item;
	    }
	  else
	    {
	      tmp_item->group = NULL;
	      new_group_item = tmp_item;
	    }
	}
    }
}