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