1 /* GTK - The GIMP Toolkit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
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.
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.
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.
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/.
28 #include "gtkaccellabel.h"
30 #include "gtkmarshalers.h"
32 #include "gtkmenubar.h"
33 #include "gtkmenuitem.h"
34 #include "gtktearoffmenuitem.h"
35 #include "gtkseparatormenuitem.h"
36 #include "gtksignal.h"
39 #define BORDER_SPACING 3
40 #define SELECT_TIMEOUT 75
42 #define MENU_ITEM_CLASS(w) GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
54 static void gtk_menu_item_class_init (GtkMenuItemClass *klass);
55 static void gtk_menu_item_init (GtkMenuItem *menu_item);
56 static void gtk_menu_item_destroy (GtkObject *object);
57 static void gtk_menu_item_finalize (GObject *object);
58 static void gtk_menu_item_size_request (GtkWidget *widget,
59 GtkRequisition *requisition);
60 static void gtk_menu_item_size_allocate (GtkWidget *widget,
61 GtkAllocation *allocation);
62 static void gtk_menu_item_realize (GtkWidget *widget);
63 static void gtk_menu_item_unrealize (GtkWidget *widget);
64 static void gtk_menu_item_map (GtkWidget *widget);
65 static void gtk_menu_item_unmap (GtkWidget *widget);
66 static void gtk_menu_item_paint (GtkWidget *widget,
68 static gint gtk_menu_item_expose (GtkWidget *widget,
69 GdkEventExpose *event);
70 static void gtk_menu_item_parent_set (GtkWidget *widget,
71 GtkWidget *previous_parent);
74 static void gtk_real_menu_item_select (GtkItem *item);
75 static void gtk_real_menu_item_deselect (GtkItem *item);
76 static void gtk_real_menu_item_activate_item (GtkMenuItem *item);
77 static void gtk_real_menu_item_toggle_size_request (GtkMenuItem *menu_item,
79 static void gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
81 static gboolean gtk_menu_item_mnemonic_activate (GtkWidget *widget,
82 gboolean group_cycling);
84 static gint gtk_menu_item_select_timeout (gpointer data);
85 static void gtk_menu_item_popup_submenu (gpointer data);
86 static void gtk_menu_item_position_menu (GtkMenu *menu,
91 static void gtk_menu_item_show_all (GtkWidget *widget);
92 static void gtk_menu_item_hide_all (GtkWidget *widget);
93 static void gtk_menu_item_forall (GtkContainer *container,
94 gboolean include_internals,
96 gpointer callback_data);
99 static GtkItemClass *parent_class;
100 static guint menu_item_signals[LAST_SIGNAL] = { 0 };
101 static guint32 last_submenu_deselect_time = 0;
106 gtk_menu_item_get_type (void)
108 static GtkType menu_item_type = 0;
112 static const GTypeInfo menu_item_info =
114 sizeof (GtkMenuItemClass),
115 NULL, /* base_init */
116 NULL, /* base_finalize */
117 (GClassInitFunc) gtk_menu_item_class_init,
118 NULL, /* class_finalize */
119 NULL, /* class_data */
120 sizeof (GtkMenuItem),
121 16, /* n_preallocs */
122 (GInstanceInitFunc) gtk_menu_item_init,
125 menu_item_type = g_type_register_static (GTK_TYPE_ITEM, "GtkMenuItem", &menu_item_info, 0);
128 return menu_item_type;
132 gtk_menu_item_class_init (GtkMenuItemClass *klass)
134 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
135 GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
136 GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
137 GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
138 GtkItemClass *item_class = GTK_ITEM_CLASS (klass);
140 parent_class = g_type_class_peek_parent (klass);
142 gobject_class->finalize = gtk_menu_item_finalize;
144 object_class->destroy = gtk_menu_item_destroy;
146 widget_class->size_request = gtk_menu_item_size_request;
147 widget_class->size_allocate = gtk_menu_item_size_allocate;
148 widget_class->expose_event = gtk_menu_item_expose;
149 widget_class->realize = gtk_menu_item_realize;
150 widget_class->unrealize = gtk_menu_item_unrealize;
151 widget_class->map = gtk_menu_item_map;
152 widget_class->unmap = gtk_menu_item_unmap;
153 widget_class->show_all = gtk_menu_item_show_all;
154 widget_class->hide_all = gtk_menu_item_hide_all;
155 widget_class->mnemonic_activate = gtk_menu_item_mnemonic_activate;
156 widget_class->parent_set = gtk_menu_item_parent_set;
158 container_class->forall = gtk_menu_item_forall;
160 item_class->select = gtk_real_menu_item_select;
161 item_class->deselect = gtk_real_menu_item_deselect;
163 klass->activate = NULL;
164 klass->activate_item = gtk_real_menu_item_activate_item;
165 klass->toggle_size_request = gtk_real_menu_item_toggle_size_request;
166 klass->toggle_size_allocate = gtk_real_menu_item_toggle_size_allocate;
168 klass->hide_on_activate = TRUE;
170 menu_item_signals[ACTIVATE] =
171 gtk_signal_new ("activate",
172 GTK_RUN_FIRST | GTK_RUN_ACTION,
173 GTK_CLASS_TYPE (object_class),
174 GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate),
175 _gtk_marshal_VOID__VOID,
177 widget_class->activate_signal = menu_item_signals[ACTIVATE];
179 menu_item_signals[ACTIVATE_ITEM] =
180 gtk_signal_new ("activate_item",
182 GTK_CLASS_TYPE (object_class),
183 GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate_item),
184 gtk_signal_default_marshaller,
187 menu_item_signals[TOGGLE_SIZE_REQUEST] =
188 gtk_signal_new ("toggle_size_request",
190 GTK_CLASS_TYPE (object_class),
191 GTK_SIGNAL_OFFSET (GtkMenuItemClass, toggle_size_request),
192 _gtk_marshal_VOID__POINTER,
196 menu_item_signals[TOGGLE_SIZE_ALLOCATE] =
197 gtk_signal_new ("toggle_size_allocate",
199 GTK_CLASS_TYPE (object_class),
200 GTK_SIGNAL_OFFSET (GtkMenuItemClass, toggle_size_allocate),
201 _gtk_marshal_NONE__INT,
207 gtk_menu_item_init (GtkMenuItem *menu_item)
209 GTK_WIDGET_SET_FLAGS (menu_item, GTK_NO_WINDOW);
211 menu_item->submenu = NULL;
212 menu_item->toggle_size = 0;
213 menu_item->accelerator_width = 0;
214 menu_item->show_submenu_indicator = FALSE;
215 menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
216 menu_item->submenu_placement = GTK_TOP_BOTTOM;
217 menu_item->right_justify = FALSE;
219 menu_item->timer = 0;
223 gtk_menu_item_new (void)
225 return GTK_WIDGET (gtk_type_new (gtk_menu_item_get_type ()));
229 gtk_menu_item_new_with_label (const gchar *label)
231 GtkWidget *menu_item;
232 GtkWidget *accel_label;
234 menu_item = gtk_menu_item_new ();
235 accel_label = gtk_accel_label_new (label);
236 gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
238 gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
239 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
240 gtk_widget_show (accel_label);
247 * gtk_menu_item_new_with_mnemonic:
248 * @label: The text of the button, with an underscore in front of the
250 * @returns: a new #GtkMenuItem
252 * Creates a new #GtkMenuItem containing a label. The label
253 * will be created using gtk_label_new_with_mnemonic(), so underscores
254 * in @label indicate the mnemonic for the menu item.
257 gtk_menu_item_new_with_mnemonic (const gchar *label)
259 GtkWidget *menu_item;
260 GtkWidget *accel_label;
262 menu_item = gtk_menu_item_new ();
263 accel_label = gtk_type_new (GTK_TYPE_ACCEL_LABEL);
264 gtk_label_set_text_with_mnemonic (GTK_LABEL (accel_label), label);
265 gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
267 gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
268 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
269 gtk_widget_show (accel_label);
275 gtk_menu_item_destroy (GtkObject *object)
277 GtkMenuItem *menu_item;
279 g_return_if_fail (GTK_IS_MENU_ITEM (object));
281 menu_item = GTK_MENU_ITEM (object);
283 if (menu_item->submenu)
284 gtk_widget_destroy (menu_item->submenu);
286 GTK_OBJECT_CLASS (parent_class)->destroy (object);
290 gtk_menu_item_finalize (GObject *object)
292 GtkMenuItem *menu_item = GTK_MENU_ITEM (object);
294 g_free (menu_item->accel_path);
296 G_OBJECT_CLASS (parent_class)->finalize (object);
300 gtk_menu_item_detacher (GtkWidget *widget,
303 GtkMenuItem *menu_item;
305 g_return_if_fail (GTK_IS_MENU_ITEM (widget));
307 menu_item = GTK_MENU_ITEM (widget);
308 g_return_if_fail (menu_item->submenu == (GtkWidget*) menu);
310 menu_item->submenu = NULL;
314 gtk_menu_item_set_submenu (GtkMenuItem *menu_item,
317 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
319 if (menu_item->submenu != submenu)
321 gtk_menu_item_remove_submenu (menu_item);
323 menu_item->submenu = submenu;
324 gtk_menu_attach_to_widget (GTK_MENU (submenu),
325 GTK_WIDGET (menu_item),
326 gtk_menu_item_detacher);
328 if (GTK_WIDGET (menu_item)->parent)
329 gtk_widget_queue_resize (GTK_WIDGET (menu_item));
334 * gtk_menu_item_get_submenu:
335 * @menu_item: a #GtkMenuItem
337 * Gets the submenu underneath this menu item, if any. See
338 * gtk_menu_item_set_submenu().
340 * Return value: submenu for this menu item, or %NULL if none.
343 gtk_menu_item_get_submenu (GtkMenuItem *menu_item)
345 g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), NULL);
347 return menu_item->submenu;
351 gtk_menu_item_remove_submenu (GtkMenuItem *menu_item)
353 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
355 if (menu_item->submenu)
356 gtk_menu_detach (GTK_MENU (menu_item->submenu));
360 _gtk_menu_item_set_placement (GtkMenuItem *menu_item,
361 GtkSubmenuPlacement placement)
363 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
365 menu_item->submenu_placement = placement;
369 gtk_menu_item_select (GtkMenuItem *menu_item)
371 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
373 gtk_item_select (GTK_ITEM (menu_item));
377 gtk_menu_item_deselect (GtkMenuItem *menu_item)
379 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
381 gtk_item_deselect (GTK_ITEM (menu_item));
385 gtk_menu_item_activate (GtkMenuItem *menu_item)
387 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
389 gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[ACTIVATE]);
393 gtk_menu_item_toggle_size_request (GtkMenuItem *menu_item,
396 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
398 gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[TOGGLE_SIZE_REQUEST], requisition);
402 gtk_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
405 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
407 gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[TOGGLE_SIZE_ALLOCATE], allocation);
411 gtk_menu_item_accel_width_foreach (GtkWidget *widget,
416 if (GTK_IS_ACCEL_LABEL (widget))
420 w = gtk_accel_label_get_accel_width (GTK_ACCEL_LABEL (widget));
421 *width = MAX (*width, w);
423 else if (GTK_IS_CONTAINER (widget))
424 gtk_container_foreach (GTK_CONTAINER (widget),
425 gtk_menu_item_accel_width_foreach,
430 gtk_menu_item_size_request (GtkWidget *widget,
431 GtkRequisition *requisition)
433 GtkMenuItem *menu_item;
437 g_return_if_fail (GTK_IS_MENU_ITEM (widget));
438 g_return_if_fail (requisition != NULL);
440 bin = GTK_BIN (widget);
441 menu_item = GTK_MENU_ITEM (widget);
443 requisition->width = (GTK_CONTAINER (widget)->border_width +
444 widget->style->xthickness +
446 requisition->height = (GTK_CONTAINER (widget)->border_width +
447 widget->style->ythickness) * 2;
449 if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
451 GtkRequisition child_requisition;
453 gtk_widget_size_request (bin->child, &child_requisition);
455 requisition->width += child_requisition.width;
456 requisition->height += child_requisition.height;
459 if (menu_item->submenu && menu_item->show_submenu_indicator)
460 requisition->width += 21;
463 gtk_container_foreach (GTK_CONTAINER (menu_item),
464 gtk_menu_item_accel_width_foreach,
466 menu_item->accelerator_width = accel_width;
470 gtk_menu_item_size_allocate (GtkWidget *widget,
471 GtkAllocation *allocation)
473 GtkMenuItem *menu_item;
475 GtkAllocation child_allocation;
477 g_return_if_fail (GTK_IS_MENU_ITEM (widget));
478 g_return_if_fail (allocation != NULL);
480 menu_item = GTK_MENU_ITEM (widget);
481 bin = GTK_BIN (widget);
483 widget->allocation = *allocation;
487 child_allocation.x = (GTK_CONTAINER (widget)->border_width +
488 widget->style->xthickness +
490 child_allocation.y = (GTK_CONTAINER (widget)->border_width +
491 widget->style->ythickness);
492 child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
493 child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
494 child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
495 child_allocation.width -= GTK_MENU_ITEM (widget)->toggle_size;
496 child_allocation.x += widget->allocation.x;
497 child_allocation.y += widget->allocation.y;
499 if (menu_item->submenu && menu_item->show_submenu_indicator)
500 child_allocation.width -= 21;
502 gtk_widget_size_allocate (bin->child, &child_allocation);
505 if (GTK_WIDGET_REALIZED (widget))
506 gdk_window_move_resize (menu_item->event_window,
507 allocation->x, allocation->y,
508 allocation->width, allocation->height);
510 if (menu_item->submenu)
511 gtk_menu_reposition (GTK_MENU (menu_item->submenu));
515 gtk_menu_item_realize (GtkWidget *widget)
517 GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
518 GdkWindowAttr attributes;
519 gint attributes_mask;
521 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
523 widget->window = gtk_widget_get_parent_window (widget);
524 gdk_window_ref (widget->window);
526 attributes.x = widget->allocation.x;
527 attributes.y = widget->allocation.y;
528 attributes.width = widget->allocation.width;
529 attributes.height = widget->allocation.height;
530 attributes.window_type = GDK_WINDOW_CHILD;
531 attributes.wclass = GDK_INPUT_ONLY;
532 attributes.event_mask = (gtk_widget_get_events (widget) |
534 GDK_BUTTON_PRESS_MASK |
535 GDK_BUTTON_RELEASE_MASK |
536 GDK_ENTER_NOTIFY_MASK |
537 GDK_LEAVE_NOTIFY_MASK |
538 GDK_POINTER_MOTION_MASK);
540 attributes_mask = GDK_WA_X | GDK_WA_Y;
541 menu_item->event_window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
542 gdk_window_set_user_data (menu_item->event_window, widget);
544 widget->style = gtk_style_attach (widget->style, widget->window);
548 gtk_menu_item_unrealize (GtkWidget *widget)
550 GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
552 gdk_window_set_user_data (menu_item->event_window, NULL);
553 gdk_window_destroy (menu_item->event_window);
554 menu_item->event_window = NULL;
556 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
557 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
561 gtk_menu_item_map (GtkWidget *widget)
563 GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
565 GTK_WIDGET_CLASS (parent_class)->map (widget);
567 gdk_window_show (menu_item->event_window);
571 gtk_menu_item_unmap (GtkWidget *widget)
573 GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
575 gdk_window_hide (menu_item->event_window);
577 GTK_WIDGET_CLASS (parent_class)->unmap (widget);
581 gtk_menu_item_paint (GtkWidget *widget,
584 GtkMenuItem *menu_item;
585 GtkStateType state_type;
586 GtkShadowType shadow_type;
589 gint border_width = GTK_CONTAINER (widget)->border_width;
591 if (GTK_WIDGET_DRAWABLE (widget))
593 menu_item = GTK_MENU_ITEM (widget);
595 state_type = widget->state;
597 x = widget->allocation.x + border_width;
598 y = widget->allocation.y + border_width;
599 width = widget->allocation.width - border_width * 2;
600 height = widget->allocation.height - border_width * 2;
602 if ((state_type == GTK_STATE_PRELIGHT) &&
603 (GTK_BIN (menu_item)->child))
604 gtk_paint_box (widget->style,
608 area, widget, "menuitem",
609 x, y, width, height);
611 if (menu_item->submenu && menu_item->show_submenu_indicator)
613 shadow_type = GTK_SHADOW_OUT;
614 if (state_type == GTK_STATE_PRELIGHT)
615 shadow_type = GTK_SHADOW_IN;
617 gtk_paint_arrow (widget->style, widget->window,
618 state_type, shadow_type,
619 area, widget, "menuitem",
620 GTK_ARROW_RIGHT, TRUE,
621 x + width - 15, y + height / 2 - 5, 10, 10);
623 else if (!GTK_BIN (menu_item)->child)
625 gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
626 area, widget, "menuitem",
627 widget->allocation.x, widget->allocation.width,
628 widget->allocation.y);
634 gtk_menu_item_expose (GtkWidget *widget,
635 GdkEventExpose *event)
637 g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
638 g_return_val_if_fail (event != NULL, FALSE);
640 if (GTK_WIDGET_DRAWABLE (widget))
642 gtk_menu_item_paint (widget, &event->area);
644 (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
651 gtk_real_menu_item_select (GtkItem *item)
653 GtkMenuItem *menu_item;
655 g_return_if_fail (GTK_IS_MENU_ITEM (item));
657 menu_item = GTK_MENU_ITEM (item);
659 /* if (menu_item->submenu && !GTK_WIDGET_VISIBLE (menu_item->submenu))*/
660 if (menu_item->submenu)
663 GdkEvent *event = gtk_get_current_event ();
665 etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
666 if (etime >= last_submenu_deselect_time &&
667 last_submenu_deselect_time + SELECT_TIMEOUT > etime)
668 menu_item->timer = gtk_timeout_add (SELECT_TIMEOUT - (etime - last_submenu_deselect_time),
669 gtk_menu_item_select_timeout,
672 gtk_menu_item_popup_submenu (menu_item);
674 gdk_event_free(event);
677 gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_PRELIGHT);
678 gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
682 gtk_real_menu_item_deselect (GtkItem *item)
684 GtkMenuItem *menu_item;
686 g_return_if_fail (GTK_IS_MENU_ITEM (item));
688 menu_item = GTK_MENU_ITEM (item);
690 if (menu_item->submenu)
693 GdkEvent *event = gtk_get_current_event ();
695 if (menu_item->timer)
697 gtk_timeout_remove (menu_item->timer);
698 menu_item->timer = 0;
701 gtk_menu_popdown (GTK_MENU (menu_item->submenu));
703 etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
704 if (etime > last_submenu_deselect_time)
705 last_submenu_deselect_time = etime;
707 gdk_event_free(event);
710 gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_NORMAL);
711 gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
715 gtk_menu_item_mnemonic_activate (GtkWidget *widget,
716 gboolean group_cycling)
720 if (widget->parent &&
721 GTK_IS_MENU_SHELL (widget->parent))
722 gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent),
727 gtk_signal_emit (GTK_OBJECT (widget), menu_item_signals[ACTIVATE_ITEM]);
734 gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
737 GtkMenuShell *submenu;
739 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
741 widget = GTK_WIDGET (menu_item);
743 if (widget->parent &&
744 GTK_IS_MENU_SHELL (widget->parent))
746 if (menu_item->submenu == NULL)
747 gtk_menu_shell_activate_item (GTK_MENU_SHELL (widget->parent),
751 GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget->parent);
753 if (!menu_shell->active)
755 gtk_grab_add (GTK_WIDGET (menu_shell));
756 menu_shell->have_grab = TRUE;
757 menu_shell->active = TRUE;
760 gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent), widget);
761 gtk_menu_item_popup_submenu (widget);
763 submenu = GTK_MENU_SHELL (menu_item->submenu);
764 if (submenu->children)
766 if (submenu->children->next &&
767 GTK_IS_TEAROFF_MENU_ITEM (submenu->children->data))
768 gtk_menu_shell_select_item (submenu, submenu->children->next->data);
770 gtk_menu_shell_select_item (submenu, submenu->children->data);
776 gtk_real_menu_item_toggle_size_request (GtkMenuItem *menu_item,
779 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
785 gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
788 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
790 menu_item->toggle_size = allocation;
794 gtk_menu_item_select_timeout (gpointer data)
796 GDK_THREADS_ENTER ();
798 gtk_menu_item_popup_submenu (data);
800 GDK_THREADS_LEAVE ();
806 gtk_menu_item_popup_submenu (gpointer data)
808 GtkMenuItem *menu_item;
810 menu_item = GTK_MENU_ITEM (data);
811 menu_item->timer = 0;
813 if (GTK_WIDGET_IS_SENSITIVE (menu_item->submenu))
815 gtk_menu_popup (GTK_MENU (menu_item->submenu),
816 GTK_WIDGET (menu_item)->parent,
817 GTK_WIDGET (menu_item),
818 gtk_menu_item_position_menu,
820 GTK_MENU_SHELL (GTK_WIDGET (menu_item)->parent)->button,
826 gtk_menu_item_position_menu (GtkMenu *menu,
832 GtkMenuItem *menu_item;
834 GtkWidget *parent_menu_item;
837 gint twidth, theight;
840 g_return_if_fail (menu != NULL);
841 g_return_if_fail (x != NULL);
842 g_return_if_fail (y != NULL);
844 menu_item = GTK_MENU_ITEM (user_data);
845 widget = GTK_WIDGET (user_data);
847 twidth = GTK_WIDGET (menu)->requisition.width;
848 theight = GTK_WIDGET (menu)->requisition.height;
850 screen_width = gdk_screen_width ();
851 screen_height = gdk_screen_height ();
853 if (!gdk_window_get_origin (widget->window, &tx, &ty))
855 g_warning ("Menu not on screen");
859 tx += widget->allocation.x;
860 ty += widget->allocation.y;
862 switch (menu_item->submenu_placement)
865 if ((ty + widget->allocation.height + theight) <= screen_height)
866 ty += widget->allocation.height;
867 else if ((ty - theight) >= 0)
869 else if (screen_height - (ty + widget->allocation.height) > ty)
870 ty += widget->allocation.height;
876 menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
877 parent_menu_item = GTK_MENU (widget->parent)->parent_menu_item;
878 if (parent_menu_item)
879 menu_item->submenu_direction = GTK_MENU_ITEM (parent_menu_item)->submenu_direction;
881 switch (menu_item->submenu_direction)
883 case GTK_DIRECTION_LEFT:
884 if ((tx - twidth) >= 0)
888 menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
889 tx += widget->allocation.width - 5;
893 case GTK_DIRECTION_RIGHT:
894 if ((tx + widget->allocation.width + twidth - 5) <= screen_width)
895 tx += widget->allocation.width - 5;
898 menu_item->submenu_direction = GTK_DIRECTION_LEFT;
904 ty += widget->allocation.height / 4;
906 /* If the height of the menu doesn't fit we move it upward. */
907 ty = CLAMP (ty, 0, MAX (0, screen_height - theight));
911 /* If we have negative, tx, here it is because we can't get
912 * the menu all the way on screen. Favor the left portion.
914 *x = CLAMP (tx, 0, MAX (0, screen_width - twidth));
919 * gtk_menu_item_set_right_justified:
920 * @menu_item: a #GtkMenuItem.
921 * @right_justified: if %TRUE the menu item will appear at the
922 * far right if added to a menu bar.
924 * Sets whether the menu item appears justified at the right
925 * side of a menu bar. This was traditionally done for "Help" menu
926 * items, but is now considered a bad idea. (If the widget
927 * layout is reversed for a right-to-left language like Hebrew
928 * or Arabic, right-justified-menu-items appear at the left.)
931 gtk_menu_item_set_right_justified (GtkMenuItem *menu_item,
932 gboolean right_justified)
934 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
936 right_justified = right_justified != FALSE;
938 if (right_justified != menu_item->right_justify)
940 menu_item->right_justify = right_justified;
941 gtk_widget_queue_resize (GTK_WIDGET (menu_item));
946 * gtk_menu_item_get_right_justified:
947 * @menu_item: a #GtkMenuItem
949 * Gets whether the menu item appears justified at the right
950 * side of the menu bar.
952 * Return value: %TRUE if the menu item will appear at the
953 * far right if added to a menu bar.
956 gtk_menu_item_get_right_justified (GtkMenuItem *menu_item)
958 g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), FALSE);
960 return menu_item->right_justify;
965 gtk_menu_item_show_all (GtkWidget *widget)
967 GtkMenuItem *menu_item;
969 g_return_if_fail (GTK_IS_MENU_ITEM (widget));
971 menu_item = GTK_MENU_ITEM (widget);
973 /* show children including submenu */
974 if (menu_item->submenu)
975 gtk_widget_show_all (menu_item->submenu);
976 gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);
978 gtk_widget_show (widget);
982 gtk_menu_item_hide_all (GtkWidget *widget)
984 GtkMenuItem *menu_item;
986 g_return_if_fail (GTK_IS_MENU_ITEM (widget));
988 gtk_widget_hide (widget);
990 menu_item = GTK_MENU_ITEM (widget);
992 /* hide children including submenu */
993 gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
994 if (menu_item->submenu)
995 gtk_widget_hide_all (menu_item->submenu);
999 gtk_menu_item_accel_name_foreach (GtkWidget *widget,
1002 const gchar **path_p = data;
1006 if (GTK_IS_LABEL (widget))
1008 *path_p = gtk_label_get_text (GTK_LABEL (widget));
1009 if (*path_p && (*path_p)[0] == 0)
1012 else if (GTK_IS_CONTAINER (widget))
1013 gtk_container_foreach (GTK_CONTAINER (widget),
1014 gtk_menu_item_accel_name_foreach,
1020 gtk_menu_item_parent_set (GtkWidget *widget,
1021 GtkWidget *previous_parent)
1023 GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
1024 GtkMenu *menu = GTK_IS_MENU (widget->parent) ? GTK_MENU (widget->parent) : NULL;
1027 _gtk_menu_item_refresh_accel_path (menu_item,
1032 if (GTK_WIDGET_CLASS (parent_class)->parent_set)
1033 GTK_WIDGET_CLASS (parent_class)->parent_set (widget, previous_parent);
1037 _gtk_menu_item_refresh_accel_path (GtkMenuItem *menu_item,
1038 const gchar *prefix,
1039 GtkAccelGroup *accel_group,
1040 gboolean group_changed)
1045 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1046 g_return_if_fail (!accel_group || GTK_IS_ACCEL_GROUP (accel_group));
1048 widget = GTK_WIDGET (menu_item);
1052 _gtk_widget_set_accel_path (widget, NULL, NULL);
1056 path = _gtk_widget_get_accel_path (widget);
1057 if (!path) /* no active accel_path yet */
1059 path = menu_item->accel_path;
1060 if (!path && prefix)
1062 gchar *postfix = NULL;
1064 /* try to construct one from label text */
1065 gtk_container_foreach (GTK_CONTAINER (menu_item),
1066 gtk_menu_item_accel_name_foreach,
1068 menu_item->accel_path = postfix ? g_strconcat (prefix, "/", postfix, NULL) : NULL;
1069 path = menu_item->accel_path;
1072 _gtk_widget_set_accel_path (widget, path, accel_group);
1074 else if (group_changed) /* reinstall accelerators */
1075 _gtk_widget_set_accel_path (widget, path, accel_group);
1079 * gtk_menu_item_set_accel_path
1080 * @menu_item: a valid #GtkMenuItem
1081 * @accel_path: accelerator path, corresponding to this menu item's functionality
1083 * Set the accelerator path on @menu_item, through which runtime changes of the
1084 * menu item's accelerator caused by the user can be identified and saved to
1085 * persistant storage (see gtk_accel_map_save() on this).
1086 * To setup a default accelerator for this menu item, call
1087 * gtk_accel_map_add_entry() with the same @accel_path.
1088 * See also gtk_accel_map_add_entry() on the specifics of accelerator paths,
1089 * and gtk_menu_set_accel_path() for a more convenient variant of this function.
1092 gtk_menu_item_set_accel_path (GtkMenuItem *menu_item,
1093 const gchar *accel_path)
1097 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1098 g_return_if_fail (accel_path && accel_path[0] == '<' && strchr (accel_path, '/'));
1100 widget = GTK_WIDGET (menu_item);
1102 /* store new path */
1103 g_free (menu_item->accel_path);
1104 menu_item->accel_path = g_strdup (accel_path);
1106 /* forget accelerators associated with old path */
1107 _gtk_widget_set_accel_path (widget, NULL, NULL);
1109 /* install accelerators associated with new path */
1112 GtkMenu *menu = GTK_MENU (widget->parent);
1114 if (menu->accel_group)
1115 _gtk_menu_item_refresh_accel_path (GTK_MENU_ITEM (widget),
1123 gtk_menu_item_forall (GtkContainer *container,
1124 gboolean include_internals,
1125 GtkCallback callback,
1126 gpointer callback_data)
1129 GtkMenuItem *menu_item;
1131 g_return_if_fail (GTK_IS_MENU_ITEM (container));
1132 g_return_if_fail (callback != NULL);
1134 bin = GTK_BIN (container);
1135 menu_item = GTK_MENU_ITEM (container);
1138 callback (bin->child, callback_data);
1142 _gtk_menu_item_is_selectable (GtkWidget *menu_item)
1144 if ((!GTK_BIN (menu_item)->child &&
1145 G_OBJECT_TYPE (menu_item) == GTK_TYPE_MENU_ITEM) ||
1146 GTK_IS_SEPARATOR_MENU_ITEM (menu_item) ||
1147 !GTK_WIDGET_IS_SENSITIVE (menu_item) ||
1148 !GTK_WIDGET_VISIBLE (menu_item))