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 <string.h>
  30 #include "gtkaccellabel.h"
  31 #include "gtkmain.h"
  32 #include "gtkmarshalers.h"
  33 #include "gtkmenu.h"
  34 #include "gtkmenubar.h"
  35 #include "gtkmenuitem.h"
  36 #include "gtkseparatormenuitem.h"
  37 #include "gtksignal.h"
  38
  39
  40 #define BORDER_SPACING  3
  41 #define SELECT_TIMEOUT  75
  42
  43 #define MENU_ITEM_CLASS(w)  GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
  44
  45
  46 enum {
  47   ACTIVATE,
  48   ACTIVATE_ITEM,
  49   TOGGLE_SIZE_REQUEST,
  50   TOGGLE_SIZE_ALLOCATE,
  51   LAST_SIGNAL
  52 };
  53
  54
  55 static void gtk_menu_item_class_init     (GtkMenuItemClass *klass);
  56 static void gtk_menu_item_init           (GtkMenuItem      *menu_item);
  57 static void gtk_menu_item_destroy        (GtkObject        *object);
  58 static void gtk_menu_item_finalize       (GObject          *object);
  59 static void gtk_menu_item_size_request   (GtkWidget        *widget,
  60                                           GtkRequisition   *requisition);
  61 static void gtk_menu_item_size_allocate  (GtkWidget        *widget,
  62                                           GtkAllocation    *allocation);
  63 static void gtk_menu_item_realize        (GtkWidget        *widget);
  64 static void gtk_menu_item_unrealize      (GtkWidget        *widget);
  65 static void gtk_menu_item_map            (GtkWidget        *widget);
  66 static void gtk_menu_item_unmap          (GtkWidget        *widget);
  67 static void gtk_menu_item_paint          (GtkWidget        *widget,
  68                                           GdkRectangle     *area);
  69 static gint gtk_menu_item_expose         (GtkWidget        *widget,
  70                                           GdkEventExpose   *event);
  71 static void gtk_menu_item_parent_set     (GtkWidget        *widget,
  72                                           GtkWidget        *previous_parent);
  73
  74
  75 static void gtk_real_menu_item_select               (GtkItem     *item);
  76 static void gtk_real_menu_item_deselect             (GtkItem     *item);
  77 static void gtk_real_menu_item_activate_item        (GtkMenuItem *item);
  78 static void gtk_real_menu_item_toggle_size_request  (GtkMenuItem *menu_item,
  79                                                      gint        *requisition);
  80 static void gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
  81                                                      gint         allocation);
  82 static gboolean gtk_menu_item_mnemonic_activate     (GtkWidget   *widget,
  83                                                      gboolean     group_cycling);
  84
  85 static gint gtk_menu_item_select_timeout (gpointer          data);
  86 static void gtk_menu_item_popup_submenu  (gpointer     data);
  87 static void gtk_menu_item_position_menu  (GtkMenu          *menu,
  88                                           gint             *x,
  89                                           gint             *y,
  90                                           gboolean         *push_in,
  91                                           gpointer          user_data);
  92 static void gtk_menu_item_show_all       (GtkWidget        *widget);
  93 static void gtk_menu_item_hide_all       (GtkWidget        *widget);
  94 static void gtk_menu_item_forall         (GtkContainer    *container,
  95                                           gboolean         include_internals,
  96                                           GtkCallback      callback,
  97                                           gpointer         callback_data);
  98
  99
 100 static GtkItemClass *parent_class;
 101 static guint menu_item_signals[LAST_SIGNAL] = { 0 };
 102 static guint32  last_submenu_deselect_time = 0;
 103
 104
 105
 106 GtkType
 107 gtk_menu_item_get_type (void)
 108 {
 109   static GtkType menu_item_type = 0;
 110
 111   if (!menu_item_type)
 112     {
 113       static const GTypeInfo menu_item_info =
 114       {
 115         sizeof (GtkMenuItemClass),
 116         NULL,           /* base_init */
 117         NULL,           /* base_finalize */
 118         (GClassInitFunc) gtk_menu_item_class_init,
 119         NULL,           /* class_finalize */
 120         NULL,           /* class_data */
 121         sizeof (GtkMenuItem),
 122         16,             /* n_preallocs */
 123         (GInstanceInitFunc) gtk_menu_item_init,
 124       };
 125
 126       menu_item_type = g_type_register_static (GTK_TYPE_ITEM, "GtkMenuItem", &menu_item_info, 0);
 127     }
 128
 129   return menu_item_type;
 130 }
 131
 132 static void
 133 gtk_menu_item_class_init (GtkMenuItemClass *klass)
 134 {
 135   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 136   GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
 137   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 138   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 139   GtkItemClass *item_class = GTK_ITEM_CLASS (klass);
 140
 141   parent_class = g_type_class_peek_parent (klass);
 142
 143   gobject_class->finalize = gtk_menu_item_finalize;
 144
 145   object_class->destroy = gtk_menu_item_destroy;
 146
 147   widget_class->size_request = gtk_menu_item_size_request;
 148   widget_class->size_allocate = gtk_menu_item_size_allocate;
 149   widget_class->expose_event = gtk_menu_item_expose;
 150   widget_class->realize = gtk_menu_item_realize;
 151   widget_class->unrealize = gtk_menu_item_unrealize;
 152   widget_class->map = gtk_menu_item_map;
 153   widget_class->unmap = gtk_menu_item_unmap;
 154   widget_class->show_all = gtk_menu_item_show_all;
 155   widget_class->hide_all = gtk_menu_item_hide_all;
 156   widget_class->mnemonic_activate = gtk_menu_item_mnemonic_activate;
 157   widget_class->parent_set = gtk_menu_item_parent_set;
 158
 159   container_class->forall = gtk_menu_item_forall;
 160
 161   item_class->select = gtk_real_menu_item_select;
 162   item_class->deselect = gtk_real_menu_item_deselect;
 163
 164   klass->activate = NULL;
 165   klass->activate_item = gtk_real_menu_item_activate_item;
 166   klass->toggle_size_request = gtk_real_menu_item_toggle_size_request;
 167   klass->toggle_size_allocate = gtk_real_menu_item_toggle_size_allocate;
 168
 169   klass->hide_on_activate = TRUE;
 170
 171   menu_item_signals[ACTIVATE] =
 172     gtk_signal_new ("activate",
 173                     GTK_RUN_FIRST | GTK_RUN_ACTION,
 174                     GTK_CLASS_TYPE (object_class),
 175                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate),
 176                     _gtk_marshal_VOID__VOID,
 177                     GTK_TYPE_NONE, 0);
 178   widget_class->activate_signal = menu_item_signals[ACTIVATE];
 179
 180   menu_item_signals[ACTIVATE_ITEM] =
 181     gtk_signal_new ("activate_item",
 182                     GTK_RUN_FIRST,
 183                     GTK_CLASS_TYPE (object_class),
 184                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate_item),
 185                     gtk_signal_default_marshaller,
 186                     GTK_TYPE_NONE, 0);
 187
 188   menu_item_signals[TOGGLE_SIZE_REQUEST] =
 189     gtk_signal_new ("toggle_size_request",
 190                     GTK_RUN_FIRST,
 191                     GTK_CLASS_TYPE (object_class),
 192                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, toggle_size_request),
 193                     _gtk_marshal_VOID__POINTER,
 194                     GTK_TYPE_NONE, 1,
 195                     GTK_TYPE_POINTER);
 196
 197   menu_item_signals[TOGGLE_SIZE_ALLOCATE] =
 198     gtk_signal_new ("toggle_size_allocate",
 199                     GTK_RUN_FIRST,
 200                     GTK_CLASS_TYPE (object_class),
 201                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, toggle_size_allocate),
 202                     _gtk_marshal_NONE__INT,
 203                     GTK_TYPE_NONE, 1,
 204                     GTK_TYPE_INT);
 205 }
 206
 207 static void
 208 gtk_menu_item_init (GtkMenuItem *menu_item)
 209 {
 210   GTK_WIDGET_SET_FLAGS (menu_item, GTK_NO_WINDOW);
 211
 212   menu_item->submenu = NULL;
 213   menu_item->toggle_size = 0;
 214   menu_item->accelerator_width = 0;
 215   menu_item->show_submenu_indicator = FALSE;
 216   menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 217   menu_item->submenu_placement = GTK_TOP_BOTTOM;
 218   menu_item->right_justify = FALSE;
 219
 220   menu_item->timer = 0;
 221 }
 222
 223 GtkWidget*
 224 gtk_menu_item_new (void)
 225 {
 226   return GTK_WIDGET (gtk_type_new (gtk_menu_item_get_type ()));
 227 }
 228
 229 GtkWidget*
 230 gtk_menu_item_new_with_label (const gchar *label)
 231 {
 232   GtkWidget *menu_item;
 233   GtkWidget *accel_label;
 234
 235   menu_item = gtk_menu_item_new ();
 236   accel_label = gtk_accel_label_new (label);
 237   gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
 238
 239   gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
 240   gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
 241   gtk_widget_show (accel_label);
 242
 243   return menu_item;
 244 }
 245
 246
 247 /**
 248  * gtk_menu_item_new_with_mnemonic:
 249  * @label: The text of the button, with an underscore in front of the
 250  *         mnemonic character
 251  * @returns: a new #GtkMenuItem
 252  *
 253  * Creates a new #GtkMenuItem containing a label. The label
 254  * will be created using gtk_label_new_with_mnemonic(), so underscores
 255  * in @label indicate the mnemonic for the menu item.
 256  **/
 257 GtkWidget*
 258 gtk_menu_item_new_with_mnemonic (const gchar *label)
 259 {
 260   GtkWidget *menu_item;
 261   GtkWidget *accel_label;
 262
 263   menu_item = gtk_menu_item_new ();
 264   accel_label = gtk_type_new (GTK_TYPE_ACCEL_LABEL);
 265   gtk_label_set_text_with_mnemonic (GTK_LABEL (accel_label), label);
 266   gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
 267
 268   gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
 269   gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
 270   gtk_widget_show (accel_label);
 271
 272   return menu_item;
 273 }
 274
 275 static void
 276 gtk_menu_item_destroy (GtkObject *object)
 277 {
 278   GtkMenuItem *menu_item;
 279
 280   g_return_if_fail (GTK_IS_MENU_ITEM (object));
 281
 282   menu_item = GTK_MENU_ITEM (object);
 283
 284   if (menu_item->submenu)
 285     gtk_widget_destroy (menu_item->submenu);
 286
 287   GTK_OBJECT_CLASS (parent_class)->destroy (object);
 288 }
 289
 290 static void
 291 gtk_menu_item_finalize (GObject *object)
 292 {
 293   GtkMenuItem *menu_item = GTK_MENU_ITEM (object);
 294
 295   g_free (menu_item->accel_path);
 296
 297   G_OBJECT_CLASS (parent_class)->finalize (object);
 298 }
 299
 300 static void
 301 gtk_menu_item_detacher (GtkWidget     *widget,
 302                         GtkMenu       *menu)
 303 {
 304   GtkMenuItem *menu_item;
 305
 306   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 307
 308   menu_item = GTK_MENU_ITEM (widget);
 309   g_return_if_fail (menu_item->submenu == (GtkWidget*) menu);
 310
 311   menu_item->submenu = NULL;
 312 }
 313
 314 void
 315 gtk_menu_item_set_submenu (GtkMenuItem *menu_item,
 316                            GtkWidget   *submenu)
 317 {
 318   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 319
 320   if (menu_item->submenu != submenu)
 321     {
 322       gtk_menu_item_remove_submenu (menu_item);
 323
 324       menu_item->submenu = submenu;
 325       gtk_menu_attach_to_widget (GTK_MENU (submenu),
 326                                  GTK_WIDGET (menu_item),
 327                                  gtk_menu_item_detacher);
 328
 329       if (GTK_WIDGET (menu_item)->parent)
 330         gtk_widget_queue_resize (GTK_WIDGET (menu_item));
 331     }
 332 }
 333
 334 /**
 335  * gtk_menu_item_get_submenu:
 336  * @menu_item: a #GtkMenuItem
 337  *
 338  * Gets the submenu underneath this menu item, if any. See
 339  * gtk_menu_item_set_submenu().
 340  *
 341  * Return value: submenu for this menu item, or %NULL if none.
 342  **/
 343 GtkWidget *
 344 gtk_menu_item_get_submenu (GtkMenuItem *menu_item)
 345 {
 346   g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), NULL);
 347
 348   return menu_item->submenu;
 349 }
 350
 351 void
 352 gtk_menu_item_remove_submenu (GtkMenuItem         *menu_item)
 353 {
 354   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 355
 356   if (menu_item->submenu)
 357     gtk_menu_detach (GTK_MENU (menu_item->submenu));
 358 }
 359
 360 void _gtk_menu_item_set_placement (GtkMenuItem         *menu_item,
 361                                    GtkSubmenuPlacement  placement);
 362
 363 void
 364 _gtk_menu_item_set_placement (GtkMenuItem         *menu_item,
 365                              GtkSubmenuPlacement  placement)
 366 {
 367   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 368
 369   menu_item->submenu_placement = placement;
 370 }
 371
 372 void
 373 gtk_menu_item_select (GtkMenuItem *menu_item)
 374 {
 375   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 376
 377   gtk_item_select (GTK_ITEM (menu_item));
 378 }
 379
 380 void
 381 gtk_menu_item_deselect (GtkMenuItem *menu_item)
 382 {
 383   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 384
 385   gtk_item_deselect (GTK_ITEM (menu_item));
 386 }
 387
 388 void
 389 gtk_menu_item_activate (GtkMenuItem *menu_item)
 390 {
 391   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 392
 393   gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[ACTIVATE]);
 394 }
 395
 396 void
 397 gtk_menu_item_toggle_size_request (GtkMenuItem *menu_item,
 398                                    gint        *requisition)
 399 {
 400   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 401
 402   gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[TOGGLE_SIZE_REQUEST], requisition);
 403 }
 404
 405 void
 406 gtk_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
 407                                     gint         allocation)
 408 {
 409   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 410
 411   gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[TOGGLE_SIZE_ALLOCATE], allocation);
 412 }
 413
 414 static void
 415 gtk_menu_item_accel_width_foreach (GtkWidget *widget,
 416                                    gpointer data)
 417 {
 418   guint *width = data;
 419
 420   if (GTK_IS_ACCEL_LABEL (widget))
 421     {
 422       guint w;
 423
 424       w = gtk_accel_label_get_accel_width (GTK_ACCEL_LABEL (widget));
 425       *width = MAX (*width, w);
 426     }
 427   else if (GTK_IS_CONTAINER (widget))
 428     gtk_container_foreach (GTK_CONTAINER (widget),
 429                            gtk_menu_item_accel_width_foreach,
 430                            data);
 431 }
 432
 433 static void
 434 gtk_menu_item_size_request (GtkWidget      *widget,
 435                             GtkRequisition *requisition)
 436 {
 437   GtkMenuItem *menu_item;
 438   GtkBin *bin;
 439   guint accel_width;
 440
 441   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 442   g_return_if_fail (requisition != NULL);
 443
 444   bin = GTK_BIN (widget);
 445   menu_item = GTK_MENU_ITEM (widget);
 446
 447   requisition->width = (GTK_CONTAINER (widget)->border_width +
 448                         widget->style->xthickness +
 449                         BORDER_SPACING) * 2;
 450   requisition->height = (GTK_CONTAINER (widget)->border_width +
 451                          widget->style->ythickness) * 2;
 452
 453   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 454     {
 455       GtkRequisition child_requisition;
 456
 457       gtk_widget_size_request (bin->child, &child_requisition);
 458
 459       requisition->width += child_requisition.width;
 460       requisition->height += child_requisition.height;
 461
 462       if (menu_item->submenu && menu_item->show_submenu_indicator)
 463         requisition->width += child_requisition.height;
 464     }
 465
 466   accel_width = 0;
 467   gtk_container_foreach (GTK_CONTAINER (menu_item),
 468                          gtk_menu_item_accel_width_foreach,
 469                          &accel_width);
 470   menu_item->accelerator_width = accel_width;
 471 }
 472
 473 static void
 474 gtk_menu_item_size_allocate (GtkWidget     *widget,
 475                              GtkAllocation *allocation)
 476 {
 477   GtkMenuItem *menu_item;
 478   GtkBin *bin;
 479   GtkAllocation child_allocation;
 480
 481   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 482   g_return_if_fail (allocation != NULL);
 483
 484   menu_item = GTK_MENU_ITEM (widget);
 485   bin = GTK_BIN (widget);
 486
 487   widget->allocation = *allocation;
 488
 489   if (bin->child)
 490     {
 491       child_allocation.x = (GTK_CONTAINER (widget)->border_width +
 492                             widget->style->xthickness +
 493                             BORDER_SPACING);
 494       child_allocation.y = (GTK_CONTAINER (widget)->border_width +
 495                             widget->style->ythickness);
 496       child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
 497       child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
 498       child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
 499       child_allocation.width -= GTK_MENU_ITEM (widget)->toggle_size;
 500       child_allocation.x += widget->allocation.x;
 501       child_allocation.y += widget->allocation.y;
 502
 503       if (menu_item->submenu && menu_item->show_submenu_indicator)
 504         child_allocation.width -= child_allocation.height;
 505
 506       gtk_widget_size_allocate (bin->child, &child_allocation);
 507     }
 508
 509   if (GTK_WIDGET_REALIZED (widget))
 510     gdk_window_move_resize (menu_item->event_window,
 511                             allocation->x, allocation->y,
 512                             allocation->width, allocation->height);
 513
 514   if (menu_item->submenu)
 515     gtk_menu_reposition (GTK_MENU (menu_item->submenu));
 516 }
 517
 518 static void
 519 gtk_menu_item_realize (GtkWidget *widget)
 520 {
 521   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
 522   GdkWindowAttr attributes;
 523   gint attributes_mask;
 524
 525   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 526
 527   widget->window = gtk_widget_get_parent_window (widget);
 528   gdk_window_ref (widget->window);
 529
 530   attributes.x = widget->allocation.x;
 531   attributes.y = widget->allocation.y;
 532   attributes.width = widget->allocation.width;
 533   attributes.height = widget->allocation.height;
 534   attributes.window_type = GDK_WINDOW_CHILD;
 535   attributes.wclass = GDK_INPUT_ONLY;
 536   attributes.event_mask = (gtk_widget_get_events (widget) |
 537                            GDK_EXPOSURE_MASK |
 538                            GDK_BUTTON_PRESS_MASK |
 539                            GDK_BUTTON_RELEASE_MASK |
 540                            GDK_ENTER_NOTIFY_MASK |
 541                            GDK_LEAVE_NOTIFY_MASK |
 542                            GDK_POINTER_MOTION_MASK);
 543
 544   attributes_mask = GDK_WA_X | GDK_WA_Y;
 545   menu_item->event_window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
 546   gdk_window_set_user_data (menu_item->event_window, widget);
 547
 548   widget->style = gtk_style_attach (widget->style, widget->window);
 549 }
 550
 551 static void
 552 gtk_menu_item_unrealize (GtkWidget *widget)
 553 {
 554   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
 555
 556   gdk_window_set_user_data (menu_item->event_window, NULL);
 557   gdk_window_destroy (menu_item->event_window);
 558   menu_item->event_window = NULL;
 559
 560   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 561     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 562 }
 563
 564 static void
 565 gtk_menu_item_map (GtkWidget *widget)
 566 {
 567   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
 568
 569   GTK_WIDGET_CLASS (parent_class)->map (widget);
 570
 571   gdk_window_show (menu_item->event_window);
 572 }
 573
 574 static void
 575 gtk_menu_item_unmap (GtkWidget *widget)
 576 {
 577   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
 578
 579   gdk_window_hide (menu_item->event_window);
 580
 581   GTK_WIDGET_CLASS (parent_class)->unmap (widget);
 582 }
 583
 584 static void
 585 gtk_menu_item_paint (GtkWidget    *widget,
 586                      GdkRectangle *area)
 587 {
 588   GtkMenuItem *menu_item;
 589   GtkStateType state_type;
 590   GtkShadowType shadow_type;
 591   gint width, height;
 592   gint x, y;
 593   gint border_width = GTK_CONTAINER (widget)->border_width;
 594
 595   if (GTK_WIDGET_DRAWABLE (widget))
 596     {
 597       menu_item = GTK_MENU_ITEM (widget);
 598
 599       state_type = widget->state;
 600
 601       x = widget->allocation.x + border_width;
 602       y = widget->allocation.y + border_width;
 603       width = widget->allocation.width - border_width * 2;
 604       height = widget->allocation.height - border_width * 2;
 605
 606       if ((state_type == GTK_STATE_PRELIGHT) &&
 607           (GTK_BIN (menu_item)->child))
 608         gtk_paint_box (widget->style,
 609                        widget->window,
 610                        GTK_STATE_PRELIGHT,
 611                        GTK_SHADOW_OUT,
 612                        area, widget, "menuitem",
 613                        x, y, width, height);
 614
 615       if (menu_item->submenu && menu_item->show_submenu_indicator)
 616         {
 617           GtkRequisition child_requisition;
 618           gint arrow_x, arrow_y;
 619           gint arrow_size;
 620           gint arrow_extent;
 621
 622           gtk_widget_get_child_requisition (GTK_BIN (menu_item)->child,
 623                                             &child_requisition);
 624
 625           arrow_size = child_requisition.height - 2 * widget->style->ythickness;
 626           arrow_extent = arrow_size * 0.6;
 627
 628           shadow_type = GTK_SHADOW_OUT;
 629           if (state_type == GTK_STATE_PRELIGHT)
 630             shadow_type = GTK_SHADOW_IN;
 631
 632           arrow_x = x + width - 1 - arrow_size + (arrow_size - arrow_extent) / 2;
 633           arrow_y = y + (height - arrow_extent) / 2;
 634
 635           gtk_paint_arrow (widget->style, widget->window,
 636                            state_type, shadow_type,
 637                            area, widget, "menuitem",
 638                            GTK_ARROW_RIGHT, TRUE,
 639                            arrow_x, arrow_y,
 640                            arrow_extent, arrow_extent);
 641         }
 642       else if (!GTK_BIN (menu_item)->child)
 643         {
 644           gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
 645                            area, widget, "menuitem",
 646                            widget->allocation.x, widget->allocation.width,
 647                            widget->allocation.y);
 648         }
 649     }
 650 }
 651
 652 static gint
 653 gtk_menu_item_expose (GtkWidget      *widget,
 654                       GdkEventExpose *event)
 655 {
 656   g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
 657   g_return_val_if_fail (event != NULL, FALSE);
 658
 659   if (GTK_WIDGET_DRAWABLE (widget))
 660     {
 661       gtk_menu_item_paint (widget, &event->area);
 662
 663       (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
 664     }
 665
 666   return FALSE;
 667 }
 668
 669 static void
 670 gtk_real_menu_item_select (GtkItem *item)
 671 {
 672   GtkMenuItem *menu_item;
 673
 674   g_return_if_fail (GTK_IS_MENU_ITEM (item));
 675
 676   menu_item = GTK_MENU_ITEM (item);
 677
 678   /*  if (menu_item->submenu && !GTK_WIDGET_VISIBLE (menu_item->submenu))*/
 679   if (menu_item->submenu)
 680     {
 681       guint32 etime;
 682       GdkEvent *event = gtk_get_current_event ();
 683
 684       etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
 685       if (event &&
 686           etime >= last_submenu_deselect_time &&
 687           last_submenu_deselect_time + SELECT_TIMEOUT > etime)
 688         {
 689           if (!menu_item->timer)
 690             menu_item->timer = gtk_timeout_add (SELECT_TIMEOUT - (etime - last_submenu_deselect_time),
 691                                                 gtk_menu_item_select_timeout,
 692                                                 menu_item);
 693           if (event &&
 694               event->type != GDK_BUTTON_PRESS &&
 695               event->type != GDK_ENTER_NOTIFY)
 696             menu_item->timer_from_keypress = TRUE;
 697           else
 698             menu_item->timer_from_keypress = FALSE;
 699         }
 700       else
 701         gtk_menu_item_popup_submenu (menu_item);
 702       if (event)
 703         gdk_event_free(event);
 704     }
 705
 706   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_PRELIGHT);
 707   gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
 708 }
 709
 710 static void
 711 gtk_real_menu_item_deselect (GtkItem *item)
 712 {
 713   GtkMenuItem *menu_item;
 714
 715   g_return_if_fail (GTK_IS_MENU_ITEM (item));
 716
 717   menu_item = GTK_MENU_ITEM (item);
 718
 719   if (menu_item->submenu)
 720     {
 721       guint32 etime;
 722       GdkEvent *event = gtk_get_current_event ();
 723
 724       if (menu_item->timer)
 725         {
 726           gtk_timeout_remove (menu_item->timer);
 727           menu_item->timer = 0;
 728         }
 729       else
 730         gtk_menu_popdown (GTK_MENU (menu_item->submenu));
 731
 732       etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
 733       if (etime > last_submenu_deselect_time)
 734         last_submenu_deselect_time = etime;
 735       if (event)
 736         gdk_event_free(event);
 737     }
 738
 739   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_NORMAL);
 740   gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
 741 }
 742
 743 static gboolean
 744 gtk_menu_item_mnemonic_activate (GtkWidget *widget,
 745                                  gboolean   group_cycling)
 746 {
 747   if (group_cycling)
 748     {
 749       if (widget->parent &&
 750           GTK_IS_MENU_SHELL (widget->parent))
 751         gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent),
 752                                     widget);
 753
 754     }
 755   else
 756     gtk_signal_emit (GTK_OBJECT (widget), menu_item_signals[ACTIVATE_ITEM]);
 757
 758   return TRUE;
 759 }
 760
 761
 762 static void
 763 gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
 764 {
 765   GtkWidget *widget;
 766   GtkMenuShell *submenu;
 767
 768   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 769
 770   widget = GTK_WIDGET (menu_item);
 771
 772   if (widget->parent &&
 773       GTK_IS_MENU_SHELL (widget->parent))
 774     {
 775       if (menu_item->submenu == NULL)
 776         gtk_menu_shell_activate_item (GTK_MENU_SHELL (widget->parent),
 777                                       widget, TRUE);
 778       else
 779         {
 780           GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget->parent);
 781
 782           _gtk_menu_shell_activate (menu_shell);
 783
 784           gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent), widget);
 785           gtk_menu_item_popup_submenu (widget);
 786
 787           _gtk_menu_shell_select_first (GTK_MENU_SHELL (menu_item->submenu));
 788           submenu = GTK_MENU_SHELL (menu_item->submenu);
 789         }
 790     }
 791 }
 792 static void
 793 gtk_real_menu_item_toggle_size_request (GtkMenuItem *menu_item,
 794                                         gint        *requisition)
 795 {
 796   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 797
 798   *requisition = 0;
 799 }
 800
 801 static void
 802 gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
 803                                          gint         allocation)
 804 {
 805   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 806
 807   menu_item->toggle_size = allocation;
 808 }
 809
 810 static gint
 811 gtk_menu_item_select_timeout (gpointer data)
 812 {
 813   GtkMenuItem *menu_item;
 814   GtkWidget *parent;
 815
 816   GDK_THREADS_ENTER ();
 817
 818   menu_item = GTK_MENU_ITEM (data);
 819
 820   parent = GTK_WIDGET (menu_item)->parent;
 821
 822   if (parent && GTK_IS_MENU_SHELL (parent) && GTK_MENU_SHELL (parent)->active)
 823     {
 824       gtk_menu_item_popup_submenu (data);
 825       if (menu_item->timer_from_keypress && menu_item->submenu)
 826         GTK_MENU_SHELL (menu_item->submenu)->ignore_enter = TRUE;
 827     }
 828
 829   GDK_THREADS_LEAVE ();
 830
 831   return FALSE;
 832 }
 833
 834 static void
 835 gtk_menu_item_popup_submenu (gpointer data)
 836 {
 837   GtkMenuItem *menu_item;
 838
 839   menu_item = GTK_MENU_ITEM (data);
 840   menu_item->timer = 0;
 841
 842   if (GTK_WIDGET_IS_SENSITIVE (menu_item->submenu))
 843     {
 844       gtk_menu_popup (GTK_MENU (menu_item->submenu),
 845                       GTK_WIDGET (menu_item)->parent,
 846                       GTK_WIDGET (menu_item),
 847                       gtk_menu_item_position_menu,
 848                       menu_item,
 849                       GTK_MENU_SHELL (GTK_WIDGET (menu_item)->parent)->button,
 850                       0);
 851     }
 852 }
 853
 854 static void
 855 gtk_menu_item_position_menu (GtkMenu  *menu,
 856                              gint     *x,
 857                              gint     *y,
 858                              gboolean *push_in,
 859                              gpointer  user_data)
 860 {
 861   GtkMenuItem *menu_item;
 862   GtkWidget *widget;
 863   GtkWidget *parent_menu_item;
 864   gint screen_width;
 865   gint screen_height;
 866   gint twidth, theight;
 867   gint tx, ty;
 868
 869   g_return_if_fail (menu != NULL);
 870   g_return_if_fail (x != NULL);
 871   g_return_if_fail (y != NULL);
 872
 873   menu_item = GTK_MENU_ITEM (user_data);
 874   widget = GTK_WIDGET (user_data);
 875
 876   twidth = GTK_WIDGET (menu)->requisition.width;
 877   theight = GTK_WIDGET (menu)->requisition.height;
 878
 879   screen_width = gdk_screen_width ();
 880   screen_height = gdk_screen_height ();
 881
 882   if (!gdk_window_get_origin (widget->window, &tx, &ty))
 883     {
 884       g_warning ("Menu not on screen");
 885       return;
 886     }
 887
 888   tx += widget->allocation.x;
 889   ty += widget->allocation.y;
 890
 891   switch (menu_item->submenu_placement)
 892     {
 893     case GTK_TOP_BOTTOM:
 894       if ((ty + widget->allocation.height + theight) <= screen_height)
 895         ty += widget->allocation.height;
 896       else if ((ty - theight) >= 0)
 897         ty -= theight;
 898       else if (screen_height - (ty + widget->allocation.height) > ty)
 899         ty += widget->allocation.height;
 900       else
 901         ty -= theight;
 902       break;
 903
 904     case GTK_LEFT_RIGHT:
 905       menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 906       parent_menu_item = GTK_MENU (widget->parent)->parent_menu_item;
 907       if (parent_menu_item)
 908         menu_item->submenu_direction = GTK_MENU_ITEM (parent_menu_item)->submenu_direction;
 909
 910       switch (menu_item->submenu_direction)
 911         {
 912         case GTK_DIRECTION_LEFT:
 913           if ((tx - twidth) >= 0)
 914             tx -= twidth;
 915           else
 916             {
 917               menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 918               tx += widget->allocation.width - 5;
 919             }
 920           break;
 921
 922         case GTK_DIRECTION_RIGHT:
 923           if ((tx + widget->allocation.width + twidth - 5) <= screen_width)
 924             tx += widget->allocation.width - 5;
 925           else
 926             {
 927               menu_item->submenu_direction = GTK_DIRECTION_LEFT;
 928               tx -= twidth;
 929             }
 930           break;
 931         }
 932
 933       ty += widget->allocation.height / 4;
 934
 935       /* If the height of the menu doesn't fit we move it upward. */
 936       ty = CLAMP (ty, 0, MAX (0, screen_height - theight));
 937       break;
 938     }
 939
 940   /* If we have negative, tx, here it is because we can't get
 941    * the menu all the way on screen. Favor the left portion.
 942    */
 943   *x = CLAMP (tx, 0, MAX (0, screen_width - twidth));
 944   *y = ty;
 945 }
 946
 947 /**
 948  * gtk_menu_item_set_right_justified:
 949  * @menu_item: a #GtkMenuItem.
 950  * @right_justified: if %TRUE the menu item will appear at the
 951  *   far right if added to a menu bar.
 952  *
 953  * Sets whether the menu item appears justified at the right
 954  * side of a menu bar. This was traditionally done for "Help" menu
 955  * items, but is now considered a bad idea. (If the widget
 956  * layout is reversed for a right-to-left language like Hebrew
 957  * or Arabic, right-justified-menu-items appear at the left.)
 958  **/
 959 void
 960 gtk_menu_item_set_right_justified (GtkMenuItem *menu_item,
 961                                    gboolean     right_justified)
 962 {
 963   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 964
 965   right_justified = right_justified != FALSE;
 966
 967   if (right_justified != menu_item->right_justify)
 968     {
 969       menu_item->right_justify = right_justified;
 970       gtk_widget_queue_resize (GTK_WIDGET (menu_item));
 971     }
 972 }
 973
 974 /**
 975  * gtk_menu_item_get_right_justified:
 976  * @menu_item: a #GtkMenuItem
 977  *
 978  * Gets whether the menu item appears justified at the right
 979  * side of the menu bar.
 980  *
 981  * Return value: %TRUE if the menu item will appear at the
 982  *   far right if added to a menu bar.
 983  **/
 984 gboolean
 985 gtk_menu_item_get_right_justified (GtkMenuItem *menu_item)
 986 {
 987   g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), FALSE);
 988
 989   return menu_item->right_justify;
 990 }
 991
 992
 993 static void
 994 gtk_menu_item_show_all (GtkWidget *widget)
 995 {
 996   GtkMenuItem *menu_item;
 997
 998   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 999
1000   menu_item = GTK_MENU_ITEM (widget);
1001
1002   /* show children including submenu */
1003   if (menu_item->submenu)
1004     gtk_widget_show_all (menu_item->submenu);
1005   gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);
1006
1007   gtk_widget_show (widget);
1008 }
1009
1010 static void
1011 gtk_menu_item_hide_all (GtkWidget *widget)
1012 {
1013   GtkMenuItem *menu_item;
1014
1015   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
1016
1017   gtk_widget_hide (widget);
1018
1019   menu_item = GTK_MENU_ITEM (widget);
1020
1021   /* hide children including submenu */
1022   gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
1023   if (menu_item->submenu)
1024     gtk_widget_hide_all (menu_item->submenu);
1025 }
1026
1027 static void
1028 gtk_menu_item_accel_name_foreach (GtkWidget *widget,
1029                                   gpointer data)
1030 {
1031   const gchar **path_p = data;
1032
1033   if (!*path_p)
1034     {
1035       if (GTK_IS_LABEL (widget))
1036         {
1037           *path_p = gtk_label_get_text (GTK_LABEL (widget));
1038           if (*path_p && (*path_p)[0] == 0)
1039             *path_p = NULL;
1040         }
1041       else if (GTK_IS_CONTAINER (widget))
1042         gtk_container_foreach (GTK_CONTAINER (widget),
1043                                gtk_menu_item_accel_name_foreach,
1044                                data);
1045     }
1046 }
1047
1048 static void
1049 gtk_menu_item_parent_set (GtkWidget *widget,
1050                           GtkWidget *previous_parent)
1051 {
1052   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
1053   GtkMenu *menu = GTK_IS_MENU (widget->parent) ? GTK_MENU (widget->parent) : NULL;
1054
1055   if (menu)
1056     _gtk_menu_item_refresh_accel_path (menu_item,
1057                                        menu->accel_path,
1058                                        menu->accel_group,
1059                                        TRUE);
1060
1061   if (GTK_WIDGET_CLASS (parent_class)->parent_set)
1062     GTK_WIDGET_CLASS (parent_class)->parent_set (widget, previous_parent);
1063 }
1064
1065 void
1066 _gtk_menu_item_refresh_accel_path (GtkMenuItem   *menu_item,
1067                                    const gchar   *prefix,
1068                                    GtkAccelGroup *accel_group,
1069                                    gboolean       group_changed)
1070 {
1071   const gchar *path;
1072   GtkWidget *widget;
1073
1074   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1075   g_return_if_fail (!accel_group || GTK_IS_ACCEL_GROUP (accel_group));
1076
1077   widget = GTK_WIDGET (menu_item);
1078
1079   if (!accel_group)
1080     {
1081       gtk_widget_set_accel_path (widget, NULL, NULL);
1082       return;
1083     }
1084
1085   path = _gtk_widget_get_accel_path (widget, NULL);
1086   if (!path)                                    /* no active accel_path yet */
1087     {
1088       path = menu_item->accel_path;
1089       if (!path && prefix)
1090         {
1091           gchar *postfix = NULL;
1092
1093           /* try to construct one from label text */
1094           gtk_container_foreach (GTK_CONTAINER (menu_item),
1095                                  gtk_menu_item_accel_name_foreach,
1096                                  &postfix);
1097           menu_item->accel_path = postfix ? g_strconcat (prefix, "/", postfix, NULL) : NULL;
1098           path = menu_item->accel_path;
1099         }
1100       if (path)
1101         gtk_widget_set_accel_path (widget, path, accel_group);
1102     }
1103   else if (group_changed)                       /* reinstall accelerators */
1104     gtk_widget_set_accel_path (widget, path, accel_group);
1105 }
1106
1107 /**
1108  * gtk_menu_item_set_accel_path
1109  * @menu_item:  a valid #GtkMenuItem
1110  * @accel_path: accelerator path, corresponding to this menu item's functionality
1111  *
1112  * Set the accelerator path on @menu_item, through which runtime changes of the
1113  * menu item's accelerator caused by the user can be identified and saved to
1114  * persistant storage (see gtk_accel_map_save() on this).
1115  * To setup a default accelerator for this menu item, call
1116  * gtk_accel_map_add_entry() with the same @accel_path.
1117  * See also gtk_accel_map_add_entry() on the specifics of accelerator paths,
1118  * and gtk_menu_set_accel_path() for a more convenient variant of this function.
1119  *
1120  * This function is basically a convenience wrapper that handles calling
1121  * gtk_widget_set_accel_path() with the appropriate accelerator group for
1122  * the menu item.
1123  */
1124 void
1125 gtk_menu_item_set_accel_path (GtkMenuItem *menu_item,
1126                               const gchar *accel_path)
1127 {
1128   GtkWidget *widget;
1129
1130   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1131   g_return_if_fail (accel_path && accel_path[0] == '<' && strchr (accel_path, '/'));
1132
1133   widget = GTK_WIDGET (menu_item);
1134
1135   /* store new path */
1136   g_free (menu_item->accel_path);
1137   menu_item->accel_path = g_strdup (accel_path);
1138
1139   /* forget accelerators associated with old path */
1140   gtk_widget_set_accel_path (widget, NULL, NULL);
1141
1142   /* install accelerators associated with new path */
1143   if (widget->parent && GTK_IS_MENU (widget->parent))
1144     {
1145       GtkMenu *menu = GTK_MENU (widget->parent);
1146
1147       if (menu->accel_group)
1148         _gtk_menu_item_refresh_accel_path (GTK_MENU_ITEM (widget),
1149                                            NULL,
1150                                            menu->accel_group,
1151                                            FALSE);
1152     }
1153 }
1154
1155 static void
1156 gtk_menu_item_forall (GtkContainer *container,
1157                       gboolean      include_internals,
1158                       GtkCallback   callback,
1159                       gpointer      callback_data)
1160 {
1161   GtkBin *bin;
1162   GtkMenuItem *menu_item;
1163
1164   g_return_if_fail (GTK_IS_MENU_ITEM (container));
1165   g_return_if_fail (callback != NULL);
1166
1167   bin = GTK_BIN (container);
1168   menu_item = GTK_MENU_ITEM (container);
1169
1170   if (bin->child)
1171     callback (bin->child, callback_data);
1172 }
1173
1174 gboolean
1175 _gtk_menu_item_is_selectable (GtkWidget *menu_item)
1176 {
1177   if ((!GTK_BIN (menu_item)->child &&
1178        G_OBJECT_TYPE (menu_item) == GTK_TYPE_MENU_ITEM) ||
1179       GTK_IS_SEPARATOR_MENU_ITEM (menu_item) ||
1180       !GTK_WIDGET_IS_SENSITIVE (menu_item) ||
1181       !GTK_WIDGET_VISIBLE (menu_item))
1182     return FALSE;
1183
1184   return TRUE;
1185 }