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