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