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/.
27 #define GTK_MENU_INTERNALS
30 #include "gtkaccellabel.h"
32 #include "gtkmarshalers.h"
34 #include "gtkmenubar.h"
35 #include "gtkmenuitem.h"
36 #include "gtkseparatormenuitem.h"
39 #define BORDER_SPACING 3
41 #define MENU_ITEM_CLASS(w) GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
53 static void gtk_menu_item_class_init (GtkMenuItemClass *klass);
54 static void gtk_menu_item_init (GtkMenuItem *menu_item);
55 static void gtk_menu_item_destroy (GtkObject *object);
56 static void gtk_menu_item_finalize (GObject *object);
57 static void gtk_menu_item_size_request (GtkWidget *widget,
58 GtkRequisition *requisition);
59 static void gtk_menu_item_size_allocate (GtkWidget *widget,
60 GtkAllocation *allocation);
61 static void gtk_menu_item_realize (GtkWidget *widget);
62 static void gtk_menu_item_unrealize (GtkWidget *widget);
63 static void gtk_menu_item_map (GtkWidget *widget);
64 static void gtk_menu_item_unmap (GtkWidget *widget);
65 static void gtk_menu_item_paint (GtkWidget *widget,
67 static gint gtk_menu_item_expose (GtkWidget *widget,
68 GdkEventExpose *event);
69 static void gtk_menu_item_parent_set (GtkWidget *widget,
70 GtkWidget *previous_parent);
73 static void gtk_real_menu_item_select (GtkItem *item);
74 static void gtk_real_menu_item_deselect (GtkItem *item);
75 static void gtk_real_menu_item_activate_item (GtkMenuItem *item);
76 static void gtk_real_menu_item_toggle_size_request (GtkMenuItem *menu_item,
78 static void gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
80 static gboolean gtk_menu_item_mnemonic_activate (GtkWidget *widget,
81 gboolean group_cycling);
83 static gint gtk_menu_item_select_timeout (gpointer data);
84 static void gtk_menu_item_popup_submenu (gpointer data);
85 static void gtk_menu_item_position_menu (GtkMenu *menu,
90 static void gtk_menu_item_show_all (GtkWidget *widget);
91 static void gtk_menu_item_hide_all (GtkWidget *widget);
92 static void gtk_menu_item_forall (GtkContainer *container,
93 gboolean include_internals,
95 gpointer callback_data);
98 static GtkItemClass *parent_class;
99 static guint menu_item_signals[LAST_SIGNAL] = { 0 };
102 gtk_menu_item_get_type (void)
104 static GType menu_item_type = 0;
108 static const GTypeInfo menu_item_info =
110 sizeof (GtkMenuItemClass),
111 NULL, /* base_init */
112 NULL, /* base_finalize */
113 (GClassInitFunc) gtk_menu_item_class_init,
114 NULL, /* class_finalize */
115 NULL, /* class_data */
116 sizeof (GtkMenuItem),
117 16, /* n_preallocs */
118 (GInstanceInitFunc) gtk_menu_item_init,
121 menu_item_type = g_type_register_static (GTK_TYPE_ITEM, "GtkMenuItem",
125 return menu_item_type;
129 gtk_menu_item_class_init (GtkMenuItemClass *klass)
131 GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
132 GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass);
133 GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
134 GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
135 GtkItemClass *item_class = GTK_ITEM_CLASS (klass);
137 parent_class = g_type_class_peek_parent (klass);
139 gobject_class->finalize = gtk_menu_item_finalize;
141 object_class->destroy = gtk_menu_item_destroy;
143 widget_class->size_request = gtk_menu_item_size_request;
144 widget_class->size_allocate = gtk_menu_item_size_allocate;
145 widget_class->expose_event = gtk_menu_item_expose;
146 widget_class->realize = gtk_menu_item_realize;
147 widget_class->unrealize = gtk_menu_item_unrealize;
148 widget_class->map = gtk_menu_item_map;
149 widget_class->unmap = gtk_menu_item_unmap;
150 widget_class->show_all = gtk_menu_item_show_all;
151 widget_class->hide_all = gtk_menu_item_hide_all;
152 widget_class->mnemonic_activate = gtk_menu_item_mnemonic_activate;
153 widget_class->parent_set = gtk_menu_item_parent_set;
155 container_class->forall = gtk_menu_item_forall;
157 item_class->select = gtk_real_menu_item_select;
158 item_class->deselect = gtk_real_menu_item_deselect;
160 klass->activate = NULL;
161 klass->activate_item = gtk_real_menu_item_activate_item;
162 klass->toggle_size_request = gtk_real_menu_item_toggle_size_request;
163 klass->toggle_size_allocate = gtk_real_menu_item_toggle_size_allocate;
165 klass->hide_on_activate = TRUE;
167 menu_item_signals[ACTIVATE] =
168 g_signal_new ("activate",
169 G_OBJECT_CLASS_TYPE (gobject_class),
170 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
171 G_STRUCT_OFFSET (GtkMenuItemClass, activate),
173 _gtk_marshal_VOID__VOID,
175 widget_class->activate_signal = menu_item_signals[ACTIVATE];
177 menu_item_signals[ACTIVATE_ITEM] =
178 g_signal_new ("activate_item",
179 G_OBJECT_CLASS_TYPE (gobject_class),
181 G_STRUCT_OFFSET (GtkMenuItemClass, activate_item),
183 _gtk_marshal_VOID__VOID,
186 menu_item_signals[TOGGLE_SIZE_REQUEST] =
187 g_signal_new ("toggle_size_request",
188 G_OBJECT_CLASS_TYPE (gobject_class),
190 G_STRUCT_OFFSET (GtkMenuItemClass, toggle_size_request),
192 _gtk_marshal_VOID__POINTER,
196 menu_item_signals[TOGGLE_SIZE_ALLOCATE] =
197 g_signal_new ("toggle_size_allocate",
198 G_OBJECT_CLASS_TYPE (gobject_class),
200 G_STRUCT_OFFSET (GtkMenuItemClass, toggle_size_allocate),
202 _gtk_marshal_NONE__INT,
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,
213 gtk_rc_property_parse_enum);
217 gtk_menu_item_init (GtkMenuItem *menu_item)
219 GTK_WIDGET_SET_FLAGS (menu_item, GTK_NO_WINDOW);
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 if (gtk_widget_get_direction (GTK_WIDGET (menu_item)) == GTK_TEXT_DIR_RTL)
226 menu_item->submenu_direction = GTK_DIRECTION_LEFT;
228 menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
229 menu_item->submenu_placement = GTK_TOP_BOTTOM;
230 menu_item->right_justify = FALSE;
232 menu_item->timer = 0;
236 gtk_menu_item_new (void)
238 return g_object_new (GTK_TYPE_MENU_ITEM, NULL);
242 gtk_menu_item_new_with_label (const gchar *label)
244 GtkWidget *menu_item;
245 GtkWidget *accel_label;
247 menu_item = gtk_menu_item_new ();
248 accel_label = gtk_accel_label_new (label);
249 gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
251 gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
252 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
253 gtk_widget_show (accel_label);
260 * gtk_menu_item_new_with_mnemonic:
261 * @label: The text of the button, with an underscore in front of the
263 * @returns: a new #GtkMenuItem
265 * Creates a new #GtkMenuItem containing a label. The label
266 * will be created using gtk_label_new_with_mnemonic(), so underscores
267 * in @label indicate the mnemonic for the menu item.
270 gtk_menu_item_new_with_mnemonic (const gchar *label)
272 GtkWidget *menu_item;
273 GtkWidget *accel_label;
275 menu_item = gtk_menu_item_new ();
276 accel_label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL);
277 gtk_label_set_text_with_mnemonic (GTK_LABEL (accel_label), label);
278 gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
280 gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
281 gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
282 gtk_widget_show (accel_label);
288 gtk_menu_item_destroy (GtkObject *object)
290 GtkMenuItem *menu_item;
292 g_return_if_fail (GTK_IS_MENU_ITEM (object));
294 menu_item = GTK_MENU_ITEM (object);
296 if (menu_item->submenu)
297 gtk_widget_destroy (menu_item->submenu);
299 GTK_OBJECT_CLASS (parent_class)->destroy (object);
303 gtk_menu_item_finalize (GObject *object)
305 GtkMenuItem *menu_item = GTK_MENU_ITEM (object);
307 g_free (menu_item->accel_path);
309 G_OBJECT_CLASS (parent_class)->finalize (object);
313 gtk_menu_item_detacher (GtkWidget *widget,
316 GtkMenuItem *menu_item;
318 g_return_if_fail (GTK_IS_MENU_ITEM (widget));
320 menu_item = GTK_MENU_ITEM (widget);
321 g_return_if_fail (menu_item->submenu == (GtkWidget*) menu);
323 menu_item->submenu = NULL;
327 gtk_menu_item_set_submenu (GtkMenuItem *menu_item,
330 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
332 if (menu_item->submenu != submenu)
334 gtk_menu_item_remove_submenu (menu_item);
336 menu_item->submenu = submenu;
337 gtk_menu_attach_to_widget (GTK_MENU (submenu),
338 GTK_WIDGET (menu_item),
339 gtk_menu_item_detacher);
341 if (GTK_WIDGET (menu_item)->parent)
342 gtk_widget_queue_resize (GTK_WIDGET (menu_item));
347 * gtk_menu_item_get_submenu:
348 * @menu_item: a #GtkMenuItem
350 * Gets the submenu underneath this menu item, if any. See
351 * gtk_menu_item_set_submenu().
353 * Return value: submenu for this menu item, or %NULL if none.
356 gtk_menu_item_get_submenu (GtkMenuItem *menu_item)
358 g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), NULL);
360 return menu_item->submenu;
364 gtk_menu_item_remove_submenu (GtkMenuItem *menu_item)
366 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
368 if (menu_item->submenu)
369 gtk_menu_detach (GTK_MENU (menu_item->submenu));
372 void _gtk_menu_item_set_placement (GtkMenuItem *menu_item,
373 GtkSubmenuPlacement placement);
376 _gtk_menu_item_set_placement (GtkMenuItem *menu_item,
377 GtkSubmenuPlacement placement)
379 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
381 menu_item->submenu_placement = placement;
385 gtk_menu_item_select (GtkMenuItem *menu_item)
387 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
389 gtk_item_select (GTK_ITEM (menu_item));
393 gtk_menu_item_deselect (GtkMenuItem *menu_item)
395 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
397 gtk_item_deselect (GTK_ITEM (menu_item));
401 gtk_menu_item_activate (GtkMenuItem *menu_item)
403 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
405 g_signal_emit (menu_item, menu_item_signals[ACTIVATE], 0);
409 gtk_menu_item_toggle_size_request (GtkMenuItem *menu_item,
412 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
414 g_signal_emit (menu_item, menu_item_signals[TOGGLE_SIZE_REQUEST], 0, requisition);
418 gtk_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
421 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
423 g_signal_emit (menu_item, menu_item_signals[TOGGLE_SIZE_ALLOCATE], 0, allocation);
427 gtk_menu_item_accel_width_foreach (GtkWidget *widget,
432 if (GTK_IS_ACCEL_LABEL (widget))
436 w = gtk_accel_label_get_accel_width (GTK_ACCEL_LABEL (widget));
437 *width = MAX (*width, w);
439 else if (GTK_IS_CONTAINER (widget))
440 gtk_container_foreach (GTK_CONTAINER (widget),
441 gtk_menu_item_accel_width_foreach,
446 gtk_menu_item_size_request (GtkWidget *widget,
447 GtkRequisition *requisition)
449 GtkMenuItem *menu_item;
453 g_return_if_fail (GTK_IS_MENU_ITEM (widget));
454 g_return_if_fail (requisition != NULL);
456 bin = GTK_BIN (widget);
457 menu_item = GTK_MENU_ITEM (widget);
459 requisition->width = (GTK_CONTAINER (widget)->border_width +
460 widget->style->xthickness +
462 requisition->height = (GTK_CONTAINER (widget)->border_width +
463 widget->style->ythickness) * 2;
465 if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
467 GtkRequisition child_requisition;
469 gtk_widget_size_request (bin->child, &child_requisition);
471 requisition->width += child_requisition.width;
472 requisition->height += child_requisition.height;
474 if (menu_item->submenu && menu_item->show_submenu_indicator)
475 requisition->width += child_requisition.height;
479 gtk_container_foreach (GTK_CONTAINER (menu_item),
480 gtk_menu_item_accel_width_foreach,
482 menu_item->accelerator_width = accel_width;
486 gtk_menu_item_size_allocate (GtkWidget *widget,
487 GtkAllocation *allocation)
489 GtkMenuItem *menu_item;
491 GtkAllocation child_allocation;
492 GtkTextDirection direction;
494 g_return_if_fail (GTK_IS_MENU_ITEM (widget));
495 g_return_if_fail (allocation != NULL);
497 menu_item = GTK_MENU_ITEM (widget);
498 bin = GTK_BIN (widget);
500 direction = gtk_widget_get_direction (widget);
502 widget->allocation = *allocation;
506 GtkRequisition child_requisition;
508 child_allocation.x = (GTK_CONTAINER (widget)->border_width +
509 widget->style->xthickness +
511 child_allocation.y = (GTK_CONTAINER (widget)->border_width +
512 widget->style->ythickness);
513 child_allocation.width = MAX (1, (gint)allocation->width - child_allocation.x * 2);
514 child_allocation.height = MAX (1, (gint)allocation->height - child_allocation.y * 2);
515 if (direction == GTK_TEXT_DIR_LTR)
516 child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
517 child_allocation.width -= GTK_MENU_ITEM (widget)->toggle_size;
518 child_allocation.x += widget->allocation.x;
519 child_allocation.y += widget->allocation.y;
521 gtk_widget_get_child_requisition (bin->child, &child_requisition);
522 if (menu_item->submenu && menu_item->show_submenu_indicator)
524 if (direction == GTK_TEXT_DIR_RTL)
525 child_allocation.x += child_requisition.height;
526 child_allocation.width -= child_requisition.height;
529 if (child_allocation.width < 1)
530 child_allocation.width = 1;
532 gtk_widget_size_allocate (bin->child, &child_allocation);
535 if (GTK_WIDGET_REALIZED (widget))
536 gdk_window_move_resize (menu_item->event_window,
537 allocation->x, allocation->y,
538 allocation->width, allocation->height);
540 if (menu_item->submenu)
541 gtk_menu_reposition (GTK_MENU (menu_item->submenu));
545 gtk_menu_item_realize (GtkWidget *widget)
547 GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
548 GdkWindowAttr attributes;
549 gint attributes_mask;
551 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
553 widget->window = gtk_widget_get_parent_window (widget);
554 g_object_ref (widget->window);
556 attributes.x = widget->allocation.x;
557 attributes.y = widget->allocation.y;
558 attributes.width = widget->allocation.width;
559 attributes.height = widget->allocation.height;
560 attributes.window_type = GDK_WINDOW_CHILD;
561 attributes.wclass = GDK_INPUT_ONLY;
562 attributes.event_mask = (gtk_widget_get_events (widget) |
564 GDK_BUTTON_PRESS_MASK |
565 GDK_BUTTON_RELEASE_MASK |
566 GDK_ENTER_NOTIFY_MASK |
567 GDK_LEAVE_NOTIFY_MASK |
568 GDK_POINTER_MOTION_MASK);
570 attributes_mask = GDK_WA_X | GDK_WA_Y;
571 menu_item->event_window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
572 gdk_window_set_user_data (menu_item->event_window, widget);
574 widget->style = gtk_style_attach (widget->style, widget->window);
578 gtk_menu_item_unrealize (GtkWidget *widget)
580 GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
582 gdk_window_set_user_data (menu_item->event_window, NULL);
583 gdk_window_destroy (menu_item->event_window);
584 menu_item->event_window = NULL;
586 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
587 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
591 gtk_menu_item_map (GtkWidget *widget)
593 GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
595 GTK_WIDGET_CLASS (parent_class)->map (widget);
597 gdk_window_show (menu_item->event_window);
601 gtk_menu_item_unmap (GtkWidget *widget)
603 GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
605 gdk_window_hide (menu_item->event_window);
607 GTK_WIDGET_CLASS (parent_class)->unmap (widget);
611 gtk_menu_item_paint (GtkWidget *widget,
614 GtkMenuItem *menu_item;
615 GtkStateType state_type;
616 GtkShadowType shadow_type, selected_shadow_type;
619 gint border_width = GTK_CONTAINER (widget)->border_width;
621 if (GTK_WIDGET_DRAWABLE (widget))
623 menu_item = GTK_MENU_ITEM (widget);
625 state_type = widget->state;
627 x = widget->allocation.x + border_width;
628 y = widget->allocation.y + border_width;
629 width = widget->allocation.width - border_width * 2;
630 height = widget->allocation.height - border_width * 2;
632 if ((state_type == GTK_STATE_PRELIGHT) &&
633 (GTK_BIN (menu_item)->child))
635 gtk_widget_style_get (widget,
636 "selected_shadow_type", &selected_shadow_type,
638 gtk_paint_box (widget->style,
641 selected_shadow_type,
642 area, widget, "menuitem",
643 x, y, width, height);
646 if (menu_item->submenu && menu_item->show_submenu_indicator)
648 GtkRequisition child_requisition;
649 gint arrow_x, arrow_y;
652 GtkTextDirection direction;
653 GtkArrowType arrow_type;
655 direction = gtk_widget_get_direction (widget);
657 gtk_widget_get_child_requisition (GTK_BIN (menu_item)->child,
660 arrow_size = child_requisition.height - 2 * widget->style->ythickness;
661 arrow_extent = arrow_size * 0.6;
663 shadow_type = GTK_SHADOW_OUT;
664 if (state_type == GTK_STATE_PRELIGHT)
665 shadow_type = GTK_SHADOW_IN;
667 if (direction == GTK_TEXT_DIR_LTR) {
668 arrow_x = x + width - 1 - arrow_size + (arrow_size - arrow_extent) / 2;
669 arrow_type = GTK_ARROW_RIGHT;
672 arrow_x = x + 1 + (arrow_size - arrow_extent) / 2;
673 arrow_type = GTK_ARROW_LEFT;
676 arrow_y = y + (height - arrow_extent) / 2;
678 gtk_paint_arrow (widget->style, widget->window,
679 state_type, shadow_type,
680 area, widget, "menuitem",
683 arrow_extent, arrow_extent);
685 else if (!GTK_BIN (menu_item)->child)
687 gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
688 area, widget, "menuitem",
689 widget->allocation.x, widget->allocation.width,
690 widget->allocation.y);
696 gtk_menu_item_expose (GtkWidget *widget,
697 GdkEventExpose *event)
699 g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
700 g_return_val_if_fail (event != NULL, FALSE);
702 if (GTK_WIDGET_DRAWABLE (widget))
704 gtk_menu_item_paint (widget, &event->area);
706 (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
713 get_popup_delay (GtkMenuItem *menu_item)
715 GtkWidget *parent = GTK_WIDGET (menu_item)->parent;
717 if (GTK_IS_MENU_SHELL (parent))
719 return _gtk_menu_shell_get_popup_delay (GTK_MENU_SHELL (parent));
725 g_object_get (G_OBJECT (gtk_widget_get_settings (GTK_WIDGET (menu_item))),
726 "gtk-menu-popup-delay", &popup_delay,
734 gtk_real_menu_item_select (GtkItem *item)
736 GtkMenuItem *menu_item;
738 g_return_if_fail (GTK_IS_MENU_ITEM (item));
740 menu_item = GTK_MENU_ITEM (item);
742 if (menu_item->submenu)
746 if (menu_item->timer)
747 gtk_timeout_remove (menu_item->timer);
749 popup_delay = get_popup_delay (menu_item);
753 GdkEvent *event = gtk_get_current_event ();
755 menu_item->timer = gtk_timeout_add (popup_delay,
756 gtk_menu_item_select_timeout,
759 event->type != GDK_BUTTON_PRESS &&
760 event->type != GDK_ENTER_NOTIFY)
761 menu_item->timer_from_keypress = TRUE;
763 menu_item->timer_from_keypress = FALSE;
766 gdk_event_free (event);
769 gtk_menu_item_popup_submenu (menu_item);
772 gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_PRELIGHT);
773 gtk_widget_queue_draw (GTK_WIDGET (menu_item));
777 gtk_real_menu_item_deselect (GtkItem *item)
779 GtkMenuItem *menu_item;
781 g_return_if_fail (GTK_IS_MENU_ITEM (item));
783 menu_item = GTK_MENU_ITEM (item);
785 if (menu_item->submenu)
787 if (menu_item->timer)
789 gtk_timeout_remove (menu_item->timer);
790 menu_item->timer = 0;
793 gtk_menu_popdown (GTK_MENU (menu_item->submenu));
796 gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_NORMAL);
797 gtk_widget_queue_draw (GTK_WIDGET (menu_item));
801 gtk_menu_item_mnemonic_activate (GtkWidget *widget,
802 gboolean group_cycling)
806 if (widget->parent &&
807 GTK_IS_MENU_SHELL (widget->parent))
808 gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent),
813 g_signal_emit (widget, menu_item_signals[ACTIVATE_ITEM], 0);
820 gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
823 GtkMenuShell *submenu;
825 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
827 widget = GTK_WIDGET (menu_item);
829 if (widget->parent &&
830 GTK_IS_MENU_SHELL (widget->parent))
832 if (menu_item->submenu == NULL)
833 gtk_menu_shell_activate_item (GTK_MENU_SHELL (widget->parent),
837 GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget->parent);
839 _gtk_menu_shell_activate (menu_shell);
841 gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent), widget);
842 gtk_menu_item_popup_submenu (widget);
844 gtk_menu_shell_select_first (GTK_MENU_SHELL (menu_item->submenu), TRUE);
845 submenu = GTK_MENU_SHELL (menu_item->submenu);
850 gtk_real_menu_item_toggle_size_request (GtkMenuItem *menu_item,
853 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
859 gtk_real_menu_item_toggle_size_allocate (GtkMenuItem *menu_item,
862 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
864 menu_item->toggle_size = allocation;
868 gtk_menu_item_select_timeout (gpointer data)
870 GtkMenuItem *menu_item;
873 GDK_THREADS_ENTER ();
875 menu_item = GTK_MENU_ITEM (data);
877 parent = GTK_WIDGET (menu_item)->parent;
879 if (parent && GTK_IS_MENU_SHELL (parent) && GTK_MENU_SHELL (parent)->active)
881 gtk_menu_item_popup_submenu (data);
882 if (menu_item->timer_from_keypress && menu_item->submenu)
883 GTK_MENU_SHELL (menu_item->submenu)->ignore_enter = TRUE;
886 GDK_THREADS_LEAVE ();
892 gtk_menu_item_popup_submenu (gpointer data)
895 GtkMenuItem *menu_item;
897 widget = GTK_WIDGET (data);
898 menu_item = GTK_MENU_ITEM (widget);
900 if (menu_item->timer)
901 gtk_timeout_remove (menu_item->timer);
902 menu_item->timer = 0;
904 if (GTK_WIDGET_IS_SENSITIVE (menu_item->submenu))
905 gtk_menu_popup (GTK_MENU (menu_item->submenu),
908 gtk_menu_item_position_menu,
910 GTK_MENU_SHELL (widget->parent)->button,
915 gtk_menu_item_position_menu (GtkMenu *menu,
921 GtkMenuItem *menu_item;
923 GtkWidget *parent_menu_item;
925 gint twidth, theight;
927 GtkTextDirection direction;
928 GdkRectangle monitor;
931 g_return_if_fail (menu != NULL);
932 g_return_if_fail (x != NULL);
933 g_return_if_fail (y != NULL);
935 menu_item = GTK_MENU_ITEM (user_data);
936 widget = GTK_WIDGET (user_data);
938 direction = gtk_widget_get_direction (widget);
940 twidth = GTK_WIDGET (menu)->requisition.width;
941 theight = GTK_WIDGET (menu)->requisition.height;
943 screen = gtk_widget_get_screen (widget);
944 monitor_num = gdk_screen_get_monitor_at_window (screen, widget->window);
947 gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
949 if (!gdk_window_get_origin (widget->window, &tx, &ty))
951 g_warning ("Menu not on screen");
955 tx += widget->allocation.x;
956 ty += widget->allocation.y;
958 switch (menu_item->submenu_placement)
961 if (direction == GTK_TEXT_DIR_LTR)
962 menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
965 menu_item->submenu_direction = GTK_DIRECTION_LEFT;
966 tx += widget->allocation.width - twidth;
969 if ((ty + widget->allocation.height + theight) <= monitor.y + monitor.height)
970 ty += widget->allocation.height;
971 else if ((ty - theight) >= monitor.y)
973 else if (monitor.y + monitor.height - (ty + widget->allocation.height) > ty)
974 ty += widget->allocation.height;
980 parent_menu_item = GTK_MENU (widget->parent)->parent_menu_item;
981 if (parent_menu_item &&
982 !GTK_MENU (widget->parent)->torn_off &&
983 !GTK_MENU_SHELL (menu)->active)
984 menu_item->submenu_direction = GTK_MENU_ITEM (parent_menu_item)->submenu_direction;
985 else if (direction == GTK_TEXT_DIR_LTR)
986 menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
988 menu_item->submenu_direction = GTK_DIRECTION_LEFT;
990 switch (menu_item->submenu_direction)
992 case GTK_DIRECTION_LEFT:
993 if ((tx - twidth) >= monitor.x)
997 menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
998 tx += widget->allocation.width - 5;
1002 case GTK_DIRECTION_RIGHT:
1003 if ((tx + widget->allocation.width + twidth - 5) <= monitor.x + monitor.width)
1004 tx += widget->allocation.width - 5;
1007 menu_item->submenu_direction = GTK_DIRECTION_LEFT;
1013 ty += widget->allocation.height / 4;
1015 /* If the height of the menu doesn't fit we move it upward. */
1016 ty = CLAMP (ty, monitor.y, MAX (monitor.y, monitor.y + monitor.height - theight));
1020 /* If we have negative, tx, here it is because we can't get
1021 * the menu all the way on screen. Favor the left portion.
1023 *x = CLAMP (tx, monitor.x, MAX (monitor.x, monitor.x + monitor.width - twidth));
1028 * gtk_menu_item_set_right_justified:
1029 * @menu_item: a #GtkMenuItem.
1030 * @right_justified: if %TRUE the menu item will appear at the
1031 * far right if added to a menu bar.
1033 * Sets whether the menu item appears justified at the right
1034 * side of a menu bar. This was traditionally done for "Help" menu
1035 * items, but is now considered a bad idea. (If the widget
1036 * layout is reversed for a right-to-left language like Hebrew
1037 * or Arabic, right-justified-menu-items appear at the left.)
1040 gtk_menu_item_set_right_justified (GtkMenuItem *menu_item,
1041 gboolean right_justified)
1043 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1045 right_justified = right_justified != FALSE;
1047 if (right_justified != menu_item->right_justify)
1049 menu_item->right_justify = right_justified;
1050 gtk_widget_queue_resize (GTK_WIDGET (menu_item));
1055 * gtk_menu_item_get_right_justified:
1056 * @menu_item: a #GtkMenuItem
1058 * Gets whether the menu item appears justified at the right
1059 * side of the menu bar.
1061 * Return value: %TRUE if the menu item will appear at the
1062 * far right if added to a menu bar.
1065 gtk_menu_item_get_right_justified (GtkMenuItem *menu_item)
1067 g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), FALSE);
1069 return menu_item->right_justify;
1074 gtk_menu_item_show_all (GtkWidget *widget)
1076 GtkMenuItem *menu_item;
1078 g_return_if_fail (GTK_IS_MENU_ITEM (widget));
1080 menu_item = GTK_MENU_ITEM (widget);
1082 /* show children including submenu */
1083 if (menu_item->submenu)
1084 gtk_widget_show_all (menu_item->submenu);
1085 gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);
1087 gtk_widget_show (widget);
1091 gtk_menu_item_hide_all (GtkWidget *widget)
1093 GtkMenuItem *menu_item;
1095 g_return_if_fail (GTK_IS_MENU_ITEM (widget));
1097 gtk_widget_hide (widget);
1099 menu_item = GTK_MENU_ITEM (widget);
1101 /* hide children including submenu */
1102 gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
1103 if (menu_item->submenu)
1104 gtk_widget_hide_all (menu_item->submenu);
1108 gtk_menu_item_accel_name_foreach (GtkWidget *widget,
1111 const gchar **path_p = data;
1115 if (GTK_IS_LABEL (widget))
1117 *path_p = gtk_label_get_text (GTK_LABEL (widget));
1118 if (*path_p && (*path_p)[0] == 0)
1121 else if (GTK_IS_CONTAINER (widget))
1122 gtk_container_foreach (GTK_CONTAINER (widget),
1123 gtk_menu_item_accel_name_foreach,
1129 gtk_menu_item_parent_set (GtkWidget *widget,
1130 GtkWidget *previous_parent)
1132 GtkMenuItem *menu_item = GTK_MENU_ITEM (widget);
1133 GtkMenu *menu = GTK_IS_MENU (widget->parent) ? GTK_MENU (widget->parent) : NULL;
1136 _gtk_menu_item_refresh_accel_path (menu_item,
1141 if (GTK_WIDGET_CLASS (parent_class)->parent_set)
1142 GTK_WIDGET_CLASS (parent_class)->parent_set (widget, previous_parent);
1146 _gtk_menu_item_refresh_accel_path (GtkMenuItem *menu_item,
1147 const gchar *prefix,
1148 GtkAccelGroup *accel_group,
1149 gboolean group_changed)
1154 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1155 g_return_if_fail (!accel_group || GTK_IS_ACCEL_GROUP (accel_group));
1157 widget = GTK_WIDGET (menu_item);
1161 gtk_widget_set_accel_path (widget, NULL, NULL);
1165 path = _gtk_widget_get_accel_path (widget, NULL);
1166 if (!path) /* no active accel_path yet */
1168 path = menu_item->accel_path;
1169 if (!path && prefix)
1171 gchar *postfix = NULL;
1173 /* try to construct one from label text */
1174 gtk_container_foreach (GTK_CONTAINER (menu_item),
1175 gtk_menu_item_accel_name_foreach,
1177 menu_item->accel_path = postfix ? g_strconcat (prefix, "/", postfix, NULL) : NULL;
1178 path = menu_item->accel_path;
1181 gtk_widget_set_accel_path (widget, path, accel_group);
1183 else if (group_changed) /* reinstall accelerators */
1184 gtk_widget_set_accel_path (widget, path, accel_group);
1188 * gtk_menu_item_set_accel_path
1189 * @menu_item: a valid #GtkMenuItem
1190 * @accel_path: accelerator path, corresponding to this menu item's
1191 * functionality, or %NULL to unset the current path.
1193 * Set the accelerator path on @menu_item, through which runtime changes of the
1194 * menu item's accelerator caused by the user can be identified and saved to
1195 * persistant storage (see gtk_accel_map_save() on this).
1196 * To setup a default accelerator for this menu item, call
1197 * gtk_accel_map_add_entry() with the same @accel_path.
1198 * See also gtk_accel_map_add_entry() on the specifics of accelerator paths,
1199 * and gtk_menu_set_accel_path() for a more convenient variant of this function.
1201 * This function is basically a convenience wrapper that handles calling
1202 * gtk_widget_set_accel_path() with the appropriate accelerator group for
1205 * Note that you do need to set an accelerator on the parent menu with
1206 * gtk_menu_set_accel_group() for this to work.
1209 gtk_menu_item_set_accel_path (GtkMenuItem *menu_item,
1210 const gchar *accel_path)
1214 g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
1215 g_return_if_fail (accel_path == NULL ||
1216 (accel_path[0] == '<' && strchr (accel_path, '/')));
1218 widget = GTK_WIDGET (menu_item);
1220 /* store new path */
1221 g_free (menu_item->accel_path);
1222 menu_item->accel_path = g_strdup (accel_path);
1224 /* forget accelerators associated with old path */
1225 gtk_widget_set_accel_path (widget, NULL, NULL);
1227 /* install accelerators associated with new path */
1228 if (widget->parent && GTK_IS_MENU (widget->parent))
1230 GtkMenu *menu = GTK_MENU (widget->parent);
1232 if (menu->accel_group)
1233 _gtk_menu_item_refresh_accel_path (GTK_MENU_ITEM (widget),
1241 gtk_menu_item_forall (GtkContainer *container,
1242 gboolean include_internals,
1243 GtkCallback callback,
1244 gpointer callback_data)
1247 GtkMenuItem *menu_item;
1249 g_return_if_fail (GTK_IS_MENU_ITEM (container));
1250 g_return_if_fail (callback != NULL);
1252 bin = GTK_BIN (container);
1253 menu_item = GTK_MENU_ITEM (container);
1256 callback (bin->child, callback_data);
1260 _gtk_menu_item_is_selectable (GtkWidget *menu_item)
1262 if ((!GTK_BIN (menu_item)->child &&
1263 G_OBJECT_TYPE (menu_item) == GTK_TYPE_MENU_ITEM) ||
1264 GTK_IS_SEPARATOR_MENU_ITEM (menu_item) ||
1265 !GTK_WIDGET_IS_SENSITIVE (menu_item) ||
1266 !GTK_WIDGET_VISIBLE (menu_item))