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