Pileus Git - ~andy/gtk/blob - gtk/gtkmenuitem.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #define GTK_MENU_INTERNALS
  28
  29 #include <config.h>
  30 #include <string.h>
  31
  32 #include "gtkaccellabel.h"
  33 #include "gtkmain.h"
  34 #include "gtkmarshalers.h"
  35 #include "gtkmenu.h"
  36 #include "gtkmenubar.h"
  37 #include "gtkmenuitem.h"
  38 #include "gtkseparatormenuitem.h"
  39 #include "gtkprivate.h"
  40 #include "gtkintl.h"
  41 #include "gtkalias.h"
  42
  43 #define MENU_ITEM_CLASS(w)  GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
  44
  45 enum {
  46   ACTIVATE,
  47   ACTIVATE_ITEM,
  48   TOGGLE_SIZE_REQUEST,
  49   TOGGLE_SIZE_ALLOCATE,
  50   LAST_SIGNAL
  51 };
  52
  53
  54 static void gtk_menu_item_class_init     (GtkMenuItemClass *klass);
  55 static void gtk_menu_item_init           (GtkMenuItem      *menu_item);
  56 static void gtk_menu_item_destroy        (GtkObject        *object);
  57 static void gtk_menu_item_finalize       (GObject          *object);
  58 static void gtk_menu_item_size_request   (GtkWidget        *widget,
  59                                           GtkRequisition   *requisition);
  60 static void gtk_menu_item_size_allocate  (GtkWidget        *widget,
  61                                           GtkAllocation    *allocation);
  62 static void gtk_menu_item_realize        (GtkWidget        *widget);
  63 static void gtk_menu_item_unrealize      (GtkWidget        *widget);
  64 static void gtk_menu_item_map            (GtkWidget        *widget);
  65 static void gtk_menu_item_unmap          (GtkWidget        *widget);
  66 static void gtk_menu_item_paint          (GtkWidget        *widget,
  67                                           GdkRectangle     *area);
  68 static gint gtk_menu_item_expose         (GtkWidget        *widget,
  69                                           GdkEventExpose   *event);
  70 static void gtk_menu_item_parent_set     (GtkWidget        *widget,
  71                                           GtkWidget        *previous_parent);
  72
  73
  74 static void gtk_real_menu_item_select               (GtkItem     *item);
  75 static void gtk_real_menu_item_deselect             (GtkItem     *item);
  76 static void gtk_real_menu_item_activate_item        (GtkMenuItem *item);
  77 static void gtk_real_menu_item_toggle_size_request  (GtkMenuItem *menu_item,
  78                                                      gint        *requisition);
  79 static void gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
  80                                                      gint         allocation);
  81 static gboolean gtk_menu_item_mnemonic_activate     (GtkWidget   *widget,
  82                                                      gboolean     group_cycling);
  83
  84 static gint gtk_menu_item_select_timeout (gpointer          data);
  85 static void gtk_menu_item_position_menu  (GtkMenu          *menu,
  86                                           gint             *x,
  87                                           gint             *y,
  88                                           gboolean         *push_in,
  89                                           gpointer          user_data);
  90 static void gtk_menu_item_show_all       (GtkWidget        *widget);
  91 static void gtk_menu_item_hide_all       (GtkWidget        *widget);
  92 static void gtk_menu_item_forall         (GtkContainer    *container,
  93                                           gboolean         include_internals,
  94                                           GtkCallback      callback,
  95                                           gpointer         callback_data);
  96 static gboolean gtk_menu_item_can_activate_accel (GtkWidget *widget,
  97                                                   guint      signal_id);
  98
  99
 100 static GtkItemClass *parent_class;
 101 static guint menu_item_signals[LAST_SIGNAL] = { 0 };
 102
 103 GType
 104 gtk_menu_item_get_type (void)
 105 {
 106   static GType menu_item_type = 0;
 107
 108   if (!menu_item_type)
 109     {
 110       static const GTypeInfo menu_item_info =
 111       {
 112         sizeof (GtkMenuItemClass),
 113         NULL,           /* base_init */
 114         NULL,           /* base_finalize */
 115         (GClassInitFunc) gtk_menu_item_class_init,
 116         NULL,           /* class_finalize */
 117         NULL,           /* class_data */
 118         sizeof (GtkMenuItem),
 119         16,             /* n_preallocs */
 120         (GInstanceInitFunc) gtk_menu_item_init,
 121       };
 122
 123       menu_item_type = g_type_register_static (GTK_TYPE_ITEM, I_("GtkMenuItem"),
 124                                                &menu_item_info, 0);
 125     }
 126
 127   return menu_item_type;
 128 }
 129
 130 static void
 131 gtk_menu_item_class_init (GtkMenuItemClass *klass)
 132 {
 133   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 134   GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
 135   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 136   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 137   GtkItemClass *item_class = GTK_ITEM_CLASS (klass);
 138
 139   parent_class = g_type_class_peek_parent (klass);
 140
 141   gobject_class->finalize = gtk_menu_item_finalize;
 142
 143   object_class->destroy = gtk_menu_item_destroy;
 144
 145   widget_class->size_request = gtk_menu_item_size_request;
 146   widget_class->size_allocate = gtk_menu_item_size_allocate;
 147   widget_class->expose_event = gtk_menu_item_expose;
 148   widget_class->realize = gtk_menu_item_realize;
 149   widget_class->unrealize = gtk_menu_item_unrealize;
 150   widget_class->map = gtk_menu_item_map;
 151   widget_class->unmap = gtk_menu_item_unmap;
 152   widget_class->show_all = gtk_menu_item_show_all;
 153   widget_class->hide_all = gtk_menu_item_hide_all;
 154   widget_class->mnemonic_activate = gtk_menu_item_mnemonic_activate;
 155   widget_class->parent_set = gtk_menu_item_parent_set;
 156   widget_class->can_activate_accel = gtk_menu_item_can_activate_accel;
 157
 158   container_class->forall = gtk_menu_item_forall;
 159
 160   item_class->select = gtk_real_menu_item_select;
 161   item_class->deselect = gtk_real_menu_item_deselect;
 162
 163   klass->activate = NULL;
 164   klass->activate_item = gtk_real_menu_item_activate_item;
 165   klass->toggle_size_request = gtk_real_menu_item_toggle_size_request;
 166   klass->toggle_size_allocate = gtk_real_menu_item_toggle_size_allocate;
 167
 168   klass->hide_on_activate = TRUE;
 169
 170   menu_item_signals[ACTIVATE] =
 171     g_signal_new (I_("activate"),
 172                   G_OBJECT_CLASS_TYPE (gobject_class),
 173                   G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 174                   G_STRUCT_OFFSET (GtkMenuItemClass, activate),
 175                   NULL, NULL,
 176                   _gtk_marshal_VOID__VOID,
 177                   G_TYPE_NONE, 0);
 178   widget_class->activate_signal = menu_item_signals[ACTIVATE];
 179
 180   menu_item_signals[ACTIVATE_ITEM] =
 181     g_signal_new (I_("activate_item"),
 182                   G_OBJECT_CLASS_TYPE (gobject_class),
 183                   G_SIGNAL_RUN_FIRST,
 184                   G_STRUCT_OFFSET (GtkMenuItemClass, activate_item),
 185                   NULL, NULL,
 186                   _gtk_marshal_VOID__VOID,
 187                   G_TYPE_NONE, 0);
 188
 189   menu_item_signals[TOGGLE_SIZE_REQUEST] =
 190     g_signal_new (I_("toggle_size_request"),
 191                   G_OBJECT_CLASS_TYPE (gobject_class),
 192                   G_SIGNAL_RUN_FIRST,
 193                   G_STRUCT_OFFSET (GtkMenuItemClass, toggle_size_request),
 194                   NULL, NULL,
 195                   _gtk_marshal_VOID__POINTER,
 196                   G_TYPE_NONE, 1,
 197                   G_TYPE_POINTER);
 198
 199   menu_item_signals[TOGGLE_SIZE_ALLOCATE] =
 200     g_signal_new (I_("toggle_size_allocate"),
 201                   G_OBJECT_CLASS_TYPE (gobject_class),
 202                   G_SIGNAL_RUN_FIRST,
 203                   G_STRUCT_OFFSET (GtkMenuItemClass, toggle_size_allocate),
 204                   NULL, NULL,
 205                   _gtk_marshal_NONE__INT,
 206                   G_TYPE_NONE, 1,
 207                   G_TYPE_INT);
 208
 209   gtk_widget_class_install_style_property_parser (widget_class,
 210                                                   g_param_spec_enum ("selected-shadow-type",
 211                                                                      "Selected Shadow Type",
 212                                                                      "Shadow type when item is selected",
 213                                                                      GTK_TYPE_SHADOW_TYPE,
 214                                                                      GTK_SHADOW_NONE,
 215                                                                      GTK_PARAM_READABLE),
 216                                                   gtk_rc_property_parse_enum);
 217
 218   gtk_widget_class_install_style_property (widget_class,
 219                                            g_param_spec_int ("horizontal-padding",
 220                                                              "Horizontal Padding",
 221                                                              "Padding to left and right of the menu item",
 222                                                              0,
 223                                                              G_MAXINT,
 224                                                              3,
 225                                                              GTK_PARAM_READABLE));
 226
 227   gtk_widget_class_install_style_property (widget_class,
 228                                            g_param_spec_int ("toggle-spacing",
 229                                                              "Icon Spacing",
 230                                                              "Space between icon and label",
 231                                                              0,
 232                                                              G_MAXINT,
 233                                                              5,
 234                                                              GTK_PARAM_READABLE));
 235
 236   gtk_widget_class_install_style_property (widget_class,
 237                                            g_param_spec_int ("arrow-spacing",
 238                                                              "Arrow Spacing",
 239                                                              "Space between label and arrow",
 240                                                              0,
 241                                                              G_MAXINT,
 242                                                              10,
 243                                                              GTK_PARAM_READABLE));
 244 }
 245
 246 static void
 247 gtk_menu_item_init (GtkMenuItem *menu_item)
 248 {
 249   GTK_WIDGET_SET_FLAGS (menu_item, GTK_NO_WINDOW);
 250
 251   menu_item->submenu = NULL;
 252   menu_item->toggle_size = 0;
 253   menu_item->accelerator_width = 0;
 254   menu_item->show_submenu_indicator = FALSE;
 255   if (gtk_widget_get_direction (GTK_WIDGET (menu_item)) == GTK_TEXT_DIR_RTL)
 256     menu_item->submenu_direction = GTK_DIRECTION_LEFT;
 257   else
 258     menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 259   menu_item->submenu_placement = GTK_TOP_BOTTOM;
 260   menu_item->right_justify = FALSE;
 261
 262   menu_item->timer = 0;
 263 }
 264
 265 GtkWidget*
 266 gtk_menu_item_new (void)
 267 {
 268   return g_object_new (GTK_TYPE_MENU_ITEM, NULL);
 269 }
 270
 271 GtkWidget*
 272 gtk_menu_item_new_with_label (const gchar *label)
 273 {
 274   GtkWidget *menu_item;
 275   GtkWidget *accel_label;
 276
 277   menu_item = gtk_menu_item_new ();
 278   accel_label = gtk_accel_label_new (label);
 279   gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
 280
 281   gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
 282   gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
 283   gtk_widget_show (accel_label);
 284
 285   return menu_item;
 286 }
 287
 288
 289 /**
 290  * gtk_menu_item_new_with_mnemonic:
 291  * @label: The text of the button, with an underscore in front of the
 292  *         mnemonic character
 293  * @returns: a new #GtkMenuItem
 294  *
 295  * Creates a new #GtkMenuItem containing a label. The label
 296  * will be created using gtk_label_new_with_mnemonic(), so underscores
 297  * in @label indicate the mnemonic for the menu item.
 298  **/
 299 GtkWidget*
 300 gtk_menu_item_new_with_mnemonic (const gchar *label)
 301 {
 302   GtkWidget *menu_item;
 303   GtkWidget *accel_label;
 304
 305   menu_item = gtk_menu_item_new ();
 306   accel_label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL);
 307   gtk_label_set_text_with_mnemonic (GTK_LABEL (accel_label), label);
 308   gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
 309
 310   gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
 311   gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
 312   gtk_widget_show (accel_label);
 313
 314   return menu_item;
 315 }
 316
 317 static void
 318 gtk_menu_item_destroy (GtkObject *object)
 319 {
 320   GtkMenuItem *menu_item;
 321
 322   g_return_if_fail (GTK_IS_MENU_ITEM (object));
 323
 324   menu_item = GTK_MENU_ITEM (object);
 325
 326   if (menu_item->submenu)
 327     gtk_widget_destroy (menu_item->submenu);
 328
 329   GTK_OBJECT_CLASS (parent_class)->destroy (object);
 330 }
 331
 332 static void
 333 gtk_menu_item_finalize (GObject *object)
 334 {
 335   GtkMenuItem *menu_item = GTK_MENU_ITEM (object);
 336
 337   g_free (menu_item->accel_path);
 338
 339   G_OBJECT_CLASS (parent_class)->finalize (object);
 340 }
 341
 342 static void
 343 gtk_menu_item_detacher (GtkWidget     *widget,
 344                         GtkMenu       *menu)
 345 {
 346   GtkMenuItem *menu_item;
 347
 348   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 349
 350   menu_item = GTK_MENU_ITEM (widget);
 351   g_return_if_fail (menu_item->submenu == (GtkWidget*) menu);
 352
 353   menu_item->submenu = NULL;
 354 }
 355
 356 void
 357 gtk_menu_item_set_submenu (GtkMenuItem *menu_item,
 358                            GtkWidget   *submenu)
 359 {
 360   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 361
 362   if (menu_item->submenu != submenu)
 363     {
 364       gtk_menu_item_remove_submenu (menu_item);
 365
 366       menu_item->submenu = submenu;
 367       gtk_menu_attach_to_widget (GTK_MENU (submenu),
 368                                  GTK_WIDGET (menu_item),
 369                                  gtk_menu_item_detacher);
 370
 371       if (GTK_WIDGET (menu_item)->parent)
 372         gtk_widget_queue_resize (GTK_WIDGET (menu_item));
 373     }
 374 }
 375
 376 /**
 377  * gtk_menu_item_get_submenu:
 378  * @menu_item: a #GtkMenuItem
 379  *
 380  * Gets the submenu underneath this menu item, if any. See
 381  * gtk_menu_item_set_submenu().
 382  *
 383  * Return value: submenu for this menu item, or %NULL if none.
 384  **/
 385 GtkWidget *
 386 gtk_menu_item_get_submenu (GtkMenuItem *menu_item)
 387 {
 388   g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), NULL);
 389
 390   return menu_item->submenu;
 391 }
 392
 393 void
 394 gtk_menu_item_remove_submenu (GtkMenuItem         *menu_item)
 395 {
 396   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 397
 398   if (menu_item->submenu)
 399     gtk_menu_detach (GTK_MENU (menu_item->submenu));
 400 }
 401
 402 void _gtk_menu_item_set_placement (GtkMenuItem         *menu_item,
 403                                    GtkSubmenuPlacement  placement);
 404
 405 void
 406 _gtk_menu_item_set_placement (GtkMenuItem         *menu_item,
 407                              GtkSubmenuPlacement  placement)
 408 {
 409   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 410
 411   menu_item->submenu_placement = placement;
 412 }
 413
 414 void
 415 gtk_menu_item_select (GtkMenuItem *menu_item)
 416 {
 417   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 418
 419   gtk_item_select (GTK_ITEM (menu_item));
 420 }
 421
 422 void
 423 gtk_menu_item_deselect (GtkMenuItem *menu_item)
 424 {
 425   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 426
 427   gtk_item_deselect (GTK_ITEM (menu_item));
 428 }
 429
 430 void
 431 gtk_menu_item_activate (GtkMenuItem *menu_item)
 432 {
 433   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 434
 435   g_signal_emit (menu_item, menu_item_signals[ACTIVATE], 0);
 436 }
 437
 438 void
 439 gtk_menu_item_toggle_size_request (GtkMenuItem *menu_item,
 440                                    gint        *requisition)
 441 {
 442   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 443
 444   g_signal_emit (menu_item, menu_item_signals[TOGGLE_SIZE_REQUEST], 0, requisition);
 445 }
 446
 447 void
 448 gtk_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
 449                                     gint         allocation)
 450 {
 451   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 452
 453   g_signal_emit (menu_item, menu_item_signals[TOGGLE_SIZE_ALLOCATE], 0, allocation);
 454 }
 455
 456 static void
 457 gtk_menu_item_accel_width_foreach (GtkWidget *widget,
 458                                    gpointer data)
 459 {
 460   guint *width = data;
 461
 462   if (GTK_IS_ACCEL_LABEL (widget))
 463     {
 464       guint w;
 465
 466       w = gtk_accel_label_get_accel_width (GTK_ACCEL_LABEL (widget));
 467       *width = MAX (*width, w);
 468     }
 469   else if (GTK_IS_CONTAINER (widget))
 470     gtk_container_foreach (GTK_CONTAINER (widget),
 471                            gtk_menu_item_accel_width_foreach,
 472                            data);
 473 }
 474
 475 static gint
 476 get_minimum_width (GtkWidget *widget)
 477 {
 478   PangoContext *context;
 479   PangoFontMetrics *metrics;
 480   gint height;
 481
 482   context = gtk_widget_get_pango_context (widget);
 483   metrics = pango_context_get_metrics (context,
 484                                        widget->style->font_desc,
 485                                        pango_context_get_language (context));
 486
 487   height = pango_font_metrics_get_ascent (metrics) +
 488       pango_font_metrics_get_descent (metrics);
 489
 490   pango_font_metrics_unref (metrics);
 491
 492   return PANGO_PIXELS (7 * height);
 493 }
 494
 495 static void
 496 gtk_menu_item_size_request (GtkWidget      *widget,
 497                             GtkRequisition *requisition)
 498 {
 499   GtkMenuItem *menu_item;
 500   GtkBin *bin;
 501   guint accel_width;
 502   guint horizontal_padding;
 503   GtkPackDirection pack_dir;
 504   GtkPackDirection child_pack_dir;
 505
 506   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 507   g_return_if_fail (requisition != NULL);
 508
 509   gtk_widget_style_get (widget,
 510                         "horizontal-padding", &horizontal_padding,
 511                         NULL);
 512
 513   bin = GTK_BIN (widget);
 514   menu_item = GTK_MENU_ITEM (widget);
 515
 516   if (GTK_IS_MENU_BAR (widget->parent))
 517     {
 518       pack_dir = gtk_menu_bar_get_pack_direction (GTK_MENU_BAR (widget->parent));
 519       child_pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (widget->parent));
 520     }
 521   else
 522     {
 523       pack_dir = GTK_PACK_DIRECTION_LTR;
 524       child_pack_dir = GTK_PACK_DIRECTION_LTR;
 525     }
 526
 527   requisition->width = (GTK_CONTAINER (widget)->border_width +
 528                         widget->style->xthickness) * 2;
 529   requisition->height = (GTK_CONTAINER (widget)->border_width +
 530                          widget->style->ythickness) * 2;
 531
 532   if ((pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL) &&
 533       (child_pack_dir == GTK_PACK_DIRECTION_LTR || child_pack_dir == GTK_PACK_DIRECTION_RTL))
 534     requisition->width += 2 * horizontal_padding;
 535   else if ((pack_dir == GTK_PACK_DIRECTION_TTB || pack_dir == GTK_PACK_DIRECTION_BTT) &&
 536       (child_pack_dir == GTK_PACK_DIRECTION_TTB || child_pack_dir == GTK_PACK_DIRECTION_BTT))
 537     requisition->height += 2 * horizontal_padding;
 538
 539   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 540     {
 541       GtkRequisition child_requisition;
 542
 543       gtk_widget_size_request (bin->child, &child_requisition);
 544
 545       requisition->width += child_requisition.width;
 546       requisition->height += child_requisition.height;
 547
 548       if (menu_item->submenu && menu_item->show_submenu_indicator)
 549         {
 550           guint arrow_spacing;
 551
 552           gtk_widget_style_get (widget,
 553                                 "arrow-spacing", &arrow_spacing,
 554                                 NULL);
 555
 556           requisition->width += child_requisition.height;
 557           requisition->width += arrow_spacing;
 558
 559           requisition->width = MAX (requisition->width, get_minimum_width (widget));
 560         }
 561     }
 562   else
 563     {
 564       /* separator item */
 565       requisition->height += 4;
 566     }
 567
 568   accel_width = 0;
 569   gtk_container_foreach (GTK_CONTAINER (menu_item),
 570                          gtk_menu_item_accel_width_foreach,
 571                          &accel_width);
 572   menu_item->accelerator_width = accel_width;
 573 }
 574
 575 static void
 576 gtk_menu_item_size_allocate (GtkWidget     *widget,
 577                              GtkAllocation *allocation)
 578 {
 579   GtkMenuItem *menu_item;
 580   GtkBin *bin;
 581   GtkAllocation child_allocation;
 582   GtkTextDirection direction;
 583   GtkPackDirection pack_dir;
 584   GtkPackDirection child_pack_dir;
 585
 586   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 587   g_return_if_fail (allocation != NULL);
 588
 589   menu_item = GTK_MENU_ITEM (widget);
 590   bin = GTK_BIN (widget);
 591
 592   direction = gtk_widget_get_direction (widget);
 593
 594   if (GTK_IS_MENU_BAR (widget->parent))
 595     {
 596       pack_dir = gtk_menu_bar_get_pack_direction (GTK_MENU_BAR (widget->parent));
 597       child_pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (widget->parent));
 598     }
 599   else
 600     {
 601       pack_dir = GTK_PACK_DIRECTION_LTR;
 602       child_pack_dir = GTK_PACK_DIRECTION_LTR;
 603     }
 604
 605   widget->allocation = *allocation;
 606
 607   if (bin->child)
 608     {
 609       GtkRequisition child_requisition;
 610       guint horizontal_padding;
 611
 612       gtk_widget_style_get (widget,
 613                             "horizontal-padding", &horizontal_padding,
 614                             NULL);
 615
 616       child_allocation.x = GTK_CONTAINER (widget)->border_width + widget->style->xthickness;
 617       child_allocation.y = GTK_CONTAINER (widget)->border_width + widget->style->ythickness;
 618
 619       if ((pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL) &&
 620           (child_pack_dir == GTK_PACK_DIRECTION_LTR || child_pack_dir == GTK_PACK_DIRECTION_RTL))
 621         child_allocation.x += horizontal_padding;
 622       else if ((pack_dir == GTK_PACK_DIRECTION_TTB || pack_dir == GTK_PACK_DIRECTION_BTT) &&
 623                (child_pack_dir == GTK_PACK_DIRECTION_TTB || child_pack_dir == GTK_PACK_DIRECTION_BTT))
 624         child_allocation.y += horizontal_padding;
 625
 626       child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
 627       child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
 628
 629       if (child_pack_dir == GTK_PACK_DIRECTION_LTR ||
 630           child_pack_dir == GTK_PACK_DIRECTION_RTL)
 631         {
 632           if ((direction == GTK_TEXT_DIR_LTR) == (child_pack_dir != GTK_PACK_DIRECTION_RTL))
 633             child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
 634           child_allocation.width -= GTK_MENU_ITEM (widget)->toggle_size;
 635         }
 636       else
 637         {
 638           if ((direction == GTK_TEXT_DIR_LTR) == (child_pack_dir != GTK_PACK_DIRECTION_BTT))
 639             child_allocation.y += GTK_MENU_ITEM (widget)->toggle_size;
 640           child_allocation.height -= GTK_MENU_ITEM (widget)->toggle_size;
 641         }
 642
 643       child_allocation.x += widget->allocation.x;
 644       child_allocation.y += widget->allocation.y;
 645
 646       gtk_widget_get_child_requisition (bin->child, &child_requisition);
 647       if (menu_item->submenu && menu_item->show_submenu_indicator)
 648         {
 649           if (direction == GTK_TEXT_DIR_RTL)
 650             child_allocation.x += child_requisition.height;
 651           child_allocation.width -= child_requisition.height;
 652         }
 653
 654       if (child_allocation.width < 1)
 655         child_allocation.width = 1;
 656
 657       gtk_widget_size_allocate (bin->child, &child_allocation);
 658     }
 659
 660   if (GTK_WIDGET_REALIZED (widget))
 661     gdk_window_move_resize (menu_item->event_window,
 662                             allocation->x, allocation->y,
 663                             allocation->width, allocation->height);
 664
 665   if (menu_item->submenu)
 666     gtk_menu_reposition (GTK_MENU (menu_item->submenu));
 667 }
 668
 669 static void
 670 gtk_menu_item_realize (GtkWidget *widget)
 671 {
 672   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
 673   GdkWindowAttr attributes;
 674   gint attributes_mask;
 675
 676   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 677
 678   widget->window = gtk_widget_get_parent_window (widget);
 679   g_object_ref (widget->window);
 680
 681   attributes.x = widget->allocation.x;
 682   attributes.y = widget->allocation.y;
 683   attributes.width = widget->allocation.width;
 684   attributes.height = widget->allocation.height;
 685   attributes.window_type = GDK_WINDOW_CHILD;
 686   attributes.wclass = GDK_INPUT_ONLY;
 687   attributes.event_mask = (gtk_widget_get_events (widget) |
 688                            GDK_BUTTON_PRESS_MASK |
 689                            GDK_BUTTON_RELEASE_MASK |
 690                            GDK_ENTER_NOTIFY_MASK |
 691                            GDK_LEAVE_NOTIFY_MASK |
 692                            GDK_POINTER_MOTION_MASK);
 693
 694   attributes_mask = GDK_WA_X | GDK_WA_Y;
 695   menu_item->event_window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
 696   gdk_window_set_user_data (menu_item->event_window, widget);
 697
 698   widget->style = gtk_style_attach (widget->style, widget->window);
 699 }
 700
 701 static void
 702 gtk_menu_item_unrealize (GtkWidget *widget)
 703 {
 704   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
 705
 706   gdk_window_set_user_data (menu_item->event_window, NULL);
 707   gdk_window_destroy (menu_item->event_window);
 708   menu_item->event_window = NULL;
 709
 710   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 711     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 712 }
 713
 714 static void
 715 gtk_menu_item_map (GtkWidget *widget)
 716 {
 717   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
 718
 719   GTK_WIDGET_CLASS (parent_class)->map (widget);
 720
 721   gdk_window_show (menu_item->event_window);
 722 }
 723
 724 static void
 725 gtk_menu_item_unmap (GtkWidget *widget)
 726 {
 727   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
 728
 729   gdk_window_hide (menu_item->event_window);
 730
 731   GTK_WIDGET_CLASS (parent_class)->unmap (widget);
 732 }
 733
 734 static void
 735 gtk_menu_item_paint (GtkWidget    *widget,
 736                      GdkRectangle *area)
 737 {
 738   GtkMenuItem *menu_item;
 739   GtkStateType state_type;
 740   GtkShadowType shadow_type, selected_shadow_type;
 741   gint width, height;
 742   gint x, y;
 743   gint border_width = GTK_CONTAINER (widget)->border_width;
 744
 745   if (GTK_WIDGET_DRAWABLE (widget))
 746     {
 747       menu_item = GTK_MENU_ITEM (widget);
 748
 749       state_type = widget->state;
 750
 751       x = widget->allocation.x + border_width;
 752       y = widget->allocation.y + border_width;
 753       width = widget->allocation.width - border_width * 2;
 754       height = widget->allocation.height - border_width * 2;
 755
 756       if ((state_type == GTK_STATE_PRELIGHT) &&
 757           (GTK_BIN (menu_item)->child))
 758         {
 759           gtk_widget_style_get (widget,
 760                                 "selected-shadow-type", &selected_shadow_type,
 761                                 NULL);
 762           gtk_paint_box (widget->style,
 763                          widget->window,
 764                          GTK_STATE_PRELIGHT,
 765                          selected_shadow_type,
 766                          area, widget, "menuitem",
 767                          x, y, width, height);
 768         }
 769
 770       if (menu_item->submenu && menu_item->show_submenu_indicator)
 771         {
 772           gint arrow_x, arrow_y;
 773           gint arrow_size;
 774           gint arrow_extent;
 775           guint horizontal_padding;
 776           GtkTextDirection direction;
 777           GtkArrowType arrow_type;
 778           PangoContext *context;
 779           PangoFontMetrics *metrics;
 780           gint ascent, descent;
 781
 782           direction = gtk_widget_get_direction (widget);
 783
 784           gtk_widget_style_get (widget,
 785                                 "horizontal-padding", &horizontal_padding,
 786                                 NULL);
 787
 788           context = gtk_widget_get_pango_context (GTK_BIN (menu_item)->child);
 789           metrics = pango_context_get_metrics (context,
 790                                                GTK_WIDGET (GTK_BIN (menu_item)->child)->style->font_desc,
 791                                                pango_context_get_language (context));
 792
 793           ascent = pango_font_metrics_get_ascent (metrics);
 794           descent = pango_font_metrics_get_descent (metrics);
 795           pango_font_metrics_unref (metrics);
 796
 797           arrow_size = PANGO_PIXELS (ascent + descent) - 2 * widget->style->ythickness;
 798
 799           arrow_extent = arrow_size * 0.8;
 800
 801           shadow_type = GTK_SHADOW_OUT;
 802           if (state_type == GTK_STATE_PRELIGHT)
 803             shadow_type = GTK_SHADOW_IN;
 804
 805           if (direction == GTK_TEXT_DIR_LTR)
 806             {
 807               arrow_x = x + width - horizontal_padding - arrow_extent;
 808               arrow_type = GTK_ARROW_RIGHT;
 809             }
 810           else
 811             {
 812               arrow_x = x + horizontal_padding;
 813               arrow_type = GTK_ARROW_LEFT;
 814             }
 815
 816           arrow_y = y + (height - arrow_extent) / 2;
 817
 818           gtk_paint_arrow (widget->style, widget->window,
 819                            state_type, shadow_type,
 820                            area, widget, "menuitem",
 821                            arrow_type, TRUE,
 822                            arrow_x, arrow_y,
 823                            arrow_extent, arrow_extent);
 824         }
 825       else if (!GTK_BIN (menu_item)->child)
 826         {
 827           guint horizontal_padding;
 828
 829           gtk_widget_style_get (widget,
 830                                 "horizontal-padding", &horizontal_padding,
 831                                 NULL);
 832
 833           gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
 834                            area, widget, "menuitem",
 835                            widget->allocation.x + horizontal_padding + widget->style->xthickness,
 836                            widget->allocation.x + widget->allocation.width - horizontal_padding - widget->style->xthickness - 1,
 837                            widget->allocation.y + (widget->allocation.height -
 838                                                    widget->style->ythickness) / 2);
 839         }
 840     }
 841 }
 842
 843 static gint
 844 gtk_menu_item_expose (GtkWidget      *widget,
 845                       GdkEventExpose *event)
 846 {
 847   g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
 848   g_return_val_if_fail (event != NULL, FALSE);
 849
 850   if (GTK_WIDGET_DRAWABLE (widget))
 851     {
 852       gtk_menu_item_paint (widget, &event->area);
 853
 854       (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
 855     }
 856
 857   return FALSE;
 858 }
 859
 860 static gint
 861 get_popup_delay (GtkMenuItem *menu_item)
 862 {
 863   GtkWidget *parent = GTK_WIDGET (menu_item)->parent;
 864
 865   if (GTK_IS_MENU_SHELL (parent))
 866     {
 867       return _gtk_menu_shell_get_popup_delay (GTK_MENU_SHELL (parent));
 868     }
 869   else
 870     {
 871       gint popup_delay;
 872
 873       g_object_get (gtk_widget_get_settings (GTK_WIDGET (menu_item)),
 874                     "gtk-menu-popup-delay", &popup_delay,
 875                     NULL);
 876
 877       return popup_delay;
 878     }
 879 }
 880
 881 static void
 882 gtk_real_menu_item_select (GtkItem *item)
 883 {
 884   GtkMenuItem *menu_item;
 885
 886   g_return_if_fail (GTK_IS_MENU_ITEM (item));
 887
 888   menu_item = GTK_MENU_ITEM (item);
 889
 890   if (menu_item->submenu &&
 891       (!GTK_WIDGET_MAPPED (menu_item->submenu) ||
 892        GTK_MENU (menu_item->submenu)->tearoff_active))
 893     {
 894       gint popup_delay;
 895
 896       if (menu_item->timer)
 897         {
 898           g_source_remove (menu_item->timer);
 899           menu_item->timer = 0;
 900           popup_delay = 0;
 901         }
 902       else
 903         popup_delay = get_popup_delay (menu_item);
 904
 905       if (popup_delay > 0)
 906         {
 907           GdkEvent *event = gtk_get_current_event ();
 908
 909           menu_item->timer = g_timeout_add (popup_delay,
 910                                             gtk_menu_item_select_timeout,
 911                                             menu_item);
 912           if (event &&
 913               event->type != GDK_BUTTON_PRESS &&
 914               event->type != GDK_ENTER_NOTIFY)
 915             menu_item->timer_from_keypress = TRUE;
 916           else
 917             menu_item->timer_from_keypress = FALSE;
 918
 919           if (event)
 920             gdk_event_free (event);
 921         }
 922       else
 923         _gtk_menu_item_popup_submenu (GTK_WIDGET (menu_item));
 924     }
 925
 926   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_PRELIGHT);
 927   gtk_widget_queue_draw (GTK_WIDGET (menu_item));
 928 }
 929
 930 static void
 931 gtk_real_menu_item_deselect (GtkItem *item)
 932 {
 933   GtkMenuItem *menu_item;
 934
 935   g_return_if_fail (GTK_IS_MENU_ITEM (item));
 936
 937   menu_item = GTK_MENU_ITEM (item);
 938
 939   if (menu_item->submenu)
 940     {
 941       if (menu_item->timer)
 942         {
 943           g_source_remove (menu_item->timer);
 944           menu_item->timer = 0;
 945         }
 946       else
 947         gtk_menu_popdown (GTK_MENU (menu_item->submenu));
 948     }
 949
 950   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_NORMAL);
 951   gtk_widget_queue_draw (GTK_WIDGET (menu_item));
 952 }
 953
 954 static gboolean
 955 gtk_menu_item_mnemonic_activate (GtkWidget *widget,
 956                                  gboolean   group_cycling)
 957 {
 958   if (group_cycling &&
 959       widget->parent &&
 960       GTK_IS_MENU_SHELL (widget->parent) &&
 961       GTK_MENU_SHELL (widget->parent)->active)
 962     {
 963       gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent),
 964                                   widget);
 965     }
 966   else
 967     g_signal_emit (widget, menu_item_signals[ACTIVATE_ITEM], 0);
 968
 969   return TRUE;
 970 }
 971
 972
 973 static void
 974 gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
 975 {
 976   GtkWidget *widget;
 977   GtkMenuShell *submenu;
 978
 979   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 980
 981   widget = GTK_WIDGET (menu_item);
 982
 983   if (widget->parent &&
 984       GTK_IS_MENU_SHELL (widget->parent))
 985     {
 986       if (menu_item->submenu == NULL)
 987         gtk_menu_shell_activate_item (GTK_MENU_SHELL (widget->parent),
 988                                       widget, TRUE);
 989       else
 990         {
 991           GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget->parent);
 992
 993           _gtk_menu_shell_activate (menu_shell);
 994
 995           gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent), widget);
 996           _gtk_menu_item_popup_submenu (widget);
 997
 998           gtk_menu_shell_select_first (GTK_MENU_SHELL (menu_item->submenu), TRUE);
 999           submenu = GTK_MENU_SHELL (menu_item->submenu);
