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

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