]> Pileus Git - ~andy/gtk/blobdiff - gtk/gtkmenuitem.c
Updated Bulgarian translation by Alexander Shopov <ash@contact.bg>
[~andy/gtk] / gtk / gtkmenuitem.c
index 413d44a14bd5529c4d1888ba2a5c386aff332c3b..03855d699954ae7ab942643236ae1e0099eba5ec 100644 (file)
@@ -26,7 +26,9 @@
 
 #define GTK_MENU_INTERNALS
 
+#include <config.h>
 #include <string.h>
+
 #include "gtkaccellabel.h"
 #include "gtkmain.h"
 #include "gtkmarshalers.h"
 #include "gtkmenubar.h"
 #include "gtkmenuitem.h"
 #include "gtkseparatormenuitem.h"
-
-
-#define BORDER_SPACING  3
+#include "gtkprivate.h"
+#include "gtkintl.h"
+#include "gtkalias.h"
 
 #define MENU_ITEM_CLASS(w)  GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
 
-
 enum {
   ACTIVATE,
   ACTIVATE_ITEM,
@@ -50,8 +51,6 @@ enum {
 };
 
 
-static void gtk_menu_item_class_init     (GtkMenuItemClass *klass);
-static void gtk_menu_item_init           (GtkMenuItem      *menu_item);
 static void gtk_menu_item_destroy        (GtkObject        *object);
 static void gtk_menu_item_finalize       (GObject          *object);
 static void gtk_menu_item_size_request   (GtkWidget        *widget,
@@ -81,7 +80,6 @@ static gboolean gtk_menu_item_mnemonic_activate     (GtkWidget   *widget,
                                                     gboolean     group_cycling);
 
 static gint gtk_menu_item_select_timeout (gpointer          data);
-static void gtk_menu_item_popup_submenu  (gpointer     data);
 static void gtk_menu_item_position_menu  (GtkMenu          *menu,
                                          gint             *x,
                                          gint             *y,
@@ -93,37 +91,13 @@ static void gtk_menu_item_forall         (GtkContainer    *container,
                                          gboolean         include_internals,
                                          GtkCallback      callback,
                                          gpointer         callback_data);
+static gboolean gtk_menu_item_can_activate_accel (GtkWidget *widget,
+                                                 guint      signal_id);
 
 
-static GtkItemClass *parent_class;
 static guint menu_item_signals[LAST_SIGNAL] = { 0 };
 
-GType
-gtk_menu_item_get_type (void)
-{
-  static GType menu_item_type = 0;
-
-  if (!menu_item_type)
-    {
-      static const GTypeInfo menu_item_info =
-      {
-       sizeof (GtkMenuItemClass),
-       NULL,           /* base_init */
-       NULL,           /* base_finalize */
-       (GClassInitFunc) gtk_menu_item_class_init,
-       NULL,           /* class_finalize */
-       NULL,           /* class_data */
-       sizeof (GtkMenuItem),
-       16,             /* n_preallocs */
-       (GInstanceInitFunc) gtk_menu_item_init,
-      };
-
-      menu_item_type = g_type_register_static (GTK_TYPE_ITEM, "GtkMenuItem",
-                                              &menu_item_info, 0);
-    }
-
-  return menu_item_type;
-}
+G_DEFINE_TYPE (GtkMenuItem, gtk_menu_item, GTK_TYPE_ITEM)
 
 static void
 gtk_menu_item_class_init (GtkMenuItemClass *klass)
@@ -134,8 +108,6 @@ gtk_menu_item_class_init (GtkMenuItemClass *klass)
   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
   GtkItemClass *item_class = GTK_ITEM_CLASS (klass);
 
-  parent_class = g_type_class_peek_parent (klass);
-
   gobject_class->finalize = gtk_menu_item_finalize;
 
   object_class->destroy = gtk_menu_item_destroy;
@@ -151,6 +123,7 @@ gtk_menu_item_class_init (GtkMenuItemClass *klass)
   widget_class->hide_all = gtk_menu_item_hide_all;
   widget_class->mnemonic_activate = gtk_menu_item_mnemonic_activate;
   widget_class->parent_set = gtk_menu_item_parent_set;
+  widget_class->can_activate_accel = gtk_menu_item_can_activate_accel;
   
   container_class->forall = gtk_menu_item_forall;
 
@@ -165,7 +138,7 @@ gtk_menu_item_class_init (GtkMenuItemClass *klass)
   klass->hide_on_activate = TRUE;
 
   menu_item_signals[ACTIVATE] =
-    g_signal_new ("activate",
+    g_signal_new (I_("activate"),
                  G_OBJECT_CLASS_TYPE (gobject_class),
                  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
                  G_STRUCT_OFFSET (GtkMenuItemClass, activate),
@@ -175,7 +148,7 @@ gtk_menu_item_class_init (GtkMenuItemClass *klass)
   widget_class->activate_signal = menu_item_signals[ACTIVATE];
 
   menu_item_signals[ACTIVATE_ITEM] =
-    g_signal_new ("activate_item",
+    g_signal_new (I_("activate_item"),
                  G_OBJECT_CLASS_TYPE (gobject_class),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GtkMenuItemClass, activate_item),
@@ -184,7 +157,7 @@ gtk_menu_item_class_init (GtkMenuItemClass *klass)
                  G_TYPE_NONE, 0);
 
   menu_item_signals[TOGGLE_SIZE_REQUEST] =
-    g_signal_new ("toggle_size_request",
+    g_signal_new (I_("toggle_size_request"),
                  G_OBJECT_CLASS_TYPE (gobject_class),
                  G_SIGNAL_RUN_FIRST,
                  G_STRUCT_OFFSET (GtkMenuItemClass, toggle_size_request),
@@ -194,23 +167,50 @@ gtk_menu_item_class_init (GtkMenuItemClass *klass)
                  G_TYPE_POINTER);
 
   menu_item_signals[TOGGLE_SIZE_ALLOCATE] =
-    g_signal_new ("toggle_size_allocate",
+    g_signal_new (I_("toggle_size_allocate"),
                  G_OBJECT_CLASS_TYPE (gobject_class),
                  G_SIGNAL_RUN_FIRST,
-                 G_STRUCT_OFFSET (GtkMenuItemClass, toggle_size_allocate),
+                 G_STRUCT_OFFSET (GtkMenuItemClass, toggle_size_allocate),
                  NULL, NULL,
                  _gtk_marshal_NONE__INT,
                  G_TYPE_NONE, 1,
                  G_TYPE_INT);
 
   gtk_widget_class_install_style_property_parser (widget_class,
-                                                 g_param_spec_enum ("selected_shadow_type",
+                                                 g_param_spec_enum ("selected-shadow-type",
                                                                     "Selected Shadow Type",
                                                                     "Shadow type when item is selected",
                                                                     GTK_TYPE_SHADOW_TYPE,
                                                                     GTK_SHADOW_NONE,
-                                                                    G_PARAM_READABLE),
+                                                                    GTK_PARAM_READABLE),
                                                  gtk_rc_property_parse_enum);
+
+  gtk_widget_class_install_style_property (widget_class,
+                                          g_param_spec_int ("horizontal-padding",
+                                                            "Horizontal Padding",
+                                                            "Padding to left and right of the menu item",
+                                                            0,
+                                                            G_MAXINT,
+                                                            3,
+                                                            GTK_PARAM_READABLE));
+
+  gtk_widget_class_install_style_property (widget_class,
+                                          g_param_spec_int ("toggle-spacing",
+                                                            "Icon Spacing",
+                                                            "Space between icon and label",
+                                                            0,
+                                                            G_MAXINT,
+                                                            5,
+                                                            GTK_PARAM_READABLE));
+
+  gtk_widget_class_install_style_property (widget_class,
+                                          g_param_spec_int ("arrow-spacing",
+                                                            "Arrow Spacing",
+                                                            "Space between label and arrow",
+                                                            0,
+                                                            G_MAXINT,
+                                                            10,
+                                                            GTK_PARAM_READABLE));
 }
 
 static void
@@ -296,7 +296,7 @@ gtk_menu_item_destroy (GtkObject *object)
   if (menu_item->submenu)
     gtk_widget_destroy (menu_item->submenu);
 
-  GTK_OBJECT_CLASS (parent_class)->destroy (object);
+  GTK_OBJECT_CLASS (gtk_menu_item_parent_class)->destroy (object);
 }
 
 static void
@@ -306,7 +306,7 @@ gtk_menu_item_finalize (GObject *object)
 
   g_free (menu_item->accel_path);
 
-  G_OBJECT_CLASS (parent_class)->finalize (object);
+  G_OBJECT_CLASS (gtk_menu_item_parent_class)->finalize (object);
 }
 
 static void
@@ -385,16 +385,38 @@ void
 gtk_menu_item_select (GtkMenuItem *menu_item)
 {
   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
-  
+
   gtk_item_select (GTK_ITEM (menu_item));
+
+  /* Enable themeing of the parent menu item depending on whether
+   * something is selected in its submenu
+   */
+  if (GTK_IS_MENU (GTK_WIDGET (menu_item)->parent))
+    {
+      GtkMenu *menu = GTK_MENU (GTK_WIDGET (menu_item)->parent);
+
+      if (menu->parent_menu_item)
+        gtk_widget_queue_draw (GTK_WIDGET (menu->parent_menu_item));
+    }
 }
 
 void
 gtk_menu_item_deselect (GtkMenuItem *menu_item)
 {
   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
-  
+
   gtk_item_deselect (GTK_ITEM (menu_item));
+
+  /* Enable themeing of the parent menu item depending on whether
+   * something is selected in its submenu
+   */
+  if (GTK_IS_MENU (GTK_WIDGET (menu_item)->parent))
+    {
+      GtkMenu *menu = GTK_MENU (GTK_WIDGET (menu_item)->parent);
+
+      if (menu->parent_menu_item)
+        gtk_widget_queue_draw (GTK_WIDGET (menu->parent_menu_item));
+    }
 }
 
 void
@@ -442,6 +464,26 @@ gtk_menu_item_accel_width_foreach (GtkWidget *widget,
                           data);
 }
 
+static gint
+get_minimum_width (GtkWidget *widget)
+{
+  PangoContext *context;
+  PangoFontMetrics *metrics;
+  gint height;
+
+  context = gtk_widget_get_pango_context (widget);
+  metrics = pango_context_get_metrics (context,
+                                      widget->style->font_desc,
+                                      pango_context_get_language (context));
+
+  height = pango_font_metrics_get_ascent (metrics) +
+      pango_font_metrics_get_descent (metrics);
+  
+  pango_font_metrics_unref (metrics);
+
+  return PANGO_PIXELS (7 * height);
+}
+
 static void
 gtk_menu_item_size_request (GtkWidget      *widget,
                            GtkRequisition *requisition)
@@ -449,19 +491,43 @@ gtk_menu_item_size_request (GtkWidget      *widget,
   GtkMenuItem *menu_item;
   GtkBin *bin;
   guint accel_width;
+  guint horizontal_padding;
+  GtkPackDirection pack_dir;
+  GtkPackDirection child_pack_dir;
 
   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
   g_return_if_fail (requisition != NULL);
 
+  gtk_widget_style_get (widget,
+                       "horizontal-padding", &horizontal_padding,
+                       NULL);
+  
   bin = GTK_BIN (widget);
   menu_item = GTK_MENU_ITEM (widget);
 
+  if (GTK_IS_MENU_BAR (widget->parent))
+    {
+      pack_dir = gtk_menu_bar_get_pack_direction (GTK_MENU_BAR (widget->parent));
+      child_pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (widget->parent));
+    }
+  else
+    {
+      pack_dir = GTK_PACK_DIRECTION_LTR;
+      child_pack_dir = GTK_PACK_DIRECTION_LTR;
+    }
+
   requisition->width = (GTK_CONTAINER (widget)->border_width +
-                       widget->style->xthickness +
-                       BORDER_SPACING) * 2;
+                       widget->style->xthickness) * 2;
   requisition->height = (GTK_CONTAINER (widget)->border_width +
                         widget->style->ythickness) * 2;
 
+  if ((pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL) &&
+      (child_pack_dir == GTK_PACK_DIRECTION_LTR || child_pack_dir == GTK_PACK_DIRECTION_RTL))
+    requisition->width += 2 * horizontal_padding;
+  else if ((pack_dir == GTK_PACK_DIRECTION_TTB || pack_dir == GTK_PACK_DIRECTION_BTT) &&
+      (child_pack_dir == GTK_PACK_DIRECTION_TTB || child_pack_dir == GTK_PACK_DIRECTION_BTT))
+    requisition->height += 2 * horizontal_padding;
+
   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
     {
       GtkRequisition child_requisition;
@@ -472,7 +538,33 @@ gtk_menu_item_size_request (GtkWidget      *widget,
       requisition->height += child_requisition.height;
 
       if (menu_item->submenu && menu_item->show_submenu_indicator)
-       requisition->width += child_requisition.height;
+       {
+         guint arrow_spacing;
+         
+         gtk_widget_style_get (widget,
+                               "arrow-spacing", &arrow_spacing,
+                               NULL);
+
+         requisition->width += child_requisition.height;
+         requisition->width += arrow_spacing;
+
+         requisition->width = MAX (requisition->width, get_minimum_width (widget));
+       }
+    }
+  else /* separator item */
+    {
+      gboolean wide_separators;
+      gint     separator_height;
+
+      gtk_widget_style_get (widget,
+                            "wide-separators",  &wide_separators,
+                            "separator-height", &separator_height,
+                            NULL);
+
+      if (wide_separators)
+        requisition->height += separator_height + widget->style->ythickness;
+      else
+        requisition->height += widget->style->ythickness * 2;
     }
 
   accel_width = 0;
@@ -490,6 +582,8 @@ gtk_menu_item_size_allocate (GtkWidget     *widget,
   GtkBin *bin;
   GtkAllocation child_allocation;
   GtkTextDirection direction;
+  GtkPackDirection pack_dir;
+  GtkPackDirection child_pack_dir;
 
   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
   g_return_if_fail (allocation != NULL);
@@ -499,22 +593,55 @@ gtk_menu_item_size_allocate (GtkWidget     *widget,
   
   direction = gtk_widget_get_direction (widget);
 
+  if (GTK_IS_MENU_BAR (widget->parent))
+    {
+      pack_dir = gtk_menu_bar_get_pack_direction (GTK_MENU_BAR (widget->parent));
+      child_pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (widget->parent));
+    }
+  else
+    {
+      pack_dir = GTK_PACK_DIRECTION_LTR;
+      child_pack_dir = GTK_PACK_DIRECTION_LTR;
+    }
+    
   widget->allocation = *allocation;
 
   if (bin->child)
     {
       GtkRequisition child_requisition;
+      guint horizontal_padding;
+
+      gtk_widget_style_get (widget,
+                           "horizontal-padding", &horizontal_padding,
+                           NULL);
+
+      child_allocation.x = GTK_CONTAINER (widget)->border_width + widget->style->xthickness;
+      child_allocation.y = GTK_CONTAINER (widget)->border_width + widget->style->ythickness;
+
+      if ((pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL) &&
+         (child_pack_dir == GTK_PACK_DIRECTION_LTR || child_pack_dir == GTK_PACK_DIRECTION_RTL))
+       child_allocation.x += horizontal_padding;
+      else if ((pack_dir == GTK_PACK_DIRECTION_TTB || pack_dir == GTK_PACK_DIRECTION_BTT) &&
+              (child_pack_dir == GTK_PACK_DIRECTION_TTB || child_pack_dir == GTK_PACK_DIRECTION_BTT))
+       child_allocation.y += horizontal_padding;
       
-      child_allocation.x = (GTK_CONTAINER (widget)->border_width +
-                            widget->style->xthickness +
-                           BORDER_SPACING);
-      child_allocation.y = (GTK_CONTAINER (widget)->border_width +
-                           widget->style->ythickness);
       child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
       child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
-      if (direction == GTK_TEXT_DIR_LTR)
-       child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
-      child_allocation.width -= GTK_MENU_ITEM (widget)->toggle_size;
+
+      if (child_pack_dir == GTK_PACK_DIRECTION_LTR ||
+         child_pack_dir == GTK_PACK_DIRECTION_RTL)
+       {
+         if ((direction == GTK_TEXT_DIR_LTR) == (child_pack_dir != GTK_PACK_DIRECTION_RTL))
+           child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
+         child_allocation.width -= GTK_MENU_ITEM (widget)->toggle_size;
+       }
+      else
+       {
+         if ((direction == GTK_TEXT_DIR_LTR) == (child_pack_dir != GTK_PACK_DIRECTION_BTT))
+           child_allocation.y += GTK_MENU_ITEM (widget)->toggle_size;
+         child_allocation.height -= GTK_MENU_ITEM (widget)->toggle_size;
+       }
+
       child_allocation.x += widget->allocation.x;
       child_allocation.y += widget->allocation.y;
 
@@ -560,7 +687,6 @@ gtk_menu_item_realize (GtkWidget *widget)
   attributes.window_type = GDK_WINDOW_CHILD;
   attributes.wclass = GDK_INPUT_ONLY;
   attributes.event_mask = (gtk_widget_get_events (widget) |
-                          GDK_EXPOSURE_MASK |
                           GDK_BUTTON_PRESS_MASK |
                           GDK_BUTTON_RELEASE_MASK |
                           GDK_ENTER_NOTIFY_MASK |
@@ -583,8 +709,8 @@ gtk_menu_item_unrealize (GtkWidget *widget)
   gdk_window_destroy (menu_item->event_window);
   menu_item->event_window = NULL;
   
-  if (GTK_WIDGET_CLASS (parent_class)->unrealize)
-    (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
+  if (GTK_WIDGET_CLASS (gtk_menu_item_parent_class)->unrealize)
+    (* GTK_WIDGET_CLASS (gtk_menu_item_parent_class)->unrealize) (widget);
 }
 
 static void
@@ -592,7 +718,7 @@ gtk_menu_item_map (GtkWidget *widget)
 {
   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
   
-  GTK_WIDGET_CLASS (parent_class)->map (widget);
+  GTK_WIDGET_CLASS (gtk_menu_item_parent_class)->map (widget);
 
   gdk_window_show (menu_item->event_window);
 }
@@ -604,7 +730,7 @@ gtk_menu_item_unmap (GtkWidget *widget)
     
   gdk_window_hide (menu_item->event_window);
 
-  GTK_WIDGET_CLASS (parent_class)->unmap (widget);
+  GTK_WIDGET_CLASS (gtk_menu_item_parent_class)->unmap (widget);
 }
 
 static void
@@ -633,7 +759,7 @@ gtk_menu_item_paint (GtkWidget    *widget,
          (GTK_BIN (menu_item)->child))
        {
          gtk_widget_style_get (widget,
-                               "selected_shadow_type", &selected_shadow_type,
+                               "selected-shadow-type", &selected_shadow_type,
                                NULL);
          gtk_paint_box (widget->style,
                         widget->window,
@@ -645,33 +771,49 @@ gtk_menu_item_paint (GtkWidget    *widget,
   
       if (menu_item->submenu && menu_item->show_submenu_indicator)
        {
-         GtkRequisition child_requisition;
          gint arrow_x, arrow_y;
          gint arrow_size;
          gint arrow_extent;
+         guint horizontal_padding;
          GtkTextDirection direction;
          GtkArrowType arrow_type;
+         PangoContext *context;
+         PangoFontMetrics *metrics;
+         gint ascent, descent;
 
          direction = gtk_widget_get_direction (widget);
       
-         gtk_widget_get_child_requisition (GTK_BIN (menu_item)->child,
-                                           &child_requisition);
+         gtk_widget_style_get (widget,
+                               "horizontal-padding", &horizontal_padding,
+                               NULL);
+         
+         context = gtk_widget_get_pango_context (GTK_BIN (menu_item)->child);
+         metrics = pango_context_get_metrics (context, 
+                                              GTK_WIDGET (GTK_BIN (menu_item)->child)->style->font_desc,
+                                              pango_context_get_language (context));
+         
+         ascent = pango_font_metrics_get_ascent (metrics);
+         descent = pango_font_metrics_get_descent (metrics);
+         pango_font_metrics_unref (metrics);
+         
+         arrow_size = PANGO_PIXELS (ascent + descent) - 2 * widget->style->ythickness;
 
-         arrow_size = child_requisition.height - 2 * widget->style->ythickness;
-         arrow_extent = arrow_size * 0.6;
+         arrow_extent = arrow_size * 0.8;
          
          shadow_type = GTK_SHADOW_OUT;
          if (state_type == GTK_STATE_PRELIGHT)
            shadow_type = GTK_SHADOW_IN;
 
-         if (direction == GTK_TEXT_DIR_LTR) {
-           arrow_x = x + width - 1 - arrow_size + (arrow_size - arrow_extent) / 2;
-           arrow_type = GTK_ARROW_RIGHT;
-         }
-         else {
-           arrow_x = x + 1 + (arrow_size - arrow_extent) / 2;
-           arrow_type = GTK_ARROW_LEFT;
-         }
+         if (direction == GTK_TEXT_DIR_LTR)
+           {
+             arrow_x = x + width - horizontal_padding - arrow_extent;
+             arrow_type = GTK_ARROW_RIGHT;
+           }
+         else
+           {
+             arrow_x = x + horizontal_padding;
+             arrow_type = GTK_ARROW_LEFT;
+           }
 
          arrow_y = y + (height - arrow_extent) / 2;
 
@@ -684,10 +826,34 @@ gtk_menu_item_paint (GtkWidget    *widget,
        }
       else if (!GTK_BIN (menu_item)->child)
        {
-         gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
-                          area, widget, "menuitem",
-                          widget->allocation.x, widget->allocation.width,
-                          widget->allocation.y);
+          gboolean wide_separators;
+          gint     separator_height;
+         guint    horizontal_padding;
+
+         gtk_widget_style_get (widget,
+                                "wide-separators",    &wide_separators,
+                                "separator-height",   &separator_height,
+                                "horizontal-padding", &horizontal_padding,
+                                NULL);
+
+          if (wide_separators)
+            gtk_paint_box (widget->style, widget->window,
+                           GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_OUT,
+                           area, widget, "hseparator",
+                           widget->allocation.x + horizontal_padding + widget->style->xthickness,
+                           widget->allocation.y + (widget->allocation.height -
+                                                   separator_height -
+                                                   widget->style->ythickness) / 2,
+                           widget->allocation.width -
+                           2 * (horizontal_padding + widget->style->xthickness),
+                           separator_height);
+          else
+            gtk_paint_hline (widget->style, widget->window,
+                             GTK_STATE_NORMAL, area, widget, "menuitem",
+                             widget->allocation.x + horizontal_padding + widget->style->xthickness,
+                             widget->allocation.x + widget->allocation.width - horizontal_padding - widget->style->xthickness - 1,
+                             widget->allocation.y + (widget->allocation.height -
+                                                     widget->style->ythickness) / 2);
        }
     }
 }
@@ -703,7 +869,7 @@ gtk_menu_item_expose (GtkWidget      *widget,
     {
       gtk_menu_item_paint (widget, &event->area);
 
-      (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
+      (* GTK_WIDGET_CLASS (gtk_menu_item_parent_class)->expose_event) (widget, event);
     }
 
   return FALSE;
@@ -722,7 +888,7 @@ get_popup_delay (GtkMenuItem *menu_item)
     {
       gint popup_delay;
       
-      g_object_get (G_OBJECT (gtk_widget_get_settings (GTK_WIDGET (menu_item))),
+      g_object_get (gtk_widget_get_settings (GTK_WIDGET (menu_item)),
                    "gtk-menu-popup-delay", &popup_delay,
                    NULL);
 
@@ -739,22 +905,28 @@ gtk_real_menu_item_select (GtkItem *item)
 
   menu_item = GTK_MENU_ITEM (item);
 
-  if (menu_item->submenu)
+  if (menu_item->submenu &&
+      (!GTK_WIDGET_MAPPED (menu_item->submenu) ||
+       GTK_MENU (menu_item->submenu)->tearoff_active))
     {
       gint popup_delay;
 
       if (menu_item->timer)
-       gtk_timeout_remove (menu_item->timer);
-
-      popup_delay = get_popup_delay (menu_item);
+       {
+         g_source_remove (menu_item->timer);
+         menu_item->timer = 0;
+         popup_delay = 0;
+       }
+      else
+       popup_delay = get_popup_delay (menu_item);
       
       if (popup_delay > 0)
        {
          GdkEvent *event = gtk_get_current_event ();
          
-         menu_item->timer = gtk_timeout_add (popup_delay,
-                                             gtk_menu_item_select_timeout,
-                                             menu_item);
+         menu_item->timer = gdk_threads_add_timeout (popup_delay,
+                                           gtk_menu_item_select_timeout,
+                                           menu_item);
          if (event &&
              event->type != GDK_BUTTON_PRESS &&
              event->type != GDK_ENTER_NOTIFY)
@@ -766,7 +938,7 @@ gtk_real_menu_item_select (GtkItem *item)
            gdk_event_free (event);
        }
       else
-       gtk_menu_item_popup_submenu (menu_item);
+       _gtk_menu_item_popup_submenu (GTK_WIDGET (menu_item));
     }
   
   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_PRELIGHT);
@@ -786,7 +958,7 @@ gtk_real_menu_item_deselect (GtkItem *item)
     {
       if (menu_item->timer)
        {
-         gtk_timeout_remove (menu_item->timer);
+         g_source_remove (menu_item->timer);
          menu_item->timer = 0;
        }
       else
@@ -820,7 +992,6 @@ static void
 gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
 {
   GtkWidget *widget;
-  GtkMenuShell *submenu; 
 
   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 
@@ -839,10 +1010,9 @@ gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
          _gtk_menu_shell_activate (menu_shell);
 
          gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent), widget); 
-         gtk_menu_item_popup_submenu (widget); 
+         _gtk_menu_item_popup_submenu (widget); 
 
          gtk_menu_shell_select_first (GTK_MENU_SHELL (menu_item->submenu), TRUE);
-         submenu = GTK_MENU_SHELL (menu_item->submenu);
        }
     }
 }
@@ -870,45 +1040,68 @@ gtk_menu_item_select_timeout (gpointer data)
   GtkMenuItem *menu_item;
   GtkWidget *parent;
   
-  GDK_THREADS_ENTER ();
-
   menu_item = GTK_MENU_ITEM (data);
 
   parent = GTK_WIDGET (menu_item)->parent;
 
-  if (parent && GTK_IS_MENU_SHELL (parent) && GTK_MENU_SHELL (parent)->active)
+  if ((GTK_IS_MENU_SHELL (parent) && GTK_MENU_SHELL (parent)->active) || 
+      (GTK_IS_MENU (parent) && GTK_MENU (parent)->torn_off))
     {
-      gtk_menu_item_popup_submenu (data);
+      _gtk_menu_item_popup_submenu (GTK_WIDGET (menu_item));
       if (menu_item->timer_from_keypress && menu_item->submenu)
        GTK_MENU_SHELL (menu_item->submenu)->ignore_enter = TRUE;
     }
 
-  GDK_THREADS_LEAVE ();
-
   return FALSE;  
 }
 
-static void
-gtk_menu_item_popup_submenu (gpointer data)
+void
+_gtk_menu_item_popup_submenu (GtkWidget *widget)
 {
-  GtkWidget *widget;
   GtkMenuItem *menu_item;
 
-  widget = GTK_WIDGET (data);
   menu_item = GTK_MENU_ITEM (widget);
 
   if (menu_item->timer)
-    gtk_timeout_remove (menu_item->timer);
+    g_source_remove (menu_item->timer);
   menu_item->timer = 0;
 
   if (GTK_WIDGET_IS_SENSITIVE (menu_item->submenu))
-    gtk_menu_popup (GTK_MENU (menu_item->submenu),
-                   widget->parent,
-                   widget,
-                   gtk_menu_item_position_menu,
-                   menu_item,
-                   GTK_MENU_SHELL (widget->parent)->button,
-                   0);
+    {
+      gboolean take_focus;
+
+      take_focus = gtk_menu_shell_get_take_focus (GTK_MENU_SHELL (widget->parent));
+      gtk_menu_shell_set_take_focus (GTK_MENU_SHELL (menu_item->submenu),
+                                     take_focus);
+
+      gtk_menu_popup (GTK_MENU (menu_item->submenu),
+                      widget->parent,
+                      widget,
+                      gtk_menu_item_position_menu,
+                      menu_item,
+                      GTK_MENU_SHELL (widget->parent)->button,
+                      0);
+    }
+}
+
+static void
+get_offsets (GtkMenu *menu,
+            gint    *horizontal_offset,
+            gint    *vertical_offset)
+{
+  gint vertical_padding;
+  gint horizontal_padding;
+  
+  gtk_widget_style_get (GTK_WIDGET (menu),
+                       "horizontal-offset", horizontal_offset,
+                       "vertical-offset", vertical_offset,
+                       "horizontal-padding", &horizontal_padding,
+                       "vertical-padding", &vertical_padding,
+                       NULL);
+
+  *vertical_offset -= GTK_WIDGET (menu)->style->ythickness;
+  *vertical_offset -= vertical_padding;
+  *horizontal_offset += horizontal_padding;
 }
 
 static void
@@ -920,13 +1113,16 @@ gtk_menu_item_position_menu (GtkMenu  *menu,
 {
   GtkMenuItem *menu_item;
   GtkWidget *widget;
-  GtkWidget *parent_menu_item;
+  GtkMenuItem *parent_menu_item;
   GdkScreen *screen;
   gint twidth, theight;
   gint tx, ty;
   GtkTextDirection direction;
   GdkRectangle monitor;
   gint monitor_num;
+  gint horizontal_offset;
+  gint vertical_offset;
+  gint parent_xthickness;
 
   g_return_if_fail (menu != NULL);
   g_return_if_fail (x != NULL);
@@ -935,13 +1131,16 @@ gtk_menu_item_position_menu (GtkMenu  *menu,
   menu_item = GTK_MENU_ITEM (user_data);
   widget = GTK_WIDGET (user_data);
 
+  if (push_in)
+    *push_in = FALSE;
+
   direction = gtk_widget_get_direction (widget);
 
   twidth = GTK_WIDGET (menu)->requisition.width;
   theight = GTK_WIDGET (menu)->requisition.height;
 
-  screen = gtk_widget_get_screen (widget);
-  monitor_num = gdk_screen_get_monitor_at_window (screen, widget->window);
+  screen = gtk_widget_get_screen (GTK_WIDGET (menu));
+  monitor_num = gdk_screen_get_monitor_at_window (screen, menu_item->event_window);
   if (monitor_num < 0)
     monitor_num = 0;
   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
@@ -955,6 +1154,24 @@ gtk_menu_item_position_menu (GtkMenu  *menu,
   tx += widget->allocation.x;
   ty += widget->allocation.y;
 
+  get_offsets (menu, &horizontal_offset, &vertical_offset);
+
+  if (GTK_IS_MENU_BAR (widget->parent))
+    {
+      menu_item->from_menubar = TRUE;
+    }
+  else if (GTK_IS_MENU (widget->parent))
+    {
+      if (GTK_MENU (widget->parent)->parent_menu_item)
+       menu_item->from_menubar = GTK_MENU_ITEM (GTK_MENU (widget->parent)->parent_menu_item)->from_menubar;
+      else
+       menu_item->from_menubar = FALSE;
+    }
+  else
+    {
+      menu_item->from_menubar = FALSE;
+    }
+  
   switch (menu_item->submenu_placement)
     {
     case GTK_TOP_BOTTOM:
@@ -965,7 +1182,6 @@ gtk_menu_item_position_menu (GtkMenu  *menu,
          menu_item->submenu_direction = GTK_DIRECTION_LEFT;
          tx += widget->allocation.width - twidth;
        }
-
       if ((ty + widget->allocation.height + theight) <= monitor.y + monitor.height)
        ty += widget->allocation.height;
       else if ((ty - theight) >= monitor.y)
@@ -977,41 +1193,50 @@ gtk_menu_item_position_menu (GtkMenu  *menu,
       break;
 
     case GTK_LEFT_RIGHT:
-      parent_menu_item = GTK_MENU (widget->parent)->parent_menu_item;
-      if (parent_menu_item && 
-         !GTK_MENU (widget->parent)->torn_off && 
-         !GTK_MENU_SHELL (menu)->active)
-       menu_item->submenu_direction = GTK_MENU_ITEM (parent_menu_item)->submenu_direction;
-      else if (direction == GTK_TEXT_DIR_LTR)
-       menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
+      if (GTK_IS_MENU (widget->parent))
+       parent_menu_item = GTK_MENU_ITEM (GTK_MENU (widget->parent)->parent_menu_item);
+      else
+       parent_menu_item = NULL;
+      
+      parent_xthickness = widget->parent->style->xthickness;
+
+      if (parent_menu_item && !GTK_MENU (widget->parent)->torn_off)
+       {
+         menu_item->submenu_direction = parent_menu_item->submenu_direction;
+       }
       else
-       menu_item->submenu_direction = GTK_DIRECTION_LEFT;
+       {
+         if (direction == GTK_TEXT_DIR_LTR)
+           menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
+         else
+           menu_item->submenu_direction = GTK_DIRECTION_LEFT;
+       }
 
       switch (menu_item->submenu_direction)
        {
        case GTK_DIRECTION_LEFT:
-         if ((tx - twidth) >= monitor.x)
-           tx -= twidth;
+         if ((tx - twidth - parent_xthickness - horizontal_offset) >= monitor.x)
+           tx -= twidth + parent_xthickness + horizontal_offset;
          else
            {
              menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
-             tx += widget->allocation.width - 5;
+             tx += widget->allocation.width + parent_xthickness + horizontal_offset;
            }
          break;
 
        case GTK_DIRECTION_RIGHT:
-         if ((tx + widget->allocation.width + twidth - 5) <= monitor.x + monitor.width)
-           tx += widget->allocation.width - 5;
+         if ((tx + widget->allocation.width + parent_xthickness + horizontal_offset + twidth) <= monitor.x + monitor.width)
+           tx += widget->allocation.width + parent_xthickness + horizontal_offset;
          else
            {
              menu_item->submenu_direction = GTK_DIRECTION_LEFT;
-             tx -= twidth;
+             tx -= twidth + parent_xthickness + horizontal_offset;
            }
          break;
        }
 
-      ty += widget->allocation.height / 4;
-
+      ty += vertical_offset;
+      
       /* If the height of the menu doesn't fit we move it upward. */
       ty = CLAMP (ty, monitor.y, MAX (monitor.y, monitor.y + monitor.height - theight));
       break;
@@ -1022,6 +1247,14 @@ gtk_menu_item_position_menu (GtkMenu  *menu,
    */
   *x = CLAMP (tx, monitor.x, MAX (monitor.x, monitor.x + monitor.width - twidth));
   *y = ty;
+
+  gtk_menu_set_monitor (menu, monitor_num);
+
+  if (!GTK_WIDGET_VISIBLE (menu->toplevel))
+    {
+      gtk_window_set_type_hint (GTK_WINDOW (menu->toplevel), menu_item->from_menubar?
+                               GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU : GDK_WINDOW_TYPE_HINT_POPUP_MENU);
+    }
 }
 
 /**
@@ -1104,6 +1337,15 @@ gtk_menu_item_hide_all (GtkWidget *widget)
     gtk_widget_hide_all (menu_item->submenu);
 }
 
+static gboolean
+gtk_menu_item_can_activate_accel (GtkWidget *widget,
+                                 guint      signal_id)
+{
+  /* Chain to the parent GtkMenu for further checks */
+  return (GTK_WIDGET_IS_SENSITIVE (widget) && GTK_WIDGET_VISIBLE (widget) &&
+          widget->parent && gtk_widget_can_activate_accel (widget->parent, signal_id));
+}
+
 static void
 gtk_menu_item_accel_name_foreach (GtkWidget *widget,
                                  gpointer data)
@@ -1138,8 +1380,8 @@ gtk_menu_item_parent_set (GtkWidget *widget,
                                       menu->accel_group,
                                       TRUE);
 
-  if (GTK_WIDGET_CLASS (parent_class)->parent_set)
-    GTK_WIDGET_CLASS (parent_class)->parent_set (widget, previous_parent);
+  if (GTK_WIDGET_CLASS (gtk_menu_item_parent_class)->parent_set)
+    GTK_WIDGET_CLASS (gtk_menu_item_parent_class)->parent_set (widget, previous_parent);
 }
 
 void
@@ -1244,13 +1486,11 @@ gtk_menu_item_forall (GtkContainer *container,
                      gpointer      callback_data)
 {
   GtkBin *bin;
-  GtkMenuItem *menu_item;
 
   g_return_if_fail (GTK_IS_MENU_ITEM (container));
   g_return_if_fail (callback != NULL);
 
   bin = GTK_BIN (container);
-  menu_item = GTK_MENU_ITEM (container);
 
   if (bin->child)
     callback (bin->child, callback_data);
@@ -1268,3 +1508,6 @@ _gtk_menu_item_is_selectable (GtkWidget *menu_item)
 
   return TRUE;
 }
+
+#define __GTK_MENU_ITEM_C__
+#include "gtkaliasdef.c"