1000         }
1001     }
1002 }
1003 static void
1004 gtk_real_menu_item_toggle_size_request (GtkMenuItem *menu_item,
1005                                         gint        *requisition)
1006 {
1007   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1008
1009   *requisition = 0;
1010 }
1011
1012 static void
1013 gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
1014                                          gint         allocation)
1015 {
1016   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1017
1018   menu_item->toggle_size = allocation;
1019 }
1020
1021 static gint
1022 gtk_menu_item_select_timeout (gpointer data)
1023 {
1024   GtkMenuItem *menu_item;
1025   GtkWidget *parent;
1026
1027   GDK_THREADS_ENTER ();
1028
1029   menu_item = GTK_MENU_ITEM (data);
1030
1031   parent = GTK_WIDGET (menu_item)->parent;
1032
1033   if ((GTK_IS_MENU_SHELL (parent) && GTK_MENU_SHELL (parent)->active) ||
1034       (GTK_IS_MENU (parent) && GTK_MENU (parent)->torn_off))
1035     {
1036       _gtk_menu_item_popup_submenu (GTK_WIDGET (menu_item));
1037       if (menu_item->timer_from_keypress && menu_item->submenu)
1038         GTK_MENU_SHELL (menu_item->submenu)->ignore_enter = TRUE;
1039     }
1040
1041   GDK_THREADS_LEAVE ();
1042
1043   return FALSE;
1044 }
1045
1046 void
1047 _gtk_menu_item_popup_submenu (GtkWidget *widget)
1048 {
1049   GtkMenuItem *menu_item;
1050
1051   menu_item = GTK_MENU_ITEM (widget);
1052
1053   if (menu_item->timer)
1054     g_source_remove (menu_item->timer);
1055   menu_item->timer = 0;
1056
1057   if (GTK_WIDGET_IS_SENSITIVE (menu_item->submenu))
1058     {
1059       gboolean take_focus;
1060
1061       take_focus = gtk_menu_shell_get_take_focus (GTK_MENU_SHELL (widget->parent));
1062       gtk_menu_shell_set_take_focus (GTK_MENU_SHELL (menu_item->submenu),
1063                                      take_focus);
1064
1065       gtk_menu_popup (GTK_MENU (menu_item->submenu),
1066                       widget->parent,
1067                       widget,
1068                       gtk_menu_item_position_menu,
1069                       menu_item,
1070                       GTK_MENU_SHELL (widget->parent)->button,
1071                       0);
1072     }
1073 }
1074
1075 static void
1076 get_offsets (GtkMenu *menu,
1077              gint    *horizontal_offset,
1078              gint    *vertical_offset)
1079 {
1080   gint vertical_padding;
1081
1082   gtk_widget_style_get (GTK_WIDGET (menu),
1083                         "horizontal-offset", horizontal_offset,
1084                         "vertical-offset", vertical_offset,
1085                         "vertical-padding", &vertical_padding,
1086                         NULL);
1087
1088   *vertical_offset -= GTK_WIDGET (menu)->style->ythickness;
1089   *vertical_offset -= vertical_padding;
1090 }
1091
1092 static void
1093 gtk_menu_item_position_menu (GtkMenu  *menu,
1094                              gint     *x,
1095                              gint     *y,
1096                              gboolean *push_in,
1097                              gpointer  user_data)
1098 {
1099   GtkMenuItem *menu_item;
1100   GtkWidget *widget;
1101   GtkWidget *parent_menu_item;
1102   GdkScreen *screen;
1103   gint twidth, theight;
1104   gint tx, ty;
1105   GtkTextDirection direction;
1106   GdkRectangle monitor;
1107   gint monitor_num;
1108   gint horizontal_offset;
1109   gint vertical_offset;
1110   gint parent_xthickness;
1111
1112   g_return_if_fail (menu != NULL);
1113   g_return_if_fail (x != NULL);
1114   g_return_if_fail (y != NULL);
1115
1116   menu_item = GTK_MENU_ITEM (user_data);
1117   widget = GTK_WIDGET (user_data);
1118
1119   if (push_in)
1120     *push_in = FALSE;
1121
1122   direction = gtk_widget_get_direction (widget);
1123
1124   twidth = GTK_WIDGET (menu)->requisition.width;
1125   theight = GTK_WIDGET (menu)->requisition.height;
1126
1127   screen = gtk_widget_get_screen (GTK_WIDGET (menu));
1128   monitor_num = gdk_screen_get_monitor_at_window (screen, menu_item->event_window);
1129   if (monitor_num < 0)
1130     monitor_num = 0;
1131   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
1132
1133   if (!gdk_window_get_origin (widget->window, &tx, &ty))
1134     {
1135       g_warning ("Menu not on screen");
1136       return;
1137     }
1138
1139   tx += widget->allocation.x;
1140   ty += widget->allocation.y;
1141
1142   get_offsets (menu, &horizontal_offset, &vertical_offset);
1143
1144   switch (menu_item->submenu_placement)
1145     {
1146     case GTK_TOP_BOTTOM:
1147       if (direction == GTK_TEXT_DIR_LTR)
1148         menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
1149       else
1150         {
1151           menu_item->submenu_direction = GTK_DIRECTION_LEFT;
1152           tx += widget->allocation.width - twidth;
1153         }
1154
1155       if ((ty + widget->allocation.height + theight) <= monitor.y + monitor.height)
1156         ty += widget->allocation.height;
1157       else if ((ty - theight) >= monitor.y)
1158         ty -= theight;
1159       else if (monitor.y + monitor.height - (ty + widget->allocation.height) > ty)
1160         ty += widget->allocation.height;
1161       else
1162         ty -= theight;
1163       break;
1164
1165     case GTK_LEFT_RIGHT:
1166       if (GTK_IS_MENU (widget->parent))
1167         parent_menu_item = GTK_MENU (widget->parent)->parent_menu_item;
1168       else
1169         parent_menu_item = NULL;
1170       parent_xthickness = widget->parent->style->xthickness;
1171       if (parent_menu_item && !GTK_MENU (widget->parent)->torn_off)
1172         menu_item->submenu_direction = GTK_MENU_ITEM (parent_menu_item)->submenu_direction;
1173       else if (direction == GTK_TEXT_DIR_LTR)
1174         menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
1175       else
1176         menu_item->submenu_direction = GTK_DIRECTION_LEFT;
1177
1178       switch (menu_item->submenu_direction)
1179         {
1180         case GTK_DIRECTION_LEFT:
1181           if ((tx - twidth - parent_xthickness - horizontal_offset) >= monitor.x)
1182             tx -= twidth + parent_xthickness + horizontal_offset;
1183           else
1184             {
1185               menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
1186               tx += widget->allocation.width + parent_xthickness + horizontal_offset;
1187             }
1188           break;
1189
1190         case GTK_DIRECTION_RIGHT:
1191           if ((tx + widget->allocation.width + parent_xthickness + horizontal_offset + twidth) <= monitor.x + monitor.width)
1192             tx += widget->allocation.width + parent_xthickness + horizontal_offset;
1193           else
1194             {
1195               menu_item->submenu_direction = GTK_DIRECTION_LEFT;
1196               tx -= twidth + parent_xthickness + horizontal_offset;
1197             }
1198           break;
1199         }
1200
1201       ty += vertical_offset;
1202
1203       /* If the height of the menu doesn't fit we move it upward. */
1204       ty = CLAMP (ty, monitor.y, MAX (monitor.y, monitor.y + monitor.height - theight));
1205       break;
1206     }
1207
1208   /* If we have negative, tx, here it is because we can't get
1209    * the menu all the way on screen. Favor the left portion.
1210    */
1211   *x = CLAMP (tx, monitor.x, MAX (monitor.x, monitor.x + monitor.width - twidth));
1212   *y = ty;
1213
1214   gtk_menu_set_monitor (menu, monitor_num);
1215 }
1216
1217 /**
1218  * gtk_menu_item_set_right_justified:
1219  * @menu_item: a #GtkMenuItem.
1220  * @right_justified: if %TRUE the menu item will appear at the
1221  *   far right if added to a menu bar.
1222  *
1223  * Sets whether the menu item appears justified at the right
1224  * side of a menu bar. This was traditionally done for "Help" menu
1225  * items, but is now considered a bad idea. (If the widget
1226  * layout is reversed for a right-to-left language like Hebrew
1227  * or Arabic, right-justified-menu-items appear at the left.)
1228  **/
1229 void
1230 gtk_menu_item_set_right_justified (GtkMenuItem *menu_item,
1231                                    gboolean     right_justified)
1232 {
1233   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1234
1235   right_justified = right_justified != FALSE;
1236
1237   if (right_justified != menu_item->right_justify)
1238     {
1239       menu_item->right_justify = right_justified;
1240       gtk_widget_queue_resize (GTK_WIDGET (menu_item));
1241     }
1242 }
1243
1244 /**
1245  * gtk_menu_item_get_right_justified:
1246  * @menu_item: a #GtkMenuItem
1247  *
1248  * Gets whether the menu item appears justified at the right
1249  * side of the menu bar.
1250  *
1251  * Return value: %TRUE if the menu item will appear at the
1252  *   far right if added to a menu bar.
1253  **/
1254 gboolean
1255 gtk_menu_item_get_right_justified (GtkMenuItem *menu_item)
1256 {
1257   g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), FALSE);
1258
1259   return menu_item->right_justify;
1260 }
1261
1262
1263 static void
1264 gtk_menu_item_show_all (GtkWidget *widget)
1265 {
1266   GtkMenuItem *menu_item;
1267
1268   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
1269
1270   menu_item = GTK_MENU_ITEM (widget);
1271
1272   /* show children including submenu */
1273   if (menu_item->submenu)
1274     gtk_widget_show_all (menu_item->submenu);
1275   gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);
1276
1277   gtk_widget_show (widget);
1278 }
1279
1280 static void
1281 gtk_menu_item_hide_all (GtkWidget *widget)
1282 {
1283   GtkMenuItem *menu_item;
1284
1285   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
1286
1287   gtk_widget_hide (widget);
1288
1289   menu_item = GTK_MENU_ITEM (widget);
1290
1291   /* hide children including submenu */
1292   gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
1293   if (menu_item->submenu)
1294     gtk_widget_hide_all (menu_item->submenu);
1295 }
1296
1297 static gboolean
1298 gtk_menu_item_can_activate_accel (GtkWidget *widget,
1299                                   guint      signal_id)
1300 {
1301   /* Chain to the parent GtkMenu for further checks */
1302   return (GTK_WIDGET_IS_SENSITIVE (widget) && GTK_WIDGET_VISIBLE (widget) &&
1303           widget->parent && gtk_widget_can_activate_accel (widget->parent, signal_id));
1304 }
1305
1306 static void
1307 gtk_menu_item_accel_name_foreach (GtkWidget *widget,
1308                                   gpointer data)
1309 {
1310   const gchar **path_p = data;
1311
1312   if (!*path_p)
1313     {
1314       if (GTK_IS_LABEL (widget))
1315         {
1316           *path_p = gtk_label_get_text (GTK_LABEL (widget));
1317           if (*path_p && (*path_p)[0] == 0)
1318             *path_p = NULL;
1319         }
1320       else if (GTK_IS_CONTAINER (widget))
1321         gtk_container_foreach (GTK_CONTAINER (widget),
1322                                gtk_menu_item_accel_name_foreach,
1323                                data);
1324     }
1325 }
1326
1327 static void
1328 gtk_menu_item_parent_set (GtkWidget *widget,
1329                           GtkWidget *previous_parent)
1330 {
1331   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
1332   GtkMenu *menu = GTK_IS_MENU (widget->parent) ? GTK_MENU (widget->parent) : NULL;
1333
1334   if (menu)
1335     _gtk_menu_item_refresh_accel_path (menu_item,
1336                                        menu->accel_path,
1337                                        menu->accel_group,
1338                                        TRUE);
1339
1340   if (GTK_WIDGET_CLASS (parent_class)->parent_set)
1341     GTK_WIDGET_CLASS (parent_class)->parent_set (widget, previous_parent);
1342 }
1343
1344 void
1345 _gtk_menu_item_refresh_accel_path (GtkMenuItem   *menu_item,
1346                                    const gchar   *prefix,
1347                                    GtkAccelGroup *accel_group,
1348                                    gboolean       group_changed)
1349 {
1350   const gchar *path;
1351   GtkWidget *widget;
1352
1353   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1354   g_return_if_fail (!accel_group || GTK_IS_ACCEL_GROUP (accel_group));
1355
1356   widget = GTK_WIDGET (menu_item);
1357
1358   if (!accel_group)
1359     {
1360       gtk_widget_set_accel_path (widget, NULL, NULL);
1361       return;
1362     }
1363
1364   path = _gtk_widget_get_accel_path (widget, NULL);
1365   if (!path)                                    /* no active accel_path yet */
1366     {
1367       path = menu_item->accel_path;
1368       if (!path && prefix)
1369         {
1370           gchar *postfix = NULL;
1371
1372           /* try to construct one from label text */
1373           gtk_container_foreach (GTK_CONTAINER (menu_item),
1374                                  gtk_menu_item_accel_name_foreach,
1375                                  &postfix);
1376           menu_item->accel_path = postfix ? g_strconcat (prefix, "/", postfix, NULL) : NULL;
1377           path = menu_item->accel_path;
1378         }
1379       if (path)
1380         gtk_widget_set_accel_path (widget, path, accel_group);
1381     }
1382   else if (group_changed)                       /* reinstall accelerators */
1383     gtk_widget_set_accel_path (widget, path, accel_group);
1384 }
1385
1386 /**
1387  * gtk_menu_item_set_accel_path
1388  * @menu_item:  a valid #GtkMenuItem
1389  * @accel_path: accelerator path, corresponding to this menu item's
1390  *              functionality, or %NULL to unset the current path.
1391  *
1392  * Set the accelerator path on @menu_item, through which runtime changes of the
1393  * menu item's accelerator caused by the user can be identified and saved to
1394  * persistant storage (see gtk_accel_map_save() on this).
1395  * To setup a default accelerator for this menu item, call
1396  * gtk_accel_map_add_entry() with the same @accel_path.
1397  * See also gtk_accel_map_add_entry() on the specifics of accelerator paths,
1398  * and gtk_menu_set_accel_path() for a more convenient variant of this function.
1399  *
1400  * This function is basically a convenience wrapper that handles calling
1401  * gtk_widget_set_accel_path() with the appropriate accelerator group for
1402  * the menu item.
1403  *
1404  * Note that you do need to set an accelerator on the parent menu with
1405  * gtk_menu_set_accel_group() for this to work.
1406  */
1407 void
1408 gtk_menu_item_set_accel_path (GtkMenuItem *menu_item,
1409                               const gchar *accel_path)
1410 {
1411   GtkWidget *widget;
1412
1413   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1414   g_return_if_fail (accel_path == NULL ||
1415                     (accel_path[0] == '<' && strchr (accel_path, '/')));
1416
1417   widget = GTK_WIDGET (menu_item);
1418
1419   /* store new path */
1420   g_free (menu_item->accel_path);
1421   menu_item->accel_path = g_strdup (accel_path);
1422
1423   /* forget accelerators associated with old path */
1424   gtk_widget_set_accel_path (widget, NULL, NULL);
1425
1426   /* install accelerators associated with new path */
1427   if (widget->parent && GTK_IS_MENU (widget->parent))
1428     {
1429       GtkMenu *menu = GTK_MENU (widget->parent);
1430
1431       if (menu->accel_group)
1432         _gtk_menu_item_refresh_accel_path (GTK_MENU_ITEM (widget),
1433                                            NULL,
1434                                            menu->accel_group,
1435                                            FALSE);
1436     }
1437 }
1438
1439 static void
1440 gtk_menu_item_forall (GtkContainer *container,
1441                       gboolean      include_internals,
1442                       GtkCallback   callback,
1443                       gpointer      callback_data)
1444 {
1445   GtkBin *bin;
1446   GtkMenuItem *menu_item;
1447
1448   g_return_if_fail (GTK_IS_MENU_ITEM (container));
1449   g_return_if_fail (callback != NULL);
1450
1451   bin = GTK_BIN (container);
1452   menu_item = GTK_MENU_ITEM (container);
1453
1454   if (bin->child)
1455     callback (bin->child, callback_data);
1456 }
1457
1458 gboolean
1459 _gtk_menu_item_is_selectable (GtkWidget *menu_item)
1460 {
1461   if ((!GTK_BIN (menu_item)->child &&
1462        G_OBJECT_TYPE (menu_item) == GTK_TYPE_MENU_ITEM) ||
1463       GTK_IS_SEPARATOR_MENU_ITEM (menu_item) ||
1464       !GTK_WIDGET_IS_SENSITIVE (menu_item) ||
1465       !GTK_WIDGET_VISIBLE (menu_item))
1466     return FALSE;
1467
1468   return TRUE;
1469 }
1470
1471 #define __GTK_MENU_ITEM_C__
1472 #include "gtkaliasdef.c"