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 Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18 #include <string.h>
  19 #include "gtklabel.h"
  20 #include "gtkmain.h"
  21 #include "gtkmenu.h"
  22 #include "gtkmenuitem.h"
  23 #include "gtksignal.h"
  24
  25
  26 #define BORDER_SPACING  3
  27 #define SELECT_TIMEOUT  20
  28
  29 #define MENU_ITEM_CLASS(w)  GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
  30
  31
  32 enum {
  33   ACTIVATE,
  34   LAST_SIGNAL
  35 };
  36
  37
  38 static void gtk_menu_item_class_init     (GtkMenuItemClass *klass);
  39 static void gtk_menu_item_init           (GtkMenuItem      *menu_item);
  40 static void gtk_menu_item_destroy        (GtkObject        *object);
  41 static void gtk_menu_item_size_request   (GtkWidget        *widget,
  42                                           GtkRequisition   *requisition);
  43 static void gtk_menu_item_size_allocate  (GtkWidget        *widget,
  44                                           GtkAllocation    *allocation);
  45 static gint gtk_menu_item_install_accel  (GtkWidget        *widget,
  46                                           const gchar      *signal_name,
  47                                           gchar             key,
  48                                           guint8            modifiers);
  49 static void gtk_menu_item_remove_accel   (GtkWidget        *widget,
  50                                           const gchar      *signal_name);
  51 static void gtk_menu_item_paint          (GtkWidget        *widget,
  52                                           GdkRectangle     *area);
  53 static void gtk_menu_item_draw           (GtkWidget        *widget,
  54                                           GdkRectangle     *area);
  55 static gint gtk_menu_item_expose         (GtkWidget        *widget,
  56                                           GdkEventExpose   *event);
  57 static gint gtk_menu_item_enter          (GtkWidget        *widget,
  58                                           GdkEventCrossing *event);
  59 static gint gtk_menu_item_leave          (GtkWidget        *widget,
  60                                           GdkEventCrossing *event);
  61 static void gtk_real_menu_item_select    (GtkItem          *item);
  62 static void gtk_real_menu_item_deselect  (GtkItem          *item);
  63 static gint gtk_menu_item_select_timeout (gpointer          data);
  64 static void gtk_menu_item_position_menu  (GtkMenu          *menu,
  65                                           gint             *x,
  66                                           gint             *y,
  67                                           gpointer          user_data);
  68
  69 static GtkItemClass *parent_class;
  70 static gint menu_item_signals[LAST_SIGNAL] = { 0 };
  71
  72
  73 guint
  74 gtk_menu_item_get_type ()
  75 {
  76   static guint 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         (GtkArgFunc) 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->enter_notify_event = gtk_menu_item_enter;
 129   widget_class->leave_notify_event = gtk_menu_item_leave;
 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 ()
 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     {
 195       gtk_object_unref (GTK_OBJECT (menu_item->submenu));
 196       /* gtk_widget_destroy (menu_item->submenu); */
 197     }
 198
 199   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 200     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 201 }
 202
 203 void
 204 gtk_menu_item_set_submenu (GtkMenuItem *menu_item,
 205                            GtkWidget   *submenu)
 206 {
 207   g_return_if_fail (menu_item != NULL);
 208   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 209
 210   if (menu_item->submenu != submenu)
 211     {
 212       if (menu_item->submenu)
 213         {
 214           g_return_if_fail (!GTK_WIDGET_VISIBLE (menu_item->submenu));
 215           gtk_object_unref (GTK_OBJECT (menu_item->submenu));
 216         }
 217       menu_item->submenu = submenu;
 218       if (menu_item->submenu)
 219         gtk_object_ref (GTK_OBJECT (menu_item->submenu));
 220
 221       if (GTK_WIDGET (menu_item)->parent)
 222         gtk_widget_queue_resize (GTK_WIDGET (menu_item));
 223     }
 224 }
 225
 226 void
 227 gtk_menu_item_set_placement (GtkMenuItem         *menu_item,
 228                              GtkSubmenuPlacement  placement)
 229 {
 230   g_return_if_fail (menu_item != NULL);
 231   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 232
 233   menu_item->submenu_placement = placement;
 234 }
 235
 236 void
 237 gtk_menu_item_accelerator_size (GtkMenuItem *menu_item)
 238 {
 239   char buf[32];
 240
 241   g_return_if_fail (menu_item != NULL);
 242   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 243
 244   if (menu_item->accelerator_key)
 245     {
 246       gtk_menu_item_accelerator_text (menu_item, buf);
 247       menu_item->accelerator_size = gdk_string_width (GTK_WIDGET (menu_item)->style->font, buf) + 13;
 248     }
 249   else if (menu_item->submenu && menu_item->show_submenu_indicator)
 250     {
 251       menu_item->accelerator_size = 21;
 252     }
 253   else
 254     {
 255       menu_item->accelerator_size = 0;
 256     }
 257 }
 258
 259 void
 260 gtk_menu_item_accelerator_text (GtkMenuItem *menu_item,
 261                                 gchar       *buffer)
 262 {
 263   g_return_if_fail (menu_item != NULL);
 264   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 265
 266   if (menu_item->accelerator_key)
 267     {
 268       buffer[0] = '\0';
 269       if (menu_item->accelerator_mods & GDK_SHIFT_MASK)
 270         {
 271           strcat (buffer, MENU_ITEM_CLASS (menu_item)->shift_text);
 272           strcat (buffer, MENU_ITEM_CLASS (menu_item)->separator_text);
 273         }
 274       if (menu_item->accelerator_mods & GDK_CONTROL_MASK)
 275         {
 276           strcat (buffer, MENU_ITEM_CLASS (menu_item)->control_text);
 277           strcat (buffer, MENU_ITEM_CLASS (menu_item)->separator_text);
 278         }
 279       if (menu_item->accelerator_mods & GDK_MOD1_MASK)
 280         {
 281           strcat (buffer, MENU_ITEM_CLASS (menu_item)->alt_text);
 282           strcat (buffer, MENU_ITEM_CLASS (menu_item)->separator_text);
 283         }
 284       strncat (buffer, &menu_item->accelerator_key, 1);
 285     }
 286 }
 287
 288 void
 289 gtk_menu_item_configure (GtkMenuItem *menu_item,
 290                          gint         show_toggle_indicator,
 291                          gint         show_submenu_indicator)
 292 {
 293   g_return_if_fail (menu_item != NULL);
 294   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
 295
 296   menu_item->show_toggle_indicator = (show_toggle_indicator == TRUE);
 297   menu_item->show_submenu_indicator = (show_submenu_indicator == TRUE);
 298 }
 299
 300 void
 301 gtk_menu_item_select (GtkMenuItem *menu_item)
 302 {
 303   gtk_item_select (GTK_ITEM (menu_item));
 304 }
 305
 306 void
 307 gtk_menu_item_deselect (GtkMenuItem *menu_item)
 308 {
 309   gtk_item_deselect (GTK_ITEM (menu_item));
 310 }
 311
 312 void
 313 gtk_menu_item_activate (GtkMenuItem *menu_item)
 314 {
 315   gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[ACTIVATE]);
 316 }
 317
 318
 319 static void
 320 gtk_menu_item_size_request (GtkWidget      *widget,
 321                             GtkRequisition *requisition)
 322 {
 323   GtkBin *bin;
 324
 325   g_return_if_fail (widget != NULL);
 326   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 327   g_return_if_fail (requisition != NULL);
 328
 329   bin = GTK_BIN (widget);
 330
 331   gtk_menu_item_accelerator_size (GTK_MENU_ITEM (widget));
 332
 333   requisition->width = (GTK_CONTAINER (widget)->border_width +
 334                         widget->style->klass->xthickness +
 335                         BORDER_SPACING) * 2;
 336   requisition->height = (GTK_CONTAINER (widget)->border_width +
 337                          widget->style->klass->ythickness) * 2;
 338
 339   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
 340     {
 341       gtk_widget_size_request (bin->child, &bin->child->requisition);
 342
 343       requisition->width += bin->child->requisition.width;
 344       requisition->height += bin->child->requisition.height;
 345     }
 346 }
 347
 348 static void
 349 gtk_menu_item_size_allocate (GtkWidget     *widget,
 350                              GtkAllocation *allocation)
 351 {
 352   GtkBin *bin;
 353   GtkAllocation child_allocation;
 354
 355   g_return_if_fail (widget != NULL);
 356   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 357   g_return_if_fail (allocation != NULL);
 358
 359   widget->allocation = *allocation;
 360   if (GTK_WIDGET_REALIZED (widget))
 361     gdk_window_move_resize (widget->window,
 362                             allocation->x, allocation->y,
 363                             allocation->width, allocation->height);
 364
 365   bin = GTK_BIN (widget);
 366
 367   if (bin->child)
 368     {
 369       child_allocation.x = (GTK_CONTAINER (widget)->border_width +
 370                             widget->style->klass->xthickness +
 371                             BORDER_SPACING);
 372       child_allocation.y = GTK_CONTAINER (widget)->border_width;
 373       child_allocation.width = allocation->width - child_allocation.x * 2;
 374       child_allocation.height = allocation->height - child_allocation.y * 2;
 375       child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
 376       child_allocation.width -= (GTK_MENU_ITEM (widget)->toggle_size +
 377                                  GTK_MENU_ITEM (widget)->accelerator_size);
 378
 379       gtk_widget_size_allocate (bin->child, &child_allocation);
 380     }
 381 }
 382
 383 static gint
 384 gtk_menu_item_install_accel (GtkWidget   *widget,
 385                              const gchar *signal_name,
 386                              gchar        key,
 387                              guint8       modifiers)
 388 {
 389   GtkMenuItem *menu_item;
 390
 391   g_return_val_if_fail (widget != NULL, FALSE);
 392   g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
 393   g_return_val_if_fail (signal_name != NULL, FALSE);
 394
 395   menu_item = GTK_MENU_ITEM (widget);
 396
 397   menu_item->accelerator_signal = gtk_signal_lookup (signal_name, GTK_OBJECT_TYPE (widget));
 398   if (menu_item->accelerator_signal > 0)
 399     {
 400       menu_item->accelerator_key = key;
 401       menu_item->accelerator_mods = modifiers;
 402
 403       if (widget->parent)
 404         gtk_widget_queue_resize (widget);
 405
 406       return TRUE;
 407     }
 408
 409   return FALSE;
 410 }
 411
 412 static void
 413 gtk_menu_item_remove_accel (GtkWidget   *widget,
 414                             const gchar *signal_name)
 415 {
 416   GtkMenuItem *menu_item;
 417   gint signal_num;
 418
 419   g_return_if_fail (widget != NULL);
 420   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 421   g_return_if_fail (signal_name != NULL);
 422
 423   menu_item = GTK_MENU_ITEM (widget);
 424
 425   signal_num = gtk_signal_lookup (signal_name, GTK_OBJECT_TYPE (widget));
 426   if (menu_item->accelerator_signal == signal_num)
 427     {
 428       menu_item->accelerator_key = 0;
 429       menu_item->accelerator_mods = 0;
 430       menu_item->accelerator_signal = 0;
 431
 432       if (GTK_WIDGET_VISIBLE (widget))
 433         {
 434           gtk_widget_queue_draw (widget);
 435           GTK_MENU_SHELL (widget->parent)->menu_flag = TRUE;
 436         }
 437       else
 438         gtk_container_need_resize (GTK_CONTAINER (widget->parent));
 439     }
 440 }
 441
 442 static void
 443 gtk_menu_item_paint (GtkWidget    *widget,
 444                      GdkRectangle *area)
 445 {
 446   GtkMenuItem *menu_item;
 447   GtkStateType state_type;
 448   GtkShadowType shadow_type;
 449   GdkFont *font;
 450   gint width, height;
 451   gint x, y;
 452   char buf[32];
 453
 454   g_return_if_fail (widget != NULL);
 455   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 456
 457   if (GTK_WIDGET_DRAWABLE (widget))
 458     {
 459       menu_item = GTK_MENU_ITEM (widget);
 460
 461       state_type = widget->state;
 462       if (!GTK_WIDGET_IS_SENSITIVE (widget))
 463         state_type = GTK_STATE_INSENSITIVE;
 464
 465       gtk_style_set_background (widget->style, widget->window, state_type);
 466       gdk_window_clear_area (widget->window, area->x, area->y, area->width, area->height);
 467
 468       x = GTK_CONTAINER (menu_item)->border_width;
 469       y = GTK_CONTAINER (menu_item)->border_width;
 470       width = widget->allocation.width - x * 2;
 471       height = widget->allocation.height - y * 2;
 472
 473       if ((state_type == GTK_STATE_PRELIGHT) &&
 474           (GTK_BIN (menu_item)->child))
 475         gtk_draw_shadow (widget->style,
 476                          widget->window,
 477                          GTK_STATE_PRELIGHT,
 478                          GTK_SHADOW_OUT,
 479                          x, y, width, height);
 480
 481       if (menu_item->accelerator_key)
 482         {
 483           gtk_menu_item_accelerator_text (menu_item, buf);
 484
 485           font = widget->style->font;
 486           x = x + width - menu_item->accelerator_size + 13 - 4;
 487           y = y + ((height - (font->ascent + font->descent)) / 2) + font->ascent;
 488
 489           if (state_type == GTK_STATE_INSENSITIVE)
 490             gdk_draw_string (widget->window, widget->style->font,
 491                              widget->style->white_gc,
 492                              x + 1, y + 1, buf);
 493
 494           gdk_draw_string (widget->window, widget->style->font,
 495                            widget->style->fg_gc[state_type],
 496                            x, y, buf);
 497         }
 498       else if (menu_item->submenu && menu_item->show_submenu_indicator)
 499         {
 500           shadow_type = GTK_SHADOW_OUT;
 501           if (state_type == GTK_STATE_PRELIGHT)
 502             shadow_type = GTK_SHADOW_IN;
 503
 504           gtk_draw_arrow (widget->style, widget->window,
 505                           state_type, shadow_type, GTK_ARROW_RIGHT, FALSE,
 506                           x + width - 15, y + height / 2 - 5, 10, 10);
 507         }
 508       else if (!GTK_BIN (menu_item)->child)
 509         {
 510           gtk_draw_hline (widget->style, widget->window, GTK_STATE_NORMAL,
 511                           0, widget->allocation.width, 0);
 512         }
 513     }
 514 }
 515
 516 static void
 517 gtk_menu_item_draw (GtkWidget    *widget,
 518                     GdkRectangle *area)
 519 {
 520   GtkBin *bin;
 521   GdkRectangle child_area;
 522
 523   g_return_if_fail (widget != NULL);
 524   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
 525   g_return_if_fail (area != NULL);
 526
 527   if (GTK_WIDGET_DRAWABLE (widget))
 528     {
 529       gtk_menu_item_paint (widget, area);
 530
 531       bin = GTK_BIN (widget);
 532
 533       if (bin->child)
 534         {
 535           if (gtk_widget_intersect (bin->child, area, &child_area))
 536             gtk_widget_draw (bin->child, &child_area);
 537         }
 538     }
 539 }
 540
 541 static gint
 542 gtk_menu_item_expose (GtkWidget      *widget,
 543                       GdkEventExpose *event)
 544 {
 545   GtkBin *bin;
 546   GdkEventExpose child_event;
 547
 548   g_return_val_if_fail (widget != NULL, FALSE);
 549   g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
 550   g_return_val_if_fail (event != NULL, FALSE);
 551
 552   if (GTK_WIDGET_DRAWABLE (widget))
 553     {
 554       gtk_menu_item_paint (widget, &event->area);
 555
 556       bin = GTK_BIN (widget);
 557
 558       if (bin->child)
 559         {
 560           child_event = *event;
 561
 562           if (GTK_WIDGET_NO_WINDOW (bin->child) &&
 563               gtk_widget_intersect (bin->child, &event->area, &child_event.area))
 564             gtk_widget_event (bin->child, (GdkEvent*) &child_event);
 565         }
 566     }
 567
 568   return FALSE;
 569 }
 570
 571 static gint
 572 gtk_menu_item_enter (GtkWidget        *widget,
 573                      GdkEventCrossing *event)
 574 {
 575   g_return_val_if_fail (widget != NULL, FALSE);
 576   g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
 577   g_return_val_if_fail (event != NULL, FALSE);
 578
 579   return gtk_widget_event (widget->parent, (GdkEvent*) event);
 580 }
 581
 582 static gint
 583 gtk_menu_item_leave (GtkWidget        *widget,
 584                      GdkEventCrossing *event)
 585 {
 586   g_return_val_if_fail (widget != NULL, FALSE);
 587   g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
 588   g_return_val_if_fail (event != NULL, FALSE);
 589
 590   return gtk_widget_event (widget->parent, (GdkEvent*) event);
 591 }
 592
 593 static void
 594 gtk_real_menu_item_select (GtkItem *item)
 595 {
 596   GtkMenuItem *menu_item;
 597
 598   g_return_if_fail (item != NULL);
 599   g_return_if_fail (GTK_IS_MENU_ITEM (item));
 600
 601   menu_item = GTK_MENU_ITEM (item);
 602
 603   if (menu_item->submenu && !GTK_WIDGET_VISIBLE (menu_item->submenu))
 604     menu_item->timer = gtk_timeout_add (SELECT_TIMEOUT, gtk_menu_item_select_timeout, menu_item);
 605
 606   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_PRELIGHT);
 607   gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
 608 }
 609
 610 static void
 611 gtk_real_menu_item_deselect (GtkItem *item)
 612 {
 613   GtkMenuItem *menu_item;
 614
 615   g_return_if_fail (item != NULL);
 616   g_return_if_fail (GTK_IS_MENU_ITEM (item));
 617
 618   menu_item = GTK_MENU_ITEM (item);
 619
 620   if (menu_item->submenu)
 621     {
 622       if (menu_item->timer)
 623         gtk_timeout_remove (menu_item->timer);
 624       else
 625         gtk_menu_popdown (GTK_MENU (menu_item->submenu));
 626     }
 627
 628   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_NORMAL);
 629   gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
 630 }
 631
 632 static gint
 633 gtk_menu_item_select_timeout (gpointer data)
 634 {
 635   GtkMenuItem *menu_item;
 636
 637   menu_item = GTK_MENU_ITEM (data);
 638   menu_item->timer = 0;
 639
 640   gtk_menu_popup (GTK_MENU (menu_item->submenu),
 641                   GTK_WIDGET (menu_item)->parent,
 642                   GTK_WIDGET (menu_item),
 643                   gtk_menu_item_position_menu,
 644                   menu_item,
 645                   GTK_MENU_SHELL (GTK_WIDGET (menu_item)->parent)->button,
 646                   0);
 647
 648   return FALSE;
 649 }
 650
 651 static void
 652 gtk_menu_item_position_menu (GtkMenu  *menu,
 653                              gint     *x,
 654                              gint     *y,
 655                              gpointer  user_data)
 656 {
 657   GtkMenuItem *menu_item;
 658   GtkMenuItem *parent_menu_item;
 659   gint screen_width;
 660   gint screen_height;
 661   gint twidth, theight;
 662   gint tx, ty;
 663
 664   g_return_if_fail (menu != NULL);
 665   g_return_if_fail (x != NULL);
 666   g_return_if_fail (y != NULL);
 667
 668   menu_item = GTK_MENU_ITEM (user_data);
 669
 670   twidth = GTK_WIDGET (menu)->requisition.width;
 671   theight = GTK_WIDGET (menu)->requisition.height;
 672
 673   screen_width = gdk_screen_width ();
 674   screen_height = gdk_screen_height ();
 675
 676   g_return_if_fail (gdk_window_get_origin (GTK_WIDGET (menu_item)->window, &tx, &ty));
 677
 678   switch (menu_item->submenu_placement)
 679     {
 680     case GTK_TOP_BOTTOM:
 681       if ((ty + GTK_WIDGET (menu_item)->allocation.height + theight) <= screen_height)
 682         ty += GTK_WIDGET (menu_item)->allocation.height;
 683       else if ((ty - theight) >= 0)
 684         ty -= theight;
 685       else
 686         ty += GTK_WIDGET (menu_item)->allocation.height;
 687
 688       if ((tx + twidth) > screen_width)
 689         {
 690           tx -= ((tx + twidth) - screen_width);
 691           if (tx < 0)
 692             tx = 0;
 693         }
 694       break;
 695
 696     case GTK_LEFT_RIGHT:
 697       menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 698       parent_menu_item = GTK_MENU_ITEM (GTK_MENU (GTK_WIDGET (menu_item)->parent)->parent_menu_item);
 699       if (parent_menu_item)
 700         menu_item->submenu_direction = parent_menu_item->submenu_direction;
 701
 702       switch (menu_item->submenu_direction)
 703         {
 704         case GTK_DIRECTION_LEFT:
 705           if ((tx - twidth) >= 0)
 706             tx -= twidth;
 707           else
 708             {
 709               menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
 710               tx += GTK_WIDGET (menu_item)->allocation.width - 5;
 711             }
 712           break;
 713
 714         case GTK_DIRECTION_RIGHT:
 715           if ((tx + GTK_WIDGET (menu_item)->allocation.width + twidth - 5) <= screen_width)
 716             tx += GTK_WIDGET (menu_item)->allocation.width - 5;
 717           else
 718             {
 719               menu_item->submenu_direction = GTK_DIRECTION_LEFT;
 720               tx -= twidth;
 721             }
 722           break;
 723         }
 724
 725       if ((ty + GTK_WIDGET (menu_item)->allocation.height / 4 + theight) <= screen_height)
 726         ty += GTK_WIDGET (menu_item)->allocation.height / 4;
 727       else
 728         {
 729           ty -= ((ty + theight) - screen_height);
 730           if (ty < 0)
 731             ty = 0;
 732         }
 733       break;
 734     }
 735
 736   *x = tx;
 737   *y = ty;
 738 }
 739
 740 void
 741 gtk_menu_item_right_justify(GtkMenuItem *menuitem)
 742 {
 743   g_return_if_fail (menuitem != NULL);
 744   g_return_if_fail (GTK_IS_MENU_ITEM (menuitem));
 745
 746   menuitem->right_justify = 1;
 747 }