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