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