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 Library 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  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library 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 #include <string.h>
  20 #include "gtkaccellabel.h"
  21 #include "gtkmain.h"
  22 #include "gtkprivate.h"
  23 #include "gtkmenu.h"
  24 #include "gtkmenubar.h"
  25 #include "gtkmenuitem.h"
  26 #include "gtksignal.h"
  27
  28
  29 #define BORDER_SPACING  3
  30 #define SELECT_TIMEOUT  75
  31
  32 #define MENU_ITEM_CLASS(w)  GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
  33
  34
  35 enum {
  36   ACTIVATE,
  37   ACTIVATE_ITEM,
  38   LAST_SIGNAL
  39 };
  40
  41
  42 static void gtk_menu_item_class_init     (GtkMenuItemClass *klass);
  43 static void gtk_menu_item_init           (GtkMenuItem      *menu_item);
  44 static void gtk_menu_item_destroy        (GtkObject        *object);
  45 static void gtk_menu_item_size_request   (GtkWidget        *widget,
  46                                           GtkRequisition   *requisition);
  47 static void gtk_menu_item_size_allocate  (GtkWidget        *widget,
  48                                           GtkAllocation    *allocation);
  49 static void gtk_menu_item_paint          (GtkWidget        *widget,
  50                                           GdkRectangle     *area);
  51 static void gtk_menu_item_draw           (GtkWidget        *widget,
  52                                           GdkRectangle     *area);
  53 static gint gtk_menu_item_expose         (GtkWidget        *widget,
  54                                           GdkEventExpose   *event);
  55 static void gtk_real_menu_item_select    (GtkItem          *item);
  56 static void gtk_real_menu_item_deselect  (GtkItem          *item);
  57 static void gtk_real_menu_item_activate_item  (GtkMenuItem      *item);
  58 static gint gtk_menu_item_select_timeout (gpointer          data);
  59 static void gtk_menu_item_position_menu  (GtkMenu          *menu,
  60                                           gint             *x,
  61                                           gint             *y,
  62                                           gpointer          user_data);
  63 static void gtk_menu_item_show_all       (GtkWidget        *widget);
  64 static void gtk_menu_item_hide_all       (GtkWidget        *widget);
  65 static void gtk_menu_item_forall         (GtkContainer    *container,
  66                                           gboolean         include_internals,
  67                                           GtkCallback      callback,
  68                                           gpointer         callback_data);
  69
  70 static GtkItemClass *parent_class;
  71 static guint menu_item_signals[LAST_SIGNAL] = { 0 };
  72 static guint32  last_submenu_deselect_time = 0;
  73
  74
  75
  76 GtkType
  77 gtk_menu_item_get_type (void)
  78 {
  79   static GtkType menu_item_type = 0;
  80
  81   if (!menu_item_type)
  82     {
  83       static const GtkTypeInfo menu_item_info =
  84       {
  85         "GtkMenuItem",
  86         sizeof (GtkMenuItem),
  87         sizeof (GtkMenuItemClass),
  88         (GtkClassInitFunc) gtk_menu_item_class_init,
  89         (GtkObjectInitFunc) gtk_menu_item_init,
  90         /* reserved_1 */ NULL,
  91         /* reserved_2 */ NULL,
  92         (GtkClassInitFunc) NULL,
  93       };
  94
  95       menu_item_type = gtk_type_unique (gtk_item_get_type (), &menu_item_info);
  96       gtk_type_set_chunk_alloc (menu_item_type, 16);
  97     }
  98
  99   return menu_item_type;
 100 }
 101
 102 static void
 103 gtk_menu_item_class_init (GtkMenuItemClass *klass)
 104 {
 105   GtkObjectClass *object_class;
 106   GtkWidgetClass *widget_class;
 107   GtkContainerClass *container_class;
 108   GtkItemClass *item_class;
 109
 110   object_class = (GtkObjectClass*) klass;
 111   widget_class = (GtkWidgetClass*) klass;
 112   container_class = (GtkContainerClass*) klass;
 113   item_class = (GtkItemClass*) klass;
 114
 115   parent_class = gtk_type_class (gtk_item_get_type ());
 116
 117   menu_item_signals[ACTIVATE] =
 118     gtk_signal_new ("activate",
 119                     GTK_RUN_FIRST | GTK_RUN_ACTION,
 120                     object_class->type,
 121                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate),
 122                     gtk_marshal_NONE__NONE,
 123                     GTK_TYPE_NONE, 0);
 124
 125   menu_item_signals[ACTIVATE_ITEM] =
 126     gtk_signal_new ("activate_item",
 127                     GTK_RUN_FIRST,
 128                     object_class->type,
 129                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate_item),
 130                     gtk_signal_default_marshaller,
 131                     GTK_TYPE_NONE, 0);
 132
 133   gtk_object_class_add_signals (object_class, menu_item_signals, LAST_SIGNAL);
 134
 135   object_class->destroy = gtk_menu_item_destroy;
 136
 137   widget_class->activate_signal = menu_item_signals[ACTIVATE];
 138   widget_class->size_request = gtk_menu_item_size_request;
 139   widget_class->size_allocate = gtk_menu_item_size_allocate;
 140   widget_class->draw = gtk_menu_item_draw;
 141   widget_class->expose_event = gtk_menu_item_expose;
 142   widget_class->show_all = gtk_menu_item_show_all;
 143   widget_class->hide_all = gtk_menu_item_hide_all;
 144
 145   container_class->forall = gtk_menu_item_forall;
 146
 147   item_class->select = gtk_real_menu_item_select;
 148   item_class->deselect = gtk_real_menu_item_deselect;
 149
 150   klass->activate = NULL;
 151   klass->activate_item = gtk_real_menu_item_activate_item;
 152
 153   klass->toggle_size = 0;
 154   klass->hide_on_activate = TRUE;
 155 }
 156
 157 static void
 158 gtk_menu_item_init (GtkMenuItem *menu_item)
 159 {
 160   menu_item->submenu = NULL;
 161   menu_item->accelerator_signal = menu_item_signals[ACTIVATE];
 162   menu_item->toggle_size = 0;
 163   menu_item->accelerator_width = 0;
 164   menu_item->show_toggle_indicator = FALSE;
 165   menu_item->show_submenu_indicator = FALSE;
 166   menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 167   menu_item->submenu_placement = GTK_TOP_BOTTOM;
 168   menu_item->right_justify = FALSE;
 169
 170   menu_item->timer = 0;
 171 }
 172
 173 GtkWidget*
 174 gtk_menu_item_new (void)
 175 {
 176   return GTK_WIDGET (gtk_type_new (gtk_menu_item_get_type ()));
 177 }
 178
 179 GtkWidget*
 180 gtk_menu_item_new_with_label (const gchar *label)
 181 {
 182   GtkWidget *menu_item;
 183   GtkWidget *accel_label;
 184
 185   menu_item = gtk_menu_item_new ();
 186   accel_label = gtk_accel_label_new (label);
 187   gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
 188
 189   gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
 190   gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
 191   gtk_widget_show (accel_label);
 192
 193   return menu_item;
 194 }
 195
 196 static void
 197 gtk_menu_item_destroy (GtkObject *object)
 198 {
 199   GtkMenuItem *menu_item;
 200
 201   g_return_if_fail (object != NULL);
 202   g_return_if_fail (GTK_IS_MENU_ITEM (object));
 203
 204   menu_item = GTK_MENU_ITEM (object);
 205
 206   if (menu_item->submenu)
 207     gtk_widget_destroy (menu_item->submenu);
 208
 209   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 210     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 211 }
 212
 213 static void
 214 gtk_menu_item_detacher (GtkWidget     *widget,
 215                         GtkMenu       *menu)
 216 {
 217   GtkMenuItem *menu_item;
 218
 219   g_return_if_fail (widget != NULL);
 220   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 221
 222   menu_item = GTK_MENU_ITEM (widget);
 223   g_return_if_fail (menu_item->submenu == (GtkWidget*) menu);
 224
 225   menu_item->submenu = NULL;
 226 }
 227
 228 void
 229 gtk_menu_item_set_submenu (GtkMenuItem *menu_item,
 230                            GtkWidget   *submenu)
 231 {
 232   g_return_if_fail (menu_item != NULL);
 233   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 234
 235   if (menu_item->submenu != submenu)
 236     {
 237       gtk_menu_item_remove_submenu (menu_item);
 238
 239       menu_item->submenu = submenu;
 240       gtk_menu_attach_to_widget (GTK_MENU (submenu),
 241                                  GTK_WIDGET (menu_item),
 242                                  gtk_menu_item_detacher);
 243
 244       if (GTK_WIDGET (menu_item)->parent)
 245         gtk_widget_queue_resize (GTK_WIDGET (menu_item));
 246     }
 247 }
 248
 249 void
 250 gtk_menu_item_remove_submenu (GtkMenuItem         *menu_item)
 251 {
 252   g_return_if_fail (menu_item != NULL);
 253   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 254
 255   if (menu_item->submenu)
 256     gtk_menu_detach (GTK_MENU (menu_item->submenu));
 257 }
 258
 259 void
 260 gtk_menu_item_set_placement (GtkMenuItem         *menu_item,
 261                              GtkSubmenuPlacement  placement)
 262 {
 263   g_return_if_fail (menu_item != NULL);
 264   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 265
 266   menu_item->submenu_placement = placement;
 267 }
 268
 269 void
 270 gtk_menu_item_configure (GtkMenuItem *menu_item,
 271                          gint         show_toggle_indicator,
 272                          gint         show_submenu_indicator)
 273 {
 274   g_return_if_fail (menu_item != NULL);
 275   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 276
 277   menu_item->show_toggle_indicator = (show_toggle_indicator == TRUE);
 278   menu_item->show_submenu_indicator = (show_submenu_indicator == TRUE);
 279 }
 280
 281 void
 282 gtk_menu_item_select (GtkMenuItem *menu_item)
 283 {
 284   g_return_if_fail (menu_item != NULL);
 285   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 286
 287   gtk_item_select (GTK_ITEM (menu_item));
 288 }
 289
 290 void
 291 gtk_menu_item_deselect (GtkMenuItem *menu_item)
 292 {
 293   g_return_if_fail (menu_item != NULL);
 294   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 295
 296   gtk_item_deselect (GTK_ITEM (menu_item));
 297 }
 298
 299 void
 300 gtk_menu_item_activate (GtkMenuItem *menu_item)
 301 {
 302   g_return_if_fail (menu_item != NULL);
 303   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 304
 305   gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[ACTIVATE]);
 306 }
 307
 308 static void
 309 gtk_menu_item_accel_width_foreach (GtkWidget *widget,
 310                                    gpointer data)
 311 {
 312   guint *width = data;
 313
 314   if (GTK_IS_ACCEL_LABEL (widget))
 315     {
 316       guint w;
 317
 318       w = gtk_accel_label_get_accel_width (GTK_ACCEL_LABEL (widget));
 319       *width = MAX (*width, w);
 320     }
 321   else if (GTK_IS_CONTAINER (widget))
 322     gtk_container_foreach (GTK_CONTAINER (widget),
 323                            gtk_menu_item_accel_width_foreach,
 324                            data);
 325 }
 326
 327 static void
 328 gtk_menu_item_size_request (GtkWidget      *widget,
 329                             GtkRequisition *requisition)
 330 {
 331   GtkMenuItem *menu_item;
 332   GtkBin *bin;
 333   guint accel_width;
 334
 335   g_return_if_fail (widget != NULL);
 336   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 337   g_return_if_fail (requisition != NULL);
 338
 339   bin = GTK_BIN (widget);
 340   menu_item = GTK_MENU_ITEM (widget);
 341
 342   requisition->width = (GTK_CONTAINER (widget)->border_width +
 343                         widget->style->klass->xthickness +
 344                         BORDER_SPACING) * 2;
 345   requisition->height = (GTK_CONTAINER (widget)->border_width +
 346                          widget->style->klass->ythickness) * 2;
 347
 348   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 349     {
 350       gtk_widget_size_request (bin->child, &bin->child->requisition);
 351
 352       requisition->width += bin->child->requisition.width;
 353       requisition->height += bin->child->requisition.height;
 354     }
 355
 356   if (menu_item->submenu && menu_item->show_submenu_indicator)
 357     requisition->width += 21;
 358
 359   accel_width = 0;
 360   gtk_container_foreach (GTK_CONTAINER (menu_item),
 361                          gtk_menu_item_accel_width_foreach,
 362                          &accel_width);
 363   menu_item->accelerator_width = accel_width;
 364 }
 365
 366 static void
 367 gtk_menu_item_size_allocate (GtkWidget     *widget,
 368                              GtkAllocation *allocation)
 369 {
 370   GtkMenuItem *menu_item;
 371   GtkBin *bin;
 372   GtkAllocation child_allocation;
 373
 374   g_return_if_fail (widget != NULL);
 375   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 376   g_return_if_fail (allocation != NULL);
 377
 378   menu_item = GTK_MENU_ITEM (widget);
 379   bin = GTK_BIN (widget);
 380
 381   widget->allocation = *allocation;
 382
 383   if (bin->child)
 384     {
 385       child_allocation.x = (GTK_CONTAINER (widget)->border_width +
 386                             widget->style->klass->xthickness +
 387                             BORDER_SPACING);
 388       child_allocation.y = (GTK_CONTAINER (widget)->border_width +
 389                             widget->style->klass->ythickness);
 390       child_allocation.width = MAX (1, allocation->width - child_allocation.x * 2);
 391       child_allocation.height = MAX (1, allocation->height - child_allocation.y * 2);
 392       child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
 393       child_allocation.width -= GTK_MENU_ITEM (widget)->toggle_size;
 394       if (menu_item->submenu && menu_item->show_submenu_indicator)
 395         child_allocation.width -= 21;
 396
 397       gtk_widget_size_allocate (bin->child, &child_allocation);
 398     }
 399
 400   if (GTK_WIDGET_REALIZED (widget))
 401     gdk_window_move_resize (widget->window,
 402                             allocation->x, allocation->y,
 403                             allocation->width, allocation->height);
 404
 405   if (menu_item->submenu)
 406     gtk_menu_reposition (GTK_MENU (menu_item->submenu));
 407 }
 408
 409 static void
 410 gtk_menu_item_paint (GtkWidget    *widget,
 411                      GdkRectangle *area)
 412 {
 413   GtkMenuItem *menu_item;
 414   GtkStateType state_type;
 415   GtkShadowType shadow_type;
 416   gint width, height;
 417   gint x, y;
 418
 419   g_return_if_fail (widget != NULL);
 420   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 421
 422   if (GTK_WIDGET_DRAWABLE (widget))
 423     {
 424       menu_item = GTK_MENU_ITEM (widget);
 425
 426       state_type = widget->state;
 427       if (!GTK_WIDGET_IS_SENSITIVE (widget))
 428         state_type = GTK_STATE_INSENSITIVE;
 429
 430       x = GTK_CONTAINER (menu_item)->border_width;
 431       y = GTK_CONTAINER (menu_item)->border_width;
 432       width = widget->allocation.width - x * 2;
 433       height = widget->allocation.height - y * 2;
 434
 435       if ((state_type == GTK_STATE_PRELIGHT) &&
 436           (GTK_BIN (menu_item)->child))
 437         gtk_paint_box (widget->style,
 438                        widget->window,
 439                        GTK_STATE_PRELIGHT,
 440                        GTK_SHADOW_OUT,
 441                        area, widget, "menuitem",
 442                        x, y, width, height);
 443       else
 444         {
 445           gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
 446           gdk_window_clear_area (widget->window, area->x, area->y, area->width, area->height);
 447         }
 448
 449       if (menu_item->submenu && menu_item->show_submenu_indicator)
 450         {
 451           shadow_type = GTK_SHADOW_OUT;
 452           if (state_type == GTK_STATE_PRELIGHT)
 453             shadow_type = GTK_SHADOW_IN;
 454
 455           gtk_paint_arrow (widget->style, widget->window,
 456                            state_type, shadow_type,
 457                            area, widget, "menuitem",
 458                            GTK_ARROW_RIGHT, TRUE,
 459                            x + width - 15, y + height / 2 - 5, 10, 10);
 460         }
 461       else if (!GTK_BIN (menu_item)->child)
 462         {
 463            gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
 464                             area, widget, "menuitem",
 465                             0, widget->allocation.width, 0);
 466         }
 467     }
 468 }
 469
 470 static void
 471 gtk_menu_item_draw (GtkWidget    *widget,
 472                     GdkRectangle *area)
 473 {
 474   GtkBin *bin;
 475   GdkRectangle child_area;
 476
 477   g_return_if_fail (widget != NULL);
 478   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 479   g_return_if_fail (area != NULL);
 480
 481   if (GTK_WIDGET_DRAWABLE (widget))
 482     {
 483       gtk_menu_item_paint (widget, area);
 484
 485       bin = GTK_BIN (widget);
 486
 487       if (bin->child)
 488         {
 489           if (gtk_widget_intersect (bin->child, area, &child_area))
 490             gtk_widget_draw (bin->child, &child_area);
 491         }
 492     }
 493 }
 494
 495 static gint
 496 gtk_menu_item_expose (GtkWidget      *widget,
 497                       GdkEventExpose *event)
 498 {
 499   GtkBin *bin;
 500   GdkEventExpose child_event;
 501
 502   g_return_val_if_fail (widget != NULL, FALSE);
 503   g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
 504   g_return_val_if_fail (event != NULL, FALSE);
 505
 506   if (GTK_WIDGET_DRAWABLE (widget))
 507     {
 508       gtk_menu_item_paint (widget, &event->area);
 509
 510       bin = GTK_BIN (widget);
 511
 512       if (bin->child)
 513         {
 514           child_event = *event;
 515
 516           if (GTK_WIDGET_NO_WINDOW (bin->child) &&
 517               gtk_widget_intersect (bin->child, &event->area, &child_event.area))
 518             gtk_widget_event (bin->child, (GdkEvent*) &child_event);
 519         }
 520     }
 521
 522   return FALSE;
 523 }
 524
 525 static void
 526 gtk_real_menu_item_select (GtkItem *item)
 527 {
 528   GtkMenuItem *menu_item;
 529
 530   g_return_if_fail (item != NULL);
 531   g_return_if_fail (GTK_IS_MENU_ITEM (item));
 532
 533   menu_item = GTK_MENU_ITEM (item);
 534
 535   /*  if (menu_item->submenu && !GTK_WIDGET_VISIBLE (menu_item->submenu))*/
 536   if (menu_item->submenu)
 537     {
 538       guint32 etime;
 539       GdkEvent *event = gtk_get_current_event ();
 540
 541       etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
 542       if (etime >= last_submenu_deselect_time &&
 543           last_submenu_deselect_time + SELECT_TIMEOUT > etime)
 544         menu_item->timer = gtk_timeout_add (SELECT_TIMEOUT - (etime - last_submenu_deselect_time),
 545                                             gtk_menu_item_select_timeout,
 546                                             menu_item);
 547       else
 548         gtk_menu_item_select_timeout (menu_item);
 549     }
 550
 551   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_PRELIGHT);
 552   gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
 553 }
 554
 555 static void
 556 gtk_real_menu_item_deselect (GtkItem *item)
 557 {
 558   GtkMenuItem *menu_item;
 559
 560   g_return_if_fail (item != NULL);
 561   g_return_if_fail (GTK_IS_MENU_ITEM (item));
 562
 563   menu_item = GTK_MENU_ITEM (item);
 564
 565   if (menu_item->submenu)
 566     {
 567       guint32 etime;
 568       GdkEvent *event = gtk_get_current_event ();
 569
 570       if (menu_item->timer)
 571         {
 572           gtk_timeout_remove (menu_item->timer);
 573           menu_item->timer = 0;
 574         }
 575       else
 576         gtk_menu_popdown (GTK_MENU (menu_item->submenu));
 577
 578       etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
 579       if (etime > last_submenu_deselect_time)
 580         last_submenu_deselect_time = etime;
 581     }
 582
 583   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_NORMAL);
 584   gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
 585 }
 586
 587 static void
 588 gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
 589 {
 590   GtkWidget *widget;
 591
 592   g_return_if_fail (menu_item != NULL);
 593   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 594
 595   widget = GTK_WIDGET (menu_item);
 596
 597   if (widget->parent &&
 598       GTK_IS_MENU_SHELL (widget->parent))
 599     {
 600       if (menu_item->submenu == NULL)
 601         gtk_menu_shell_activate_item (GTK_MENU_SHELL (widget->parent),
 602                                       widget, TRUE);
 603       else
 604         {
 605           GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget->parent);
 606
 607           if (!menu_shell->active)
 608             {
 609               gtk_grab_add (GTK_WIDGET (menu_shell));
 610               menu_shell->have_grab = TRUE;
 611               menu_shell->active = TRUE;
 612             }
 613
 614           gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent), widget);
 615         }
 616     }
 617 }
 618
 619 static gint
 620 gtk_menu_item_select_timeout (gpointer data)
 621 {
 622   GtkMenuItem *menu_item;
 623
 624   GTK_THREADS_ENTER ();
 625
 626   menu_item = GTK_MENU_ITEM (data);
 627   menu_item->timer = 0;
 628
 629   gtk_menu_popup (GTK_MENU (menu_item->submenu),
 630                   GTK_WIDGET (menu_item)->parent,
 631                   GTK_WIDGET (menu_item),
 632                   gtk_menu_item_position_menu,
 633                   menu_item,
 634                   GTK_MENU_SHELL (GTK_WIDGET (menu_item)->parent)->button,
 635                   0);
 636
 637   /* This is a bit of a hack - we want to select the first item
 638    * of menus hanging of a menu bar, but not for cascading submenus
 639    */
 640   if (GTK_IS_MENU_BAR (GTK_WIDGET (menu_item)->parent))
 641     {
 642       GtkMenuShell *submenu = GTK_MENU_SHELL (menu_item->submenu);
 643       if (submenu->children)
 644         gtk_menu_shell_select_item (submenu, submenu->children->data);
 645     }
 646
 647   GTK_THREADS_LEAVE ();
 648
 649   return FALSE;
 650 }
 651
 652 static void
 653 gtk_menu_item_position_menu (GtkMenu  *menu,
 654                              gint     *x,
 655                              gint     *y,
 656                              gpointer  user_data)
 657 {
 658   GtkMenuItem *menu_item;
 659   GtkWidget *parent_menu_item;
 660   gint screen_width;
 661   gint screen_height;
 662   gint twidth, theight;
 663   gint tx, ty;
 664
 665   g_return_if_fail (menu != NULL);
 666   g_return_if_fail (x != NULL);
 667   g_return_if_fail (y != NULL);
 668
 669   menu_item = GTK_MENU_ITEM (user_data);
 670
 671   twidth = GTK_WIDGET (menu)->requisition.width;
 672   theight = GTK_WIDGET (menu)->requisition.height;
 673
 674   screen_width = gdk_screen_width ();
 675   screen_height = gdk_screen_height ();
 676
 677   if (!gdk_window_get_origin (GTK_WIDGET (menu_item)->window, &tx, &ty))
 678     {
 679       g_warning ("Menu not on screen");
 680       return;
 681     }
 682
 683   switch (menu_item->submenu_placement)
 684     {
 685     case GTK_TOP_BOTTOM:
 686       if ((ty + GTK_WIDGET (menu_item)->allocation.height + theight) <= screen_height)
 687         ty += GTK_WIDGET (menu_item)->allocation.height;
 688       else if ((ty - theight) >= 0)
 689         ty -= theight;
 690       else
 691         ty += GTK_WIDGET (menu_item)->allocation.height;
 692
 693       if ((tx + twidth) > screen_width)
 694         {
 695           tx -= ((tx + twidth) - screen_width);
 696           if (tx < 0)
 697             tx = 0;
 698         }
 699       break;
 700
 701     case GTK_LEFT_RIGHT:
 702       menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 703       parent_menu_item = GTK_MENU (GTK_WIDGET (menu_item)->parent)->parent_menu_item;
 704       if (parent_menu_item)
 705         menu_item->submenu_direction = GTK_MENU_ITEM (parent_menu_item)->submenu_direction;
 706
 707       switch (menu_item->submenu_direction)
 708         {
 709         case GTK_DIRECTION_LEFT:
 710           if ((tx - twidth) >= 0)
 711             tx -= twidth;
 712           else
 713             {
 714               menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 715               tx += GTK_WIDGET (menu_item)->allocation.width - 5;
 716             }
 717           break;
 718
 719         case GTK_DIRECTION_RIGHT:
 720           if ((tx + GTK_WIDGET (menu_item)->allocation.width + twidth - 5) <= screen_width)
 721             tx += GTK_WIDGET (menu_item)->allocation.width - 5;
 722           else
 723             {
 724               menu_item->submenu_direction = GTK_DIRECTION_LEFT;
 725               tx -= twidth;
 726             }
 727           break;
 728         }
 729
 730       if ((ty + GTK_WIDGET (menu_item)->allocation.height / 4 + theight) <= screen_height)
 731         ty += GTK_WIDGET (menu_item)->allocation.height / 4;
 732       else
 733         {
 734           ty -= ((ty + theight) - screen_height);
 735           if (ty < 0)
 736             ty = 0;
 737         }
 738       break;
 739     }
 740
 741   *x = tx;
 742   *y = ty;
 743 }
 744
 745 void
 746 gtk_menu_item_right_justify(GtkMenuItem *menuitem)
 747 {
 748   g_return_if_fail (menuitem != NULL);
 749   g_return_if_fail (GTK_IS_MENU_ITEM (menuitem));
 750
 751   menuitem->right_justify = 1;
 752 }
 753
 754
 755 static void
 756 gtk_menu_item_show_all (GtkWidget *widget)
 757 {
 758   GtkMenuItem *menu_item;
 759
 760   g_return_if_fail (widget != NULL);
 761   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 762
 763   menu_item = GTK_MENU_ITEM (widget);
 764
 765   /* show children including submenu */
 766   if (menu_item->submenu)
 767     gtk_widget_show_all (menu_item->submenu);
 768   gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);
 769
 770   gtk_widget_show (widget);
 771 }
 772
 773 static void
 774 gtk_menu_item_hide_all (GtkWidget *widget)
 775 {
 776   GtkMenuItem *menu_item;
 777
 778   g_return_if_fail (widget != NULL);
 779   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 780
 781   gtk_widget_hide (widget);
 782
 783   menu_item = GTK_MENU_ITEM (widget);
 784
 785   /* hide children including submenu */
 786   gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
 787   if (menu_item->submenu)
 788     gtk_widget_hide_all (menu_item->submenu);
 789 }
 790
 791 static void
 792 gtk_menu_item_forall (GtkContainer *container,
 793                       gboolean      include_internals,
 794                       GtkCallback   callback,
 795                       gpointer      callback_data)
 796 {
 797   GtkBin *bin;
 798   GtkMenuItem *menu_item;
 799
 800   g_return_if_fail (container != NULL);
 801   g_return_if_fail (GTK_IS_MENU_ITEM (container));
 802   g_return_if_fail (callback != NULL);
 803
 804   bin = GTK_BIN (container);
 805   menu_item = GTK_MENU_ITEM (container);
 806
 807   if (bin->child)
 808     (* callback) (bin->child, callback_data);
 809   if (include_internals && menu_item->submenu)
 810     (* callback) (menu_item->submenu, callback_data);
 811 }