]> Pileus Git - ~andy/gtk/blob - gtk/gtkmenuitem.c
add "selected_shadow_type" style property
[~andy/gtk] / 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 Lesser 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  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser 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
20 /*
21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
22  * file for a list of people on the GTK+ Team.  See the ChangeLog
23  * files for a list of changes.  These files are distributed with
24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
25  */
26
27 #define GTK_MENU_INTERNALS
28
29 #include <string.h>
30 #include "gtkaccellabel.h"
31 #include "gtkmain.h"
32 #include "gtkmarshalers.h"
33 #include "gtkmenu.h"
34 #include "gtkmenubar.h"
35 #include "gtkmenuitem.h"
36 #include "gtkseparatormenuitem.h"
37 #include "gtksignal.h"
38
39
40 #define BORDER_SPACING  3
41 #define SELECT_TIMEOUT  75
42
43 #define MENU_ITEM_CLASS(w)  GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
44
45
46 enum {
47   ACTIVATE,
48   ACTIVATE_ITEM,
49   TOGGLE_SIZE_REQUEST,
50   TOGGLE_SIZE_ALLOCATE,
51   LAST_SIGNAL
52 };
53
54
55 static void gtk_menu_item_class_init     (GtkMenuItemClass *klass);
56 static void gtk_menu_item_init           (GtkMenuItem      *menu_item);
57 static void gtk_menu_item_destroy        (GtkObject        *object);
58 static void gtk_menu_item_finalize       (GObject          *object);
59 static void gtk_menu_item_size_request   (GtkWidget        *widget,
60                                           GtkRequisition   *requisition);
61 static void gtk_menu_item_size_allocate  (GtkWidget        *widget,
62                                           GtkAllocation    *allocation);
63 static void gtk_menu_item_realize        (GtkWidget        *widget);
64 static void gtk_menu_item_unrealize      (GtkWidget        *widget);
65 static void gtk_menu_item_map            (GtkWidget        *widget);
66 static void gtk_menu_item_unmap          (GtkWidget        *widget);
67 static void gtk_menu_item_paint          (GtkWidget        *widget,
68                                           GdkRectangle     *area);
69 static gint gtk_menu_item_expose         (GtkWidget        *widget,
70                                           GdkEventExpose   *event);
71 static void gtk_menu_item_parent_set     (GtkWidget        *widget,
72                                           GtkWidget        *previous_parent);
73
74
75 static void gtk_real_menu_item_select               (GtkItem     *item);
76 static void gtk_real_menu_item_deselect             (GtkItem     *item);
77 static void gtk_real_menu_item_activate_item        (GtkMenuItem *item);
78 static void gtk_real_menu_item_toggle_size_request  (GtkMenuItem *menu_item,
79                                                      gint        *requisition);
80 static void gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
81                                                      gint         allocation);
82 static gboolean gtk_menu_item_mnemonic_activate     (GtkWidget   *widget,
83                                                      gboolean     group_cycling);
84
85 static gint gtk_menu_item_select_timeout (gpointer          data);
86 static void gtk_menu_item_popup_submenu  (gpointer     data);
87 static void gtk_menu_item_position_menu  (GtkMenu          *menu,
88                                           gint             *x,
89                                           gint             *y,
90                                           gboolean         *push_in,
91                                           gpointer          user_data);
92 static void gtk_menu_item_show_all       (GtkWidget        *widget);
93 static void gtk_menu_item_hide_all       (GtkWidget        *widget);
94 static void gtk_menu_item_forall         (GtkContainer    *container,
95                                           gboolean         include_internals,
96                                           GtkCallback      callback,
97                                           gpointer         callback_data);
98
99
100 static GtkItemClass *parent_class;
101 static guint menu_item_signals[LAST_SIGNAL] = { 0 };
102 static guint32  last_submenu_deselect_time = 0;
103
104
105
106 GtkType
107 gtk_menu_item_get_type (void)
108 {
109   static GtkType menu_item_type = 0;
110
111   if (!menu_item_type)
112     {
113       static const GTypeInfo menu_item_info =
114       {
115         sizeof (GtkMenuItemClass),
116         NULL,           /* base_init */
117         NULL,           /* base_finalize */
118         (GClassInitFunc) gtk_menu_item_class_init,
119         NULL,           /* class_finalize */
120         NULL,           /* class_data */
121         sizeof (GtkMenuItem),
122         16,             /* n_preallocs */
123         (GInstanceInitFunc) gtk_menu_item_init,
124       };
125
126       menu_item_type = g_type_register_static (GTK_TYPE_ITEM, "GtkMenuItem", &menu_item_info, 0);
127     }
128
129   return menu_item_type;
130 }
131
132 static void
133 gtk_menu_item_class_init (GtkMenuItemClass *klass)
134 {
135   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
136   GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
137   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
138   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
139   GtkItemClass *item_class = GTK_ITEM_CLASS (klass);
140
141   parent_class = g_type_class_peek_parent (klass);
142
143   gobject_class->finalize = gtk_menu_item_finalize;
144
145   object_class->destroy = gtk_menu_item_destroy;
146
147   widget_class->size_request = gtk_menu_item_size_request;
148   widget_class->size_allocate = gtk_menu_item_size_allocate;
149   widget_class->expose_event = gtk_menu_item_expose;
150   widget_class->realize = gtk_menu_item_realize;
151   widget_class->unrealize = gtk_menu_item_unrealize;
152   widget_class->map = gtk_menu_item_map;
153   widget_class->unmap = gtk_menu_item_unmap;
154   widget_class->show_all = gtk_menu_item_show_all;
155   widget_class->hide_all = gtk_menu_item_hide_all;
156   widget_class->mnemonic_activate = gtk_menu_item_mnemonic_activate;
157   widget_class->parent_set = gtk_menu_item_parent_set;
158   
159   container_class->forall = gtk_menu_item_forall;
160
161   item_class->select = gtk_real_menu_item_select;
162   item_class->deselect = gtk_real_menu_item_deselect;
163
164   klass->activate = NULL;
165   klass->activate_item = gtk_real_menu_item_activate_item;
166   klass->toggle_size_request = gtk_real_menu_item_toggle_size_request;
167   klass->toggle_size_allocate = gtk_real_menu_item_toggle_size_allocate;
168
169   klass->hide_on_activate = TRUE;
170
171   menu_item_signals[ACTIVATE] =
172     gtk_signal_new ("activate",
173                     GTK_RUN_FIRST | GTK_RUN_ACTION,
174                     GTK_CLASS_TYPE (object_class),
175                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate),
176                     _gtk_marshal_VOID__VOID,
177                     GTK_TYPE_NONE, 0);
178   widget_class->activate_signal = menu_item_signals[ACTIVATE];
179
180   menu_item_signals[ACTIVATE_ITEM] =
181     gtk_signal_new ("activate_item",
182                     GTK_RUN_FIRST,
183                     GTK_CLASS_TYPE (object_class),
184                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate_item),
185                     gtk_signal_default_marshaller,
186                     GTK_TYPE_NONE, 0);
187
188   menu_item_signals[TOGGLE_SIZE_REQUEST] =
189     gtk_signal_new ("toggle_size_request",
190                     GTK_RUN_FIRST,
191                     GTK_CLASS_TYPE (object_class),
192                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, toggle_size_request),
193                     _gtk_marshal_VOID__POINTER,
194                     GTK_TYPE_NONE, 1,
195                     GTK_TYPE_POINTER);
196
197   menu_item_signals[TOGGLE_SIZE_ALLOCATE] =
198     gtk_signal_new ("toggle_size_allocate",
199                     GTK_RUN_FIRST,
200                     GTK_CLASS_TYPE (object_class),
201                     GTK_SIGNAL_OFFSET (GtkMenuItemClass, toggle_size_allocate),
202                     _gtk_marshal_NONE__INT,
203                     GTK_TYPE_NONE, 1,
204                     GTK_TYPE_INT);
205
206   gtk_widget_class_install_style_property_parser (widget_class,
207                                                   g_param_spec_enum ("selected_shadow_type",
208                                                                      "Selected Shadow Type",
209                                                                      "Shadow type when item is selected",
210                                                                      GTK_TYPE_SHADOW_TYPE,
211                                                                      GTK_SHADOW_OUT,
212                                                                      G_PARAM_READABLE),
213                                                   gtk_rc_property_parse_enum);
214 }
215
216 static void
217 gtk_menu_item_init (GtkMenuItem *menu_item)
218 {
219   GTK_WIDGET_SET_FLAGS (menu_item, GTK_NO_WINDOW);
220   
221   menu_item->submenu = NULL;
222   menu_item->toggle_size = 0;
223   menu_item->accelerator_width = 0;
224   menu_item->show_submenu_indicator = FALSE;
225   menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
226   menu_item->submenu_placement = GTK_TOP_BOTTOM;
227   menu_item->right_justify = FALSE;
228
229   menu_item->timer = 0;
230 }
231
232 GtkWidget*
233 gtk_menu_item_new (void)
234 {
235   return GTK_WIDGET (gtk_type_new (gtk_menu_item_get_type ()));
236 }
237
238 GtkWidget*
239 gtk_menu_item_new_with_label (const gchar *label)
240 {
241   GtkWidget *menu_item;
242   GtkWidget *accel_label;
243
244   menu_item = gtk_menu_item_new ();
245   accel_label = gtk_accel_label_new (label);
246   gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
247
248   gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
249   gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
250   gtk_widget_show (accel_label);
251
252   return menu_item;
253 }
254
255
256 /**
257  * gtk_menu_item_new_with_mnemonic:
258  * @label: The text of the button, with an underscore in front of the
259  *         mnemonic character
260  * @returns: a new #GtkMenuItem
261  *
262  * Creates a new #GtkMenuItem containing a label. The label
263  * will be created using gtk_label_new_with_mnemonic(), so underscores
264  * in @label indicate the mnemonic for the menu item.
265  **/
266 GtkWidget*
267 gtk_menu_item_new_with_mnemonic (const gchar *label)
268 {
269   GtkWidget *menu_item;
270   GtkWidget *accel_label;
271
272   menu_item = gtk_menu_item_new ();
273   accel_label = gtk_type_new (GTK_TYPE_ACCEL_LABEL);
274   gtk_label_set_text_with_mnemonic (GTK_LABEL (accel_label), label);
275   gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
276
277   gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
278   gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
279   gtk_widget_show (accel_label);
280
281   return menu_item;
282 }
283
284 static void
285 gtk_menu_item_destroy (GtkObject *object)
286 {
287   GtkMenuItem *menu_item;
288
289   g_return_if_fail (GTK_IS_MENU_ITEM (object));
290
291   menu_item = GTK_MENU_ITEM (object);
292
293   if (menu_item->submenu)
294     gtk_widget_destroy (menu_item->submenu);
295
296   GTK_OBJECT_CLASS (parent_class)->destroy (object);
297 }
298
299 static void
300 gtk_menu_item_finalize (GObject *object)
301 {
302   GtkMenuItem *menu_item = GTK_MENU_ITEM (object);
303
304   g_free (menu_item->accel_path);
305
306   G_OBJECT_CLASS (parent_class)->finalize (object);
307 }
308
309 static void
310 gtk_menu_item_detacher (GtkWidget     *widget,
311                         GtkMenu       *menu)
312 {
313   GtkMenuItem *menu_item;
314
315   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
316
317   menu_item = GTK_MENU_ITEM (widget);
318   g_return_if_fail (menu_item->submenu == (GtkWidget*) menu);
319
320   menu_item->submenu = NULL;
321 }
322
323 void
324 gtk_menu_item_set_submenu (GtkMenuItem *menu_item,
325                            GtkWidget   *submenu)
326 {
327   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
328   
329   if (menu_item->submenu != submenu)
330     {
331       gtk_menu_item_remove_submenu (menu_item);
332       
333       menu_item->submenu = submenu;
334       gtk_menu_attach_to_widget (GTK_MENU (submenu),
335                                  GTK_WIDGET (menu_item),
336                                  gtk_menu_item_detacher);
337       
338       if (GTK_WIDGET (menu_item)->parent)
339         gtk_widget_queue_resize (GTK_WIDGET (menu_item));
340     }
341 }
342
343 /**
344  * gtk_menu_item_get_submenu:
345  * @menu_item: a #GtkMenuItem
346  *
347  * Gets the submenu underneath this menu item, if any. See
348  * gtk_menu_item_set_submenu().
349  *
350  * Return value: submenu for this menu item, or %NULL if none.
351  **/
352 GtkWidget *
353 gtk_menu_item_get_submenu (GtkMenuItem *menu_item)
354 {
355   g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), NULL);
356
357   return menu_item->submenu;
358 }
359
360 void
361 gtk_menu_item_remove_submenu (GtkMenuItem         *menu_item)
362 {
363   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
364       
365   if (menu_item->submenu)
366     gtk_menu_detach (GTK_MENU (menu_item->submenu));
367 }
368
369 void _gtk_menu_item_set_placement (GtkMenuItem         *menu_item,
370                                    GtkSubmenuPlacement  placement);
371
372 void
373 _gtk_menu_item_set_placement (GtkMenuItem         *menu_item,
374                              GtkSubmenuPlacement  placement)
375 {
376   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
377
378   menu_item->submenu_placement = placement;
379 }
380
381 void
382 gtk_menu_item_select (GtkMenuItem *menu_item)
383 {
384   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
385   
386   gtk_item_select (GTK_ITEM (menu_item));
387 }
388
389 void
390 gtk_menu_item_deselect (GtkMenuItem *menu_item)
391 {
392   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
393   
394   gtk_item_deselect (GTK_ITEM (menu_item));
395 }
396
397 void
398 gtk_menu_item_activate (GtkMenuItem *menu_item)
399 {
400   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
401   
402   gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[ACTIVATE]);
403 }
404
405 void
406 gtk_menu_item_toggle_size_request (GtkMenuItem *menu_item,
407                                    gint        *requisition)
408 {
409   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
410
411   gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[TOGGLE_SIZE_REQUEST], requisition);
412 }
413
414 void
415 gtk_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
416                                     gint         allocation)
417 {
418   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
419
420   gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[TOGGLE_SIZE_ALLOCATE], allocation);
421 }
422
423 static void
424 gtk_menu_item_accel_width_foreach (GtkWidget *widget,
425                                    gpointer data)
426 {
427   guint *width = data;
428
429   if (GTK_IS_ACCEL_LABEL (widget))
430     {
431       guint w;
432
433       w = gtk_accel_label_get_accel_width (GTK_ACCEL_LABEL (widget));
434       *width = MAX (*width, w);
435     }
436   else if (GTK_IS_CONTAINER (widget))
437     gtk_container_foreach (GTK_CONTAINER (widget),
438                            gtk_menu_item_accel_width_foreach,
439                            data);
440 }
441
442 static void
443 gtk_menu_item_size_request (GtkWidget      *widget,
444                             GtkRequisition *requisition)
445 {
446   GtkMenuItem *menu_item;
447   GtkBin *bin;
448   guint accel_width;
449
450   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
451   g_return_if_fail (requisition != NULL);
452
453   bin = GTK_BIN (widget);
454   menu_item = GTK_MENU_ITEM (widget);
455
456   requisition->width = (GTK_CONTAINER (widget)->border_width +
457                         widget->style->xthickness +
458                         BORDER_SPACING) * 2;
459   requisition->height = (GTK_CONTAINER (widget)->border_width +
460                          widget->style->ythickness) * 2;
461
462   if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
463     {
464       GtkRequisition child_requisition;
465       
466       gtk_widget_size_request (bin->child, &child_requisition);
467
468       requisition->width += child_requisition.width;
469       requisition->height += child_requisition.height;
470
471       if (menu_item->submenu && menu_item->show_submenu_indicator)
472         requisition->width += child_requisition.height;
473     }
474
475   accel_width = 0;
476   gtk_container_foreach (GTK_CONTAINER (menu_item),
477                          gtk_menu_item_accel_width_foreach,
478                          &accel_width);
479   menu_item->accelerator_width = accel_width;
480 }
481
482 static void
483 gtk_menu_item_size_allocate (GtkWidget     *widget,
484                              GtkAllocation *allocation)
485 {
486   GtkMenuItem *menu_item;
487   GtkBin *bin;
488   GtkAllocation child_allocation;
489
490   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
491   g_return_if_fail (allocation != NULL);
492
493   menu_item = GTK_MENU_ITEM (widget);
494   bin = GTK_BIN (widget);
495   
496   widget->allocation = *allocation;
497
498   if (bin->child)
499     {
500       child_allocation.x = (GTK_CONTAINER (widget)->border_width +
501                             widget->style->xthickness +
502                             BORDER_SPACING);
503       child_allocation.y = (GTK_CONTAINER (widget)->border_width +
504                             widget->style->ythickness);
505       child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
506       child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
507       child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
508       child_allocation.width -= GTK_MENU_ITEM (widget)->toggle_size;
509       child_allocation.x += widget->allocation.x;
510       child_allocation.y += widget->allocation.y;
511       
512       if (menu_item->submenu && menu_item->show_submenu_indicator)
513         child_allocation.width -= child_allocation.height;
514
515       gtk_widget_size_allocate (bin->child, &child_allocation);
516     }
517
518   if (GTK_WIDGET_REALIZED (widget))
519     gdk_window_move_resize (menu_item->event_window,
520                             allocation->x, allocation->y,
521                             allocation->width, allocation->height);
522
523   if (menu_item->submenu)
524     gtk_menu_reposition (GTK_MENU (menu_item->submenu));
525 }
526
527 static void
528 gtk_menu_item_realize (GtkWidget *widget)
529 {
530   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
531   GdkWindowAttr attributes;
532   gint attributes_mask;
533
534   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
535
536   widget->window = gtk_widget_get_parent_window (widget);
537   gdk_window_ref (widget->window);
538   
539   attributes.x = widget->allocation.x;
540   attributes.y = widget->allocation.y;
541   attributes.width = widget->allocation.width;
542   attributes.height = widget->allocation.height;
543   attributes.window_type = GDK_WINDOW_CHILD;
544   attributes.wclass = GDK_INPUT_ONLY;
545   attributes.event_mask = (gtk_widget_get_events (widget) |
546                            GDK_EXPOSURE_MASK |
547                            GDK_BUTTON_PRESS_MASK |
548                            GDK_BUTTON_RELEASE_MASK |
549                            GDK_ENTER_NOTIFY_MASK |
550                            GDK_LEAVE_NOTIFY_MASK |
551                            GDK_POINTER_MOTION_MASK);
552
553   attributes_mask = GDK_WA_X | GDK_WA_Y;
554   menu_item->event_window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
555   gdk_window_set_user_data (menu_item->event_window, widget);
556
557   widget->style = gtk_style_attach (widget->style, widget->window);
558 }
559
560 static void
561 gtk_menu_item_unrealize (GtkWidget *widget)
562 {
563   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
564
565   gdk_window_set_user_data (menu_item->event_window, NULL);
566   gdk_window_destroy (menu_item->event_window);
567   menu_item->event_window = NULL;
568   
569   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
570     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
571 }
572
573 static void
574 gtk_menu_item_map (GtkWidget *widget)
575 {
576   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
577   
578   GTK_WIDGET_CLASS (parent_class)->map (widget);
579
580   gdk_window_show (menu_item->event_window);
581 }
582
583 static void
584 gtk_menu_item_unmap (GtkWidget *widget)
585 {
586   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
587     
588   gdk_window_hide (menu_item->event_window);
589
590   GTK_WIDGET_CLASS (parent_class)->unmap (widget);
591 }
592
593 static void
594 gtk_menu_item_paint (GtkWidget    *widget,
595                      GdkRectangle *area)
596 {
597   GtkMenuItem *menu_item;
598   GtkStateType state_type;
599   GtkShadowType shadow_type, selected_shadow_type;
600   gint width, height;
601   gint x, y;
602   gint border_width = GTK_CONTAINER (widget)->border_width;
603
604   if (GTK_WIDGET_DRAWABLE (widget))
605     {
606       menu_item = GTK_MENU_ITEM (widget);
607
608       state_type = widget->state;
609
610       x = widget->allocation.x + border_width;
611       y = widget->allocation.y + border_width;
612       width = widget->allocation.width - border_width * 2;
613       height = widget->allocation.height - border_width * 2;
614       
615       if ((state_type == GTK_STATE_PRELIGHT) &&
616           (GTK_BIN (menu_item)->child))
617         {
618           gtk_widget_style_get (widget,
619                                 "selected_shadow_type", &selected_shadow_type,
620                                 NULL);
621           gtk_paint_box (widget->style,
622                          widget->window,
623                          GTK_STATE_PRELIGHT,
624                          selected_shadow_type,
625                          area, widget, "menuitem",
626                          x, y, width, height);
627         }
628   
629       if (menu_item->submenu && menu_item->show_submenu_indicator)
630         {
631           GtkRequisition child_requisition;
632           gint arrow_x, arrow_y;
633           gint arrow_size;
634           gint arrow_extent;
635
636           gtk_widget_get_child_requisition (GTK_BIN (menu_item)->child,
637                                             &child_requisition);
638
639           arrow_size = child_requisition.height - 2 * widget->style->ythickness;
640           arrow_extent = arrow_size * 0.6;
641           
642           shadow_type = GTK_SHADOW_OUT;
643           if (state_type == GTK_STATE_PRELIGHT)
644             shadow_type = GTK_SHADOW_IN;
645
646           arrow_x = x + width - 1 - arrow_size + (arrow_size - arrow_extent) / 2;
647           arrow_y = y + (height - arrow_extent) / 2;
648
649           gtk_paint_arrow (widget->style, widget->window,
650                            state_type, shadow_type, 
651                            area, widget, "menuitem", 
652                            GTK_ARROW_RIGHT, TRUE,
653                            arrow_x, arrow_y,
654                            arrow_extent, arrow_extent);
655         }
656       else if (!GTK_BIN (menu_item)->child)
657         {
658           gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
659                            area, widget, "menuitem",
660                            widget->allocation.x, widget->allocation.width,
661                            widget->allocation.y);
662         }
663     }
664 }
665
666 static gint
667 gtk_menu_item_expose (GtkWidget      *widget,
668                       GdkEventExpose *event)
669 {
670   g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
671   g_return_val_if_fail (event != NULL, FALSE);
672
673   if (GTK_WIDGET_DRAWABLE (widget))
674     {
675       gtk_menu_item_paint (widget, &event->area);
676
677       (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
678     }
679
680   return FALSE;
681 }
682
683 static void
684 gtk_real_menu_item_select (GtkItem *item)
685 {
686   GtkMenuItem *menu_item;
687
688   g_return_if_fail (GTK_IS_MENU_ITEM (item));
689
690   menu_item = GTK_MENU_ITEM (item);
691
692   /*  if (menu_item->submenu && !GTK_WIDGET_VISIBLE (menu_item->submenu))*/
693   if (menu_item->submenu)
694     {
695       guint32 etime;
696       GdkEvent *event = gtk_get_current_event ();
697
698       etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
699       if (event &&
700           etime >= last_submenu_deselect_time &&
701           last_submenu_deselect_time + SELECT_TIMEOUT > etime)
702         {
703           if (!menu_item->timer)
704             menu_item->timer = gtk_timeout_add (SELECT_TIMEOUT - (etime - last_submenu_deselect_time),
705                                                 gtk_menu_item_select_timeout,
706                                                 menu_item);
707           if (event &&
708               event->type != GDK_BUTTON_PRESS &&
709               event->type != GDK_ENTER_NOTIFY)
710             menu_item->timer_from_keypress = TRUE;
711           else
712             menu_item->timer_from_keypress = FALSE;
713         }
714       else
715         gtk_menu_item_popup_submenu (menu_item);
716       if (event)
717         gdk_event_free(event);
718     }
719   
720   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_PRELIGHT);
721   gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
722 }
723
724 static void
725 gtk_real_menu_item_deselect (GtkItem *item)
726 {
727   GtkMenuItem *menu_item;
728
729   g_return_if_fail (GTK_IS_MENU_ITEM (item));
730
731   menu_item = GTK_MENU_ITEM (item);
732
733   if (menu_item->submenu)
734     {
735       guint32 etime;
736       GdkEvent *event = gtk_get_current_event ();
737
738       if (menu_item->timer)
739         {
740           gtk_timeout_remove (menu_item->timer);
741           menu_item->timer = 0;
742         }
743       else
744         gtk_menu_popdown (GTK_MENU (menu_item->submenu));
745
746       etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
747       if (etime > last_submenu_deselect_time)
748         last_submenu_deselect_time = etime;
749       if (event)
750         gdk_event_free(event);
751     }
752
753   gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_NORMAL);
754   gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
755 }
756
757 static gboolean
758 gtk_menu_item_mnemonic_activate (GtkWidget *widget,
759                                  gboolean   group_cycling)
760 {
761   if (group_cycling)
762     {
763       if (widget->parent &&
764           GTK_IS_MENU_SHELL (widget->parent))
765         gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent),
766                                     widget);
767
768     }
769   else
770     gtk_signal_emit (GTK_OBJECT (widget), menu_item_signals[ACTIVATE_ITEM]);
771   
772   return TRUE;
773 }
774
775
776 static void
777 gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
778 {
779   GtkWidget *widget;
780   GtkMenuShell *submenu; 
781
782   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
783
784   widget = GTK_WIDGET (menu_item);
785   
786   if (widget->parent &&
787       GTK_IS_MENU_SHELL (widget->parent))
788     {
789       if (menu_item->submenu == NULL)
790         gtk_menu_shell_activate_item (GTK_MENU_SHELL (widget->parent),
791                                       widget, TRUE);
792       else
793         {
794           GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget->parent);
795
796           _gtk_menu_shell_activate (menu_shell);
797
798           gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent), widget); 
799           gtk_menu_item_popup_submenu (widget); 
800
801           _gtk_menu_shell_select_first (GTK_MENU_SHELL (menu_item->submenu));
802           submenu = GTK_MENU_SHELL (menu_item->submenu);
803         }
804     }
805 }
806 static void
807 gtk_real_menu_item_toggle_size_request (GtkMenuItem *menu_item,
808                                         gint        *requisition)
809 {
810   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
811
812   *requisition = 0;
813 }
814
815 static void
816 gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
817                                          gint         allocation)
818 {
819   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
820
821   menu_item->toggle_size = allocation;
822 }
823
824 static gint
825 gtk_menu_item_select_timeout (gpointer data)
826 {
827   GtkMenuItem *menu_item;
828   GtkWidget *parent;
829   
830   GDK_THREADS_ENTER ();
831
832   menu_item = GTK_MENU_ITEM (data);
833
834   parent = GTK_WIDGET (menu_item)->parent;
835
836   if (parent && GTK_IS_MENU_SHELL (parent) && GTK_MENU_SHELL (parent)->active)
837     {
838       gtk_menu_item_popup_submenu (data);
839       if (menu_item->timer_from_keypress && menu_item->submenu)
840         GTK_MENU_SHELL (menu_item->submenu)->ignore_enter = TRUE;
841     }
842
843   GDK_THREADS_LEAVE ();
844
845   return FALSE;  
846 }
847
848 static void
849 gtk_menu_item_popup_submenu (gpointer data)
850 {
851   GtkMenuItem *menu_item;
852
853   menu_item = GTK_MENU_ITEM (data);
854   menu_item->timer = 0;
855
856   if (GTK_WIDGET_IS_SENSITIVE (menu_item->submenu))
857     {
858       gtk_menu_popup (GTK_MENU (menu_item->submenu),
859                       GTK_WIDGET (menu_item)->parent,
860                       GTK_WIDGET (menu_item),
861                       gtk_menu_item_position_menu,
862                       menu_item,
863                       GTK_MENU_SHELL (GTK_WIDGET (menu_item)->parent)->button,
864                       0);
865     }
866 }
867
868 static void
869 gtk_menu_item_position_menu (GtkMenu  *menu,
870                              gint     *x,
871                              gint     *y,
872                              gboolean *push_in,
873                              gpointer  user_data)
874 {
875   GtkMenuItem *menu_item;
876   GtkWidget *widget;
877   GtkWidget *parent_menu_item;
878   gint screen_width;
879   gint screen_height;
880   gint twidth, theight;
881   gint tx, ty;
882
883   g_return_if_fail (menu != NULL);
884   g_return_if_fail (x != NULL);
885   g_return_if_fail (y != NULL);
886
887   menu_item = GTK_MENU_ITEM (user_data);
888   widget = GTK_WIDGET (user_data);
889
890   twidth = GTK_WIDGET (menu)->requisition.width;
891   theight = GTK_WIDGET (menu)->requisition.height;
892
893   screen_width = gdk_screen_width ();
894   screen_height = gdk_screen_height ();
895
896   if (!gdk_window_get_origin (widget->window, &tx, &ty))
897     {
898       g_warning ("Menu not on screen");
899       return;
900     }
901
902   tx += widget->allocation.x;
903   ty += widget->allocation.y;
904
905   switch (menu_item->submenu_placement)
906     {
907     case GTK_TOP_BOTTOM:
908       if ((ty + widget->allocation.height + theight) <= screen_height)
909         ty += widget->allocation.height;
910       else if ((ty - theight) >= 0)
911         ty -= theight;
912       else if (screen_height - (ty + widget->allocation.height) > ty)
913         ty += widget->allocation.height;
914       else
915         ty -= theight;
916       break;
917
918     case GTK_LEFT_RIGHT:
919       menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
920       parent_menu_item = GTK_MENU (widget->parent)->parent_menu_item;
921       if (parent_menu_item)
922         menu_item->submenu_direction = GTK_MENU_ITEM (parent_menu_item)->submenu_direction;
923
924       switch (menu_item->submenu_direction)
925         {
926         case GTK_DIRECTION_LEFT:
927           if ((tx - twidth) >= 0)
928             tx -= twidth;
929           else
930             {
931               menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
932               tx += widget->allocation.width - 5;
933             }
934           break;
935
936         case GTK_DIRECTION_RIGHT:
937           if ((tx + widget->allocation.width + twidth - 5) <= screen_width)
938             tx += widget->allocation.width - 5;
939           else
940             {
941               menu_item->submenu_direction = GTK_DIRECTION_LEFT;
942               tx -= twidth;
943             }
944           break;
945         }
946
947       ty += widget->allocation.height / 4;
948
949       /* If the height of the menu doesn't fit we move it upward. */
950       ty = CLAMP (ty, 0, MAX (0, screen_height - theight));
951       break;
952     }
953
954   /* If we have negative, tx, here it is because we can't get
955    * the menu all the way on screen. Favor the left portion.
956    */
957   *x = CLAMP (tx, 0, MAX (0, screen_width - twidth));
958   *y = ty;
959 }
960
961 /**
962  * gtk_menu_item_set_right_justified:
963  * @menu_item: a #GtkMenuItem.
964  * @right_justified: if %TRUE the menu item will appear at the 
965  *   far right if added to a menu bar.
966  * 
967  * Sets whether the menu item appears justified at the right
968  * side of a menu bar. This was traditionally done for "Help" menu
969  * items, but is now considered a bad idea. (If the widget
970  * layout is reversed for a right-to-left language like Hebrew
971  * or Arabic, right-justified-menu-items appear at the left.)
972  **/
973 void
974 gtk_menu_item_set_right_justified (GtkMenuItem *menu_item,
975                                    gboolean     right_justified)
976 {
977   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
978
979   right_justified = right_justified != FALSE;
980
981   if (right_justified != menu_item->right_justify)
982     {
983       menu_item->right_justify = right_justified;
984       gtk_widget_queue_resize (GTK_WIDGET (menu_item));
985     }
986 }
987
988 /**
989  * gtk_menu_item_get_right_justified:
990  * @menu_item: a #GtkMenuItem
991  * 
992  * Gets whether the menu item appears justified at the right
993  * side of the menu bar.
994  * 
995  * Return value: %TRUE if the menu item will appear at the
996  *   far right if added to a menu bar.
997  **/
998 gboolean
999 gtk_menu_item_get_right_justified (GtkMenuItem *menu_item)
1000 {
1001   g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), FALSE);
1002   
1003   return menu_item->right_justify;
1004 }
1005
1006
1007 static void
1008 gtk_menu_item_show_all (GtkWidget *widget)
1009 {
1010   GtkMenuItem *menu_item;
1011
1012   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
1013
1014   menu_item = GTK_MENU_ITEM (widget);
1015
1016   /* show children including submenu */
1017   if (menu_item->submenu)
1018     gtk_widget_show_all (menu_item->submenu);
1019   gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);
1020
1021   gtk_widget_show (widget);
1022 }
1023
1024 static void
1025 gtk_menu_item_hide_all (GtkWidget *widget)
1026 {
1027   GtkMenuItem *menu_item;
1028
1029   g_return_if_fail (GTK_IS_MENU_ITEM (widget));
1030
1031   gtk_widget_hide (widget);
1032
1033   menu_item = GTK_MENU_ITEM (widget);
1034
1035   /* hide children including submenu */
1036   gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
1037   if (menu_item->submenu)
1038     gtk_widget_hide_all (menu_item->submenu);
1039 }
1040
1041 static void
1042 gtk_menu_item_accel_name_foreach (GtkWidget *widget,
1043                                   gpointer data)
1044 {
1045   const gchar **path_p = data;
1046
1047   if (!*path_p)
1048     {
1049       if (GTK_IS_LABEL (widget))
1050         {
1051           *path_p = gtk_label_get_text (GTK_LABEL (widget));
1052           if (*path_p && (*path_p)[0] == 0)
1053             *path_p = NULL;
1054         }
1055       else if (GTK_IS_CONTAINER (widget))
1056         gtk_container_foreach (GTK_CONTAINER (widget),
1057                                gtk_menu_item_accel_name_foreach,
1058                                data);
1059     }
1060 }
1061
1062 static void
1063 gtk_menu_item_parent_set (GtkWidget *widget,
1064                           GtkWidget *previous_parent)
1065 {
1066   GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
1067   GtkMenu *menu = GTK_IS_MENU (widget->parent) ? GTK_MENU (widget->parent) : NULL;
1068
1069   if (menu)
1070     _gtk_menu_item_refresh_accel_path (menu_item,
1071                                        menu->accel_path,
1072                                        menu->accel_group,
1073                                        TRUE);
1074
1075   if (GTK_WIDGET_CLASS (parent_class)->parent_set)
1076     GTK_WIDGET_CLASS (parent_class)->parent_set (widget, previous_parent);
1077 }
1078
1079 void
1080 _gtk_menu_item_refresh_accel_path (GtkMenuItem   *menu_item,
1081                                    const gchar   *prefix,
1082                                    GtkAccelGroup *accel_group,
1083                                    gboolean       group_changed)
1084 {
1085   const gchar *path;
1086   GtkWidget *widget;
1087
1088   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1089   g_return_if_fail (!accel_group || GTK_IS_ACCEL_GROUP (accel_group));
1090
1091   widget = GTK_WIDGET (menu_item);
1092
1093   if (!accel_group)
1094     {
1095       gtk_widget_set_accel_path (widget, NULL, NULL);
1096       return;
1097     }
1098
1099   path = _gtk_widget_get_accel_path (widget, NULL);
1100   if (!path)                                    /* no active accel_path yet */
1101     {
1102       path = menu_item->accel_path;
1103       if (!path && prefix)
1104         {
1105           gchar *postfix = NULL;
1106
1107           /* try to construct one from label text */
1108           gtk_container_foreach (GTK_CONTAINER (menu_item),
1109                                  gtk_menu_item_accel_name_foreach,
1110                                  &postfix);
1111           menu_item->accel_path = postfix ? g_strconcat (prefix, "/", postfix, NULL) : NULL;
1112           path = menu_item->accel_path;
1113         }
1114       if (path)
1115         gtk_widget_set_accel_path (widget, path, accel_group);
1116     }
1117   else if (group_changed)                       /* reinstall accelerators */
1118     gtk_widget_set_accel_path (widget, path, accel_group);
1119 }
1120
1121 /**
1122  * gtk_menu_item_set_accel_path
1123  * @menu_item:  a valid #GtkMenuItem
1124  * @accel_path: accelerator path, corresponding to this menu item's functionality
1125  *
1126  * Set the accelerator path on @menu_item, through which runtime changes of the
1127  * menu item's accelerator caused by the user can be identified and saved to
1128  * persistant storage (see gtk_accel_map_save() on this).
1129  * To setup a default accelerator for this menu item, call
1130  * gtk_accel_map_add_entry() with the same @accel_path.
1131  * See also gtk_accel_map_add_entry() on the specifics of accelerator paths,
1132  * and gtk_menu_set_accel_path() for a more convenient variant of this function.
1133  *
1134  * This function is basically a convenience wrapper that handles calling
1135  * gtk_widget_set_accel_path() with the appropriate accelerator group for
1136  * the menu item.
1137  */
1138 void
1139 gtk_menu_item_set_accel_path (GtkMenuItem *menu_item,
1140                               const gchar *accel_path)
1141 {
1142   GtkWidget *widget;
1143
1144   g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1145   g_return_if_fail (accel_path && accel_path[0] == '<' && strchr (accel_path, '/'));
1146
1147   widget = GTK_WIDGET (menu_item);
1148
1149   /* store new path */
1150   g_free (menu_item->accel_path);
1151   menu_item->accel_path = g_strdup (accel_path);
1152
1153   /* forget accelerators associated with old path */
1154   gtk_widget_set_accel_path (widget, NULL, NULL);
1155
1156   /* install accelerators associated with new path */
1157   if (widget->parent && GTK_IS_MENU (widget->parent))
1158     {
1159       GtkMenu *menu = GTK_MENU (widget->parent);
1160
1161       if (menu->accel_group)
1162         _gtk_menu_item_refresh_accel_path (GTK_MENU_ITEM (widget),
1163                                            NULL,
1164                                            menu->accel_group,
1165                                            FALSE);
1166     }
1167 }
1168
1169 static void
1170 gtk_menu_item_forall (GtkContainer *container,
1171                       gboolean      include_internals,
1172                       GtkCallback   callback,
1173                       gpointer      callback_data)
1174 {
1175   GtkBin *bin;
1176   GtkMenuItem *menu_item;
1177
1178   g_return_if_fail (GTK_IS_MENU_ITEM (container));
1179   g_return_if_fail (callback != NULL);
1180
1181   bin = GTK_BIN (container);
1182   menu_item = GTK_MENU_ITEM (container);
1183
1184   if (bin->child)
1185     callback (bin->child, callback_data);
1186 }
1187
1188 gboolean
1189 _gtk_menu_item_is_selectable (GtkWidget *menu_item)
1190 {
1191   if ((!GTK_BIN (menu_item)->child &&
1192        G_OBJECT_TYPE (menu_item) == GTK_TYPE_MENU_ITEM) ||
1193       GTK_IS_SEPARATOR_MENU_ITEM (menu_item) ||
1194       !GTK_WIDGET_IS_SENSITIVE (menu_item) ||
1195       !GTK_WIDGET_VISIBLE (menu_item))
1196     return FALSE;
1197
1198   return TRUE;
1199 }