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_size_request   (GtkWidget        *widget,
  55                                           GtkRequisition   *requisition);
  56 static void gtk_menu_item_size_allocate  (GtkWidget        *widget,
  57                                           GtkAllocation    *allocation);
  58 static void gtk_menu_item_paint          (GtkWidget        *widget,
  59                                           GdkRectangle     *area);
  60 static gint gtk_menu_item_expose         (GtkWidget        *widget,
  61                                           GdkEventExpose   *event);
  62
  63 static void gtk_real_menu_item_select               (GtkItem     *item);
  64 static void gtk_real_menu_item_deselect             (GtkItem     *item);
  65 static void gtk_real_menu_item_activate_item        (GtkMenuItem *item);
  66 static void gtk_real_menu_item_toggle_size_request  (GtkMenuItem *menu_item,
  67                                                      gint        *requisition);
  68 static void gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
  69                                                      gint         allocation);
  70 static gboolean gtk_menu_item_mnemonic_activate     (GtkWidget   *widget,
  71                                                      gboolean     group_cycling);
  72
  73 static gint gtk_menu_item_select_timeout (gpointer          data);
  74 static void gtk_menu_item_popup_submenu  (gpointer     data);
  75 static void gtk_menu_item_position_menu  (GtkMenu          *menu,
  76                                           gint             *x,
  77                                           gint             *y,
  78                                           gboolean         *push_in,
  79                                           gpointer          user_data);
  80 static void gtk_menu_item_show_all       (GtkWidget        *widget);
  81 static void gtk_menu_item_hide_all       (GtkWidget        *widget);
  82 static void gtk_menu_item_forall         (GtkContainer    *container,
  83                                           gboolean         include_internals,
  84                                           GtkCallback      callback,
  85                                           gpointer         callback_data);
  86
  87
  88 static GtkItemClass *parent_class;
  89 static guint menu_item_signals[LAST_SIGNAL] = { 0 };
  90 static guint32  last_submenu_deselect_time = 0;
  91
  92
  93
  94 GtkType
  95 gtk_menu_item_get_type (void)
  96 {
  97   static GtkType menu_item_type = 0;
  98
  99   if (!menu_item_type)
 100     {
 101       static const GTypeInfo menu_item_info =
 102       {
 103         sizeof (GtkMenuItemClass),
 104         NULL,           /* base_init */
 105         NULL,           /* base_finalize */
 106         (GClassInitFunc) gtk_menu_item_class_init,
 107         NULL,           /* class_finalize */
 108         NULL,           /* class_data */
 109         sizeof (GtkMenuItem),
 110         16,             /* n_preallocs */
 111         (GInstanceInitFunc) gtk_menu_item_init,
 112       };
 113
 114       menu_item_type = g_type_register_static (GTK_TYPE_ITEM, "GtkMenuItem", &menu_item_info, 0);
 115     }
 116
 117   return menu_item_type;
 118 }
 119
 120 static void
 121 gtk_menu_item_class_init (GtkMenuItemClass *klass)
 122 {
 123   GtkObjectClass *object_class;
 124   GtkWidgetClass *widget_class;
 125   GtkContainerClass *container_class;
 126   GtkItemClass *item_class;
 127
 128   object_class = (GtkObjectClass*) klass;
 129   widget_class = (GtkWidgetClass*) klass;
 130   container_class = (GtkContainerClass*) klass;
 131   item_class = (GtkItemClass*) klass;
 132
 133   parent_class = gtk_type_class (gtk_item_get_type ());
 134
 135
 136   object_class->destroy = gtk_menu_item_destroy;
 137
 138   widget_class->size_request = gtk_menu_item_size_request;
 139   widget_class->size_allocate = gtk_menu_item_size_allocate;
 140   widget_class->expose_event = gtk_menu_item_expose;
 141   widget_class->show_all = gtk_menu_item_show_all;
 142   widget_class->hide_all = gtk_menu_item_hide_all;
 143   widget_class->mnemonic_activate = gtk_menu_item_mnemonic_activate;
 144
 145   container_class->forall = gtk_menu_item_forall;
 146
 147   item_class->select = gtk_real_menu_item_select;
 148   item_class->deselect = gtk_real_menu_item_deselect;
 149
 150   klass->activate = NULL;
 151   klass->activate_item = gtk_real_menu_item_activate_item;
 152   klass->toggle_size_request = gtk_real_menu_item_toggle_size_request;
 153   klass->toggle_size_allocate = gtk_real_menu_item_toggle_size_allocate;
 154
 155   klass->hide_on_activate = TRUE;
 156
 157   menu_item_signals[ACTIVATE] =
 158     gtk_signal_new ("activate",
 159                     GTK_RUN_FIRST | GTK_RUN_ACTION,
 160                     GTK_CLASS_TYPE (object_class),
 161                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate),
 162                     gtk_marshal_VOID__VOID,
 163                     GTK_TYPE_NONE, 0);
 164   widget_class->activate_signal = menu_item_signals[ACTIVATE];
 165
 166   menu_item_signals[ACTIVATE_ITEM] =
 167     gtk_signal_new ("activate_item",
 168                     GTK_RUN_FIRST,
 169                     GTK_CLASS_TYPE (object_class),
 170                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate_item),
 171                     gtk_signal_default_marshaller,
 172                     GTK_TYPE_NONE, 0);
 173
 174   menu_item_signals[TOGGLE_SIZE_REQUEST] =
 175     gtk_signal_new ("toggle_size_request",
 176                     GTK_RUN_FIRST,
 177                     GTK_CLASS_TYPE (object_class),
 178                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, toggle_size_request),
 179                     gtk_marshal_NONE__POINTER,
 180                     GTK_TYPE_NONE, 1,
 181                     GTK_TYPE_POINTER);
 182
 183   menu_item_signals[TOGGLE_SIZE_ALLOCATE] =
 184     gtk_signal_new ("toggle_size_allocate",
 185                     GTK_RUN_FIRST,
 186                     GTK_CLASS_TYPE (object_class),
 187                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, toggle_size_allocate),
 188                     gtk_marshal_NONE__INT,
 189                     GTK_TYPE_NONE, 1,
 190                     GTK_TYPE_INT);
 191 }
 192
 193 static void
 194 gtk_menu_item_init (GtkMenuItem *menu_item)
 195 {
 196   menu_item->submenu = NULL;
 197   menu_item->accelerator_signal = menu_item_signals[ACTIVATE];
 198   menu_item->toggle_size = 0;
 199   menu_item->accelerator_width = 0;
 200   menu_item->show_toggle_indicator = FALSE;
 201   menu_item->show_submenu_indicator = FALSE;
 202   menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 203   menu_item->submenu_placement = GTK_TOP_BOTTOM;
 204   menu_item->right_justify = FALSE;
 205
 206   menu_item->timer = 0;
 207 }
 208
 209 GtkWidget*
 210 gtk_menu_item_new (void)
 211 {
 212   return GTK_WIDGET (gtk_type_new (gtk_menu_item_get_type ()));
 213 }
 214
 215 GtkWidget*
 216 gtk_menu_item_new_with_label (const gchar *label)
 217 {
 218   GtkWidget *menu_item;
 219   GtkWidget *accel_label;
 220
 221   menu_item = gtk_menu_item_new ();
 222   accel_label = gtk_accel_label_new (label);
 223   gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
 224
 225   gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
 226   gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
 227   gtk_widget_show (accel_label);
 228
 229   return menu_item;
 230 }
 231
 232
 233 /**
 234  * gtk_menu_item_new_with_mnemonic:
 235  * @label: The text of the button, with an underscore in front of the
 236  *         mnemonic character
 237  * @returns: a new #GtkMenuItem
 238  *
 239  * Creates a new #GtkMenuItem containing a label. The label
 240  * will be created using gtk_label_new_with_mnemonic(), so underscores
 241  * in @label indicate the mnemonic for the menu item.
 242  **/
 243 GtkWidget*
 244 gtk_menu_item_new_with_mnemonic (const gchar *label)
 245 {
 246   GtkWidget *menu_item;
 247   GtkWidget *accel_label;
 248
 249   menu_item = gtk_menu_item_new ();
 250   accel_label = gtk_type_new (GTK_TYPE_ACCEL_LABEL);
 251   gtk_label_set_text_with_mnemonic (GTK_LABEL (accel_label), label);
 252   gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
 253
 254   gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
 255   gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
 256   gtk_widget_show (accel_label);
 257
 258   return menu_item;
 259 }
 260
 261 static void
 262 gtk_menu_item_destroy (GtkObject *object)
 263 {
 264   GtkMenuItem *menu_item;
 265
 266   g_return_if_fail (object != NULL);
 267   g_return_if_fail (GTK_IS_MENU_ITEM (object));
 268
 269   menu_item = GTK_MENU_ITEM (object);
 270
 271   if (menu_item->submenu)
 272     gtk_widget_destroy (menu_item->submenu);
 273
 274   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 275     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 276 }
 277
 278 static void
 279 gtk_menu_item_detacher (GtkWidget     *widget,
 280                         GtkMenu       *menu)
 281 {
 282   GtkMenuItem *menu_item;
 283
 284   g_return_if_fail (widget != NULL);
 285   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 286
 287   menu_item = GTK_MENU_ITEM (widget);
 288   g_return_if_fail (menu_item->submenu == (GtkWidget*) menu);
 289
 290   menu_item->submenu = NULL;
 291 }
 292
 293 void
 294 gtk_menu_item_set_submenu (GtkMenuItem *menu_item,
 295                            GtkWidget   *submenu)
 296 {
 297   g_return_if_fail (menu_item != NULL);
 298   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 299
 300   if (menu_item->submenu != submenu)
 301     {
 302       gtk_menu_item_remove_submenu (menu_item);
 303
 304       menu_item->submenu = submenu;
 305       gtk_menu_attach_to_widget (GTK_MENU (submenu),
 306                                  GTK_WIDGET (menu_item),
 307                                  gtk_menu_item_detacher);
 308
 309       if (GTK_WIDGET (menu_item)->parent)
 310         gtk_widget_queue_resize (GTK_WIDGET (menu_item));
 311     }
 312 }
 313
 314 /**
 315  * gtk_menu_item_get_submenu:
 316  * @menu_item: a #GtkMenuItem
 317  *
 318  * Gets the submenu underneath this menu item, if any. See
 319  * gtk_menu_item_set_submenu().
 320  *
 321  * Return value: submenu for this menu item, or %NULL if none.
 322  **/
 323 GtkWidget *
 324 gtk_menu_item_get_submenu (GtkMenuItem *menu_item)
 325 {
 326   g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), NULL);
 327
 328   return menu_item->submenu;
 329 }
 330
 331 void
 332 gtk_menu_item_remove_submenu (GtkMenuItem         *menu_item)
 333 {
 334   g_return_if_fail (menu_item != NULL);
 335   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 336
 337   if (menu_item->submenu)
 338     gtk_menu_detach (GTK_MENU (menu_item->submenu));
 339 }
 340
 341 void
 342 gtk_menu_item_set_placement (GtkMenuItem         *menu_item,
 343                              GtkSubmenuPlacement  placement)
 344 {
 345   g_return_if_fail (menu_item != NULL);
 346   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 347
 348   menu_item->submenu_placement = placement;
 349 }
 350
 351 void
 352 gtk_menu_item_configure (GtkMenuItem *menu_item,
 353                          gboolean     show_toggle_indicator,
 354                          gboolean     show_submenu_indicator)
 355 {
 356   g_return_if_fail (menu_item != NULL);
 357   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 358
 359   menu_item->show_toggle_indicator = show_toggle_indicator;
 360   menu_item->show_submenu_indicator = show_submenu_indicator;
 361 }
 362
 363 void
 364 gtk_menu_item_select (GtkMenuItem *menu_item)
 365 {
 366   g_return_if_fail (menu_item != NULL);
 367   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 368
 369   gtk_item_select (GTK_ITEM (menu_item));
 370 }
 371
 372 void
 373 gtk_menu_item_deselect (GtkMenuItem *menu_item)
 374 {
 375   g_return_if_fail (menu_item != NULL);
 376   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 377
 378   gtk_item_deselect (GTK_ITEM (menu_item));
 379 }
 380
 381 void
 382 gtk_menu_item_activate (GtkMenuItem *menu_item)
 383 {
 384   g_return_if_fail (menu_item != NULL);
 385   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 386
 387   gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[ACTIVATE]);
 388 }
 389
 390 void
 391 gtk_menu_item_toggle_size_request (GtkMenuItem *menu_item,
 392                                    gint        *requisition)
 393 {
 394   g_return_if_fail (menu_item != NULL);
 395   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 396
 397   gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[TOGGLE_SIZE_REQUEST], requisition);
 398 }
 399
 400 void
 401 gtk_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
 402                                     gint         allocation)
 403 {
 404   g_return_if_fail (menu_item != NULL);
 405   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 406
 407   gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[TOGGLE_SIZE_ALLOCATE], allocation);
 408 }
 409
 410 static void
 411 gtk_menu_item_accel_width_foreach (GtkWidget *widget,
 412                                    gpointer data)
 413 {
 414   guint *width = data;
 415
 416   if (GTK_IS_ACCEL_LABEL (widget))
 417     {
 418       guint w;
 419
 420       w = gtk_accel_label_get_accel_width (GTK_ACCEL_LABEL (widget));
 421       *width = MAX (*width, w);
 422     }
 423   else if (GTK_IS_CONTAINER (widget))
 424     gtk_container_foreach (GTK_CONTAINER (widget),
 425                            gtk_menu_item_accel_width_foreach,
 426                            data);
 427 }
 428
 429 static void
 430 gtk_menu_item_size_request (GtkWidget      *widget,
 431                             GtkRequisition *requisition)
 432 {
 433   GtkMenuItem *menu_item;
 434   GtkBin *bin;
 435   guint accel_width;
 436
 437   g_return_if_fail (widget != NULL);
 438   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 439   g_return_if_fail (requisition != NULL);
 440
 441   bin = GTK_BIN (widget);
 442   menu_item = GTK_MENU_ITEM (widget);
 443
 444   requisition->width = (GTK_CONTAINER (widget)->border_width +
 445                         widget->style->xthickness +
 446                         BORDER_SPACING) * 2;
 447   requisition->height = (GTK_CONTAINER (widget)->border_width +
 448                          widget->style->ythickness) * 2;
 449
 450   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 451     {
 452       GtkRequisition child_requisition;
 453
 454       gtk_widget_size_request (bin->child, &child_requisition);
 455
 456       requisition->width += child_requisition.width;
 457       requisition->height += child_requisition.height;
 458     }
 459
 460   if (menu_item->submenu && menu_item->show_submenu_indicator)
 461     requisition->width += 21;
 462
 463   accel_width = 0;
 464   gtk_container_foreach (GTK_CONTAINER (menu_item),
 465                          gtk_menu_item_accel_width_foreach,
 466                          &accel_width);
 467   menu_item->accelerator_width = accel_width;
 468 }
 469
 470 static void
 471 gtk_menu_item_size_allocate (GtkWidget     *widget,
 472                              GtkAllocation *allocation)
 473 {
 474   GtkMenuItem *menu_item;
 475   GtkBin *bin;
 476   GtkAllocation child_allocation;
 477
 478   g_return_if_fail (widget != NULL);
 479   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 480   g_return_if_fail (allocation != NULL);
 481
 482   menu_item = GTK_MENU_ITEM (widget);
 483   bin = GTK_BIN (widget);
 484
 485   widget->allocation = *allocation;
 486
 487   if (bin->child)
 488     {
 489       child_allocation.x = (GTK_CONTAINER (widget)->border_width +
 490                             widget->style->xthickness +
 491                             BORDER_SPACING);
 492       child_allocation.y = (GTK_CONTAINER (widget)->border_width +
 493                             widget->style->ythickness);
 494       child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
 495       child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
 496       child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
 497       child_allocation.width -= GTK_MENU_ITEM (widget)->toggle_size;
 498       if (menu_item->submenu && menu_item->show_submenu_indicator)
 499         child_allocation.width -= 21;
 500
 501       gtk_widget_size_allocate (bin->child, &child_allocation);
 502     }
 503
 504   if (GTK_WIDGET_REALIZED (widget))
 505     gdk_window_move_resize (widget->window,
 506                             allocation->x, allocation->y,
 507                             allocation->width, allocation->height);
 508
 509   if (menu_item->submenu)
 510     gtk_menu_reposition (GTK_MENU (menu_item->submenu));
 511 }
 512
 513 static void
 514 gtk_menu_item_paint (GtkWidget    *widget,
 515                      GdkRectangle *area)
 516 {
 517   GtkMenuItem *menu_item;
 518   GtkStateType state_type;
 519   GtkShadowType shadow_type;
 520   gint width, height;
 521   gint x, y;
 522
 523   g_return_if_fail (widget != NULL);
 524   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 525
 526   if (GTK_WIDGET_DRAWABLE (widget))
 527     {
 528       menu_item = GTK_MENU_ITEM (widget);
 529
 530       state_type = widget->state;
 531
 532       x = GTK_CONTAINER (menu_item)->border_width;
 533       y = GTK_CONTAINER (menu_item)->border_width;
 534       width = widget->allocation.width - x * 2;
 535       height = widget->allocation.height - y * 2;
 536
 537       if ((state_type == GTK_STATE_PRELIGHT) &&
 538           (GTK_BIN (menu_item)->child))
 539         gtk_paint_box (widget->style,
 540                        widget->window,
 541                        GTK_STATE_PRELIGHT,
 542                        GTK_SHADOW_OUT,
 543                        area, widget, "menuitem",
 544                        x, y, width, height);
 545       else
 546         {
 547           gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
 548           gdk_window_clear_area (widget->window, area->x, area->y, area->width, area->height);
 549         }
 550
 551       if (menu_item->submenu && menu_item->show_submenu_indicator)
 552         {
 553           shadow_type = GTK_SHADOW_OUT;
 554           if (state_type == GTK_STATE_PRELIGHT)
 555             shadow_type = GTK_SHADOW_IN;
 556
 557           gtk_paint_arrow (widget->style, widget->window,
 558                            state_type, shadow_type,
 559                            area, widget, "menuitem",
 560                            GTK_ARROW_RIGHT, TRUE,
 561                            x + width - 15, y + height / 2 - 5, 10, 10);
 562         }
 563       else if (!GTK_BIN (menu_item)->child)
 564         {
 565            gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
 566                             area, widget, "menuitem",
 567                             0, widget->allocation.width, 0);
 568         }
 569     }
 570 }
 571
 572 static gint
 573 gtk_menu_item_expose (GtkWidget      *widget,
 574                       GdkEventExpose *event)
 575 {
 576   g_return_val_if_fail (widget != NULL, FALSE);
 577   g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
 578   g_return_val_if_fail (event != NULL, FALSE);
 579
 580   if (GTK_WIDGET_DRAWABLE (widget))
 581     {
 582       gtk_menu_item_paint (widget, &event->area);
 583
 584       (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
 585     }
 586
 587   return FALSE;
 588 }
 589
 590 static void
 591 gtk_real_menu_item_select (GtkItem *item)
 592 {
 593   GtkMenuItem *menu_item;
 594
 595   g_return_if_fail (item != NULL);
 596   g_return_if_fail (GTK_IS_MENU_ITEM (item));
 597
 598   menu_item = GTK_MENU_ITEM (item);
 599
 600   /*  if (menu_item->submenu && !GTK_WIDGET_VISIBLE (menu_item->submenu))*/
 601   if (menu_item->submenu)
 602     {
 603       guint32 etime;
 604       GdkEvent *event = gtk_get_current_event ();
 605
 606       etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
 607       if (etime >= last_submenu_deselect_time &&
 608           last_submenu_deselect_time + SELECT_TIMEOUT > etime)
 609         menu_item->timer = gtk_timeout_add (SELECT_TIMEOUT - (etime - last_submenu_deselect_time),
 610                                             gtk_menu_item_select_timeout,
 611                                             menu_item);
 612       else
 613         gtk_menu_item_popup_submenu (menu_item);
 614       if (event)
 615         gdk_event_free(event);
 616     }
 617
 618   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_PRELIGHT);
 619   gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
 620 }
 621
 622 static void
 623 gtk_real_menu_item_deselect (GtkItem *item)
 624 {
 625   GtkMenuItem *menu_item;
 626
 627   g_return_if_fail (item != NULL);
 628   g_return_if_fail (GTK_IS_MENU_ITEM (item));
 629
 630   menu_item = GTK_MENU_ITEM (item);
 631
 632   if (menu_item->submenu)
 633     {
 634       guint32 etime;
 635       GdkEvent *event = gtk_get_current_event ();
 636
 637       if (menu_item->timer)
 638         {
 639           gtk_timeout_remove (menu_item->timer);
 640           menu_item->timer = 0;
 641         }
 642       else
 643         gtk_menu_popdown (GTK_MENU (menu_item->submenu));
 644
 645       etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
 646       if (etime > last_submenu_deselect_time)
 647         last_submenu_deselect_time = etime;
 648       if (event)
 649         gdk_event_free(event);
 650     }
 651
 652   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_NORMAL);
 653   gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
 654 }
 655
 656 static gboolean
 657 gtk_menu_item_mnemonic_activate (GtkWidget *widget,
 658                                  gboolean   group_cycling)
 659 {
 660   if (group_cycling)
 661     {
 662       if (widget->parent &&
 663           GTK_IS_MENU_SHELL (widget->parent))
 664         gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent),
 665                                     widget);
 666
 667     }
 668   else
 669     gtk_signal_emit (GTK_OBJECT (widget), menu_item_signals[ACTIVATE_ITEM]);
 670
 671   return TRUE;
 672 }
 673
 674
 675 static void
 676 gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
 677 {
 678   GtkWidget *widget;
 679   GtkMenuShell *submenu;
 680
 681   g_return_if_fail (menu_item != NULL);
 682   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 683
 684   widget = GTK_WIDGET (menu_item);
 685
 686   if (widget->parent &&
 687       GTK_IS_MENU_SHELL (widget->parent))
 688     {
 689       if (menu_item->submenu == NULL)
 690         gtk_menu_shell_activate_item (GTK_MENU_SHELL (widget->parent),
 691                                       widget, TRUE);
 692       else
 693         {
 694           GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget->parent);
 695
 696           if (!menu_shell->active)
 697             {
 698               gtk_grab_add (GTK_WIDGET (menu_shell));
 699               menu_shell->have_grab = TRUE;
 700               menu_shell->active = TRUE;
 701             }
 702
 703           gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent), widget);
 704           gtk_menu_item_popup_submenu (widget);
 705
 706           submenu = GTK_MENU_SHELL (menu_item->submenu);
 707           if (submenu->children)
 708             gtk_menu_shell_select_item (submenu, submenu->children->data);
 709         }
 710     }
 711 }
 712 static void
 713 gtk_real_menu_item_toggle_size_request (GtkMenuItem *menu_item,
 714                                         gint        *requisition)
 715 {
 716   g_return_if_fail (menu_item != NULL);
 717   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 718
 719   *requisition = 0;
 720 }
 721
 722 static void
 723 gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
 724                                          gint         allocation)
 725 {
 726   g_return_if_fail (menu_item != NULL);
 727   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 728
 729   menu_item->toggle_size = allocation;
 730 }
 731
 732 static gint
 733 gtk_menu_item_select_timeout (gpointer data)
 734 {
 735   GDK_THREADS_ENTER ();
 736
 737   gtk_menu_item_popup_submenu (data);
 738
 739   GDK_THREADS_LEAVE ();
 740
 741   return FALSE;
 742 }
 743
 744 static void
 745 gtk_menu_item_popup_submenu (gpointer data)
 746 {
 747   GtkMenuItem *menu_item;
 748
 749   menu_item = GTK_MENU_ITEM (data);
 750   menu_item->timer = 0;
 751
 752   if (GTK_WIDGET_IS_SENSITIVE (menu_item->submenu))
 753     {
 754       gtk_menu_popup (GTK_MENU (menu_item->submenu),
 755                       GTK_WIDGET (menu_item)->parent,
 756                       GTK_WIDGET (menu_item),
 757                       gtk_menu_item_position_menu,
 758                       menu_item,
 759                       GTK_MENU_SHELL (GTK_WIDGET (menu_item)->parent)->button,
 760                       0);
 761     }
 762 }
 763
 764 static void
 765 gtk_menu_item_position_menu (GtkMenu  *menu,
 766                              gint     *x,
 767                              gint     *y,
 768                              gboolean *push_in,
 769                              gpointer  user_data)
 770 {
 771   GtkMenuItem *menu_item;
 772   GtkWidget *parent_menu_item;
 773   gint screen_width;
 774   gint screen_height;
 775   gint twidth, theight;
 776   gint tx, ty;
 777
 778   g_return_if_fail (menu != NULL);
 779   g_return_if_fail (x != NULL);
 780   g_return_if_fail (y != NULL);
 781
 782   menu_item = GTK_MENU_ITEM (user_data);
 783
 784   twidth = GTK_WIDGET (menu)->requisition.width;
 785   theight = GTK_WIDGET (menu)->requisition.height;
 786
 787   screen_width = gdk_screen_width ();
 788   screen_height = gdk_screen_height ();
 789
 790   if (!gdk_window_get_origin (GTK_WIDGET (menu_item)->window, &tx, &ty))
 791     {
 792       g_warning ("Menu not on screen");
 793       return;
 794     }
 795
 796   switch (menu_item->submenu_placement)
 797     {
 798     case GTK_TOP_BOTTOM:
 799       if ((ty + GTK_WIDGET (menu_item)->allocation.height + theight) <= screen_height)
 800         ty += GTK_WIDGET (menu_item)->allocation.height;
 801       else if ((ty - theight) >= 0)
 802         ty -= theight;
 803       else if (screen_height - (ty + GTK_WIDGET (menu_item)->allocation.height) > ty)
 804         ty += GTK_WIDGET (menu_item)->allocation.height;
 805       else
 806         ty -= theight;
 807       break;
 808
 809     case GTK_LEFT_RIGHT:
 810       menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 811       parent_menu_item = GTK_MENU (GTK_WIDGET (menu_item)->parent)->parent_menu_item;
 812       if (parent_menu_item)
 813         menu_item->submenu_direction = GTK_MENU_ITEM (parent_menu_item)->submenu_direction;
 814
 815       switch (menu_item->submenu_direction)
 816         {
 817         case GTK_DIRECTION_LEFT:
 818           if ((tx - twidth) >= 0)
 819             tx -= twidth;
 820           else
 821             {
 822               menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 823               tx += GTK_WIDGET (menu_item)->allocation.width - 5;
 824             }
 825           break;
 826
 827         case GTK_DIRECTION_RIGHT:
 828           if ((tx + GTK_WIDGET (menu_item)->allocation.width + twidth - 5) <= screen_width)
 829             tx += GTK_WIDGET (menu_item)->allocation.width - 5;
 830           else
 831             {
 832               menu_item->submenu_direction = GTK_DIRECTION_LEFT;
 833               tx -= twidth;
 834             }
 835           break;
 836         }
 837
 838       ty += GTK_WIDGET (menu_item)->allocation.height / 4;
 839
 840       /* If the height of the menu doesn't fit we move it upward. */
 841       ty = CLAMP (ty, 0, MAX (0, screen_height - theight));
 842       break;
 843     }
 844
 845   /* If we have negative, tx, here it is because we can't get
 846    * the menu all the way on screen. Favor the left portion.
 847    */
 848   *x = CLAMP (tx, 0, MAX (0, screen_width - twidth));
 849   *y = ty;
 850 }
 851
 852 void
 853 gtk_menu_item_right_justify (GtkMenuItem *menuitem)
 854 {
 855   g_return_if_fail (menuitem != NULL);
 856   g_return_if_fail (GTK_IS_MENU_ITEM (menuitem));
 857
 858   menuitem->right_justify = 1;
 859 }
 860
 861
 862 static void
 863 gtk_menu_item_show_all (GtkWidget *widget)
 864 {
 865   GtkMenuItem *menu_item;
 866
 867   g_return_if_fail (widget != NULL);
 868   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 869
 870   menu_item = GTK_MENU_ITEM (widget);
 871
 872   /* show children including submenu */
 873   if (menu_item->submenu)
 874     gtk_widget_show_all (menu_item->submenu);
 875   gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);
 876
 877   gtk_widget_show (widget);
 878 }
 879
 880 static void
 881 gtk_menu_item_hide_all (GtkWidget *widget)
 882 {
 883   GtkMenuItem *menu_item;
 884
 885   g_return_if_fail (widget != NULL);
 886   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 887
 888   gtk_widget_hide (widget);
 889
 890   menu_item = GTK_MENU_ITEM (widget);
 891
 892   /* hide children including submenu */
 893   gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
 894   if (menu_item->submenu)
 895     gtk_widget_hide_all (menu_item->submenu);
 896 }
 897
 898 static void
 899 gtk_menu_item_forall (GtkContainer *container,
 900                       gboolean      include_internals,
 901                       GtkCallback   callback,
 902                       gpointer      callback_data)
 903 {
 904   GtkBin *bin;
 905   GtkMenuItem *menu_item;
 906
 907   g_return_if_fail (container != NULL);
 908   g_return_if_fail (GTK_IS_MENU_ITEM (container));
 909   g_return_if_fail (callback != NULL);
 910
 911   bin = GTK_BIN (container);
 912   menu_item = GTK_MENU_ITEM (container);
 913
 914   if (bin->child)
 915     (* callback) (bin->child, callback_data);
 916 }