* Boston, MA 02111-1307, USA.
*/
#include <string.h>
-#include "gtklabel.h"
+#include "gtkaccellabel.h"
#include "gtkmain.h"
#include "gtkmenu.h"
+#include "gtkmenubar.h"
#include "gtkmenuitem.h"
#include "gtksignal.h"
#define BORDER_SPACING 3
-#define SELECT_TIMEOUT 20
+#define SELECT_TIMEOUT 75
#define MENU_ITEM_CLASS(w) GTK_MENU_ITEM_CLASS (GTK_OBJECT (w)->klass)
enum {
ACTIVATE,
+ ACTIVATE_ITEM,
LAST_SIGNAL
};
GtkRequisition *requisition);
static void gtk_menu_item_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
-static gint gtk_menu_item_install_accel (GtkWidget *widget,
- const gchar *signal_name,
- gchar key,
- guint8 modifiers);
-static void gtk_menu_item_remove_accel (GtkWidget *widget,
- const gchar *signal_name);
static void gtk_menu_item_paint (GtkWidget *widget,
GdkRectangle *area);
static void gtk_menu_item_draw (GtkWidget *widget,
GdkRectangle *area);
static gint gtk_menu_item_expose (GtkWidget *widget,
GdkEventExpose *event);
-static gint gtk_menu_item_enter (GtkWidget *widget,
- GdkEventCrossing *event);
-static gint gtk_menu_item_leave (GtkWidget *widget,
- GdkEventCrossing *event);
static void gtk_real_menu_item_select (GtkItem *item);
static void gtk_real_menu_item_deselect (GtkItem *item);
+static void gtk_real_menu_item_activate_item (GtkMenuItem *item);
static gint gtk_menu_item_select_timeout (gpointer data);
static void gtk_menu_item_position_menu (GtkMenu *menu,
gint *x,
gpointer user_data);
static void gtk_menu_item_show_all (GtkWidget *widget);
static void gtk_menu_item_hide_all (GtkWidget *widget);
+static void gtk_menu_item_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data);
static GtkItemClass *parent_class;
static guint menu_item_signals[LAST_SIGNAL] = { 0 };
+static guint32 last_submenu_deselect_time = 0;
-guint
-gtk_menu_item_get_type ()
+
+GtkType
+gtk_menu_item_get_type (void)
{
- static guint menu_item_type = 0;
+ static GtkType menu_item_type = 0;
if (!menu_item_type)
{
- GtkTypeInfo menu_item_info =
+ static const GtkTypeInfo menu_item_info =
{
"GtkMenuItem",
sizeof (GtkMenuItem),
sizeof (GtkMenuItemClass),
(GtkClassInitFunc) gtk_menu_item_class_init,
(GtkObjectInitFunc) gtk_menu_item_init,
- (GtkArgSetFunc) NULL,
- (GtkArgGetFunc) NULL,
+ /* reserved_1 */ NULL,
+ /* reserved_2 */ NULL,
+ (GtkClassInitFunc) NULL,
};
menu_item_type = gtk_type_unique (gtk_item_get_type (), &menu_item_info);
+ gtk_type_set_chunk_alloc (menu_item_type, 16);
}
return menu_item_type;
{
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
+ GtkContainerClass *container_class;
GtkItemClass *item_class;
object_class = (GtkObjectClass*) klass;
widget_class = (GtkWidgetClass*) klass;
+ container_class = (GtkContainerClass*) klass;
item_class = (GtkItemClass*) klass;
parent_class = gtk_type_class (gtk_item_get_type ());
menu_item_signals[ACTIVATE] =
gtk_signal_new ("activate",
- GTK_RUN_FIRST,
+ GTK_RUN_FIRST | GTK_RUN_ACTION,
object_class->type,
GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate),
+ gtk_marshal_NONE__NONE,
+ GTK_TYPE_NONE, 0);
+
+ menu_item_signals[ACTIVATE_ITEM] =
+ gtk_signal_new ("activate_item",
+ GTK_RUN_FIRST,
+ object_class->type,
+ GTK_SIGNAL_OFFSET (GtkMenuItemClass, activate_item),
gtk_signal_default_marshaller,
GTK_TYPE_NONE, 0);
widget_class->activate_signal = menu_item_signals[ACTIVATE];
widget_class->size_request = gtk_menu_item_size_request;
widget_class->size_allocate = gtk_menu_item_size_allocate;
- widget_class->install_accelerator = gtk_menu_item_install_accel;
- widget_class->remove_accelerator = gtk_menu_item_remove_accel;
widget_class->draw = gtk_menu_item_draw;
widget_class->expose_event = gtk_menu_item_expose;
- widget_class->enter_notify_event = gtk_menu_item_enter;
- widget_class->leave_notify_event = gtk_menu_item_leave;
widget_class->show_all = gtk_menu_item_show_all;
- widget_class->hide_all = gtk_menu_item_hide_all;
+ widget_class->hide_all = gtk_menu_item_hide_all;
+
+ container_class->forall = gtk_menu_item_forall;
item_class->select = gtk_real_menu_item_select;
item_class->deselect = gtk_real_menu_item_deselect;
klass->activate = NULL;
+ klass->activate_item = gtk_real_menu_item_activate_item;
klass->toggle_size = 0;
- klass->shift_text = "Shft";
- klass->control_text = "Ctl";
- klass->alt_text = "Alt";
- klass->separator_text = "+";
+ klass->hide_on_activate = TRUE;
}
static void
gtk_menu_item_init (GtkMenuItem *menu_item)
{
menu_item->submenu = NULL;
- menu_item->accelerator_key = 0;
- menu_item->accelerator_mods = 0;
- menu_item->accelerator_size = 0;
- menu_item->accelerator_signal = 0;
+ menu_item->accelerator_signal = menu_item_signals[ACTIVATE];
menu_item->toggle_size = 0;
+ menu_item->accelerator_width = 0;
menu_item->show_toggle_indicator = FALSE;
menu_item->show_submenu_indicator = FALSE;
menu_item->submenu_direction = GTK_DIRECTION_RIGHT;
}
GtkWidget*
-gtk_menu_item_new ()
+gtk_menu_item_new (void)
{
return GTK_WIDGET (gtk_type_new (gtk_menu_item_get_type ()));
}
gtk_menu_item_new_with_label (const gchar *label)
{
GtkWidget *menu_item;
- GtkWidget *label_widget;
+ GtkWidget *accel_label;
menu_item = gtk_menu_item_new ();
- label_widget = gtk_label_new (label);
- gtk_misc_set_alignment (GTK_MISC (label_widget), 0.0, 0.5);
+ accel_label = gtk_accel_label_new (label);
+ gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
- gtk_container_add (GTK_CONTAINER (menu_item), label_widget);
- gtk_widget_show (label_widget);
+ gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
+ gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), menu_item);
+ gtk_widget_show (accel_label);
return menu_item;
}
menu_item->submenu_placement = placement;
}
-void
-gtk_menu_item_accelerator_size (GtkMenuItem *menu_item)
-{
- char buf[32];
-
- g_return_if_fail (menu_item != NULL);
- g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
-
- if (menu_item->accelerator_key)
- {
- gtk_menu_item_accelerator_text (menu_item, buf);
- menu_item->accelerator_size = gdk_string_width (GTK_WIDGET (menu_item)->style->font, buf) + 13;
- }
- else if (menu_item->submenu && menu_item->show_submenu_indicator)
- {
- menu_item->accelerator_size = 21;
- }
- else
- {
- menu_item->accelerator_size = 0;
- }
-}
-
-void
-gtk_menu_item_accelerator_text (GtkMenuItem *menu_item,
- gchar *buffer)
-{
- g_return_if_fail (menu_item != NULL);
- g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
-
- if (menu_item->accelerator_key)
- {
- buffer[0] = '\0';
- if (menu_item->accelerator_mods & GDK_SHIFT_MASK)
- {
- strcat (buffer, MENU_ITEM_CLASS (menu_item)->shift_text);
- strcat (buffer, MENU_ITEM_CLASS (menu_item)->separator_text);
- }
- if (menu_item->accelerator_mods & GDK_CONTROL_MASK)
- {
- strcat (buffer, MENU_ITEM_CLASS (menu_item)->control_text);
- strcat (buffer, MENU_ITEM_CLASS (menu_item)->separator_text);
- }
- if (menu_item->accelerator_mods & GDK_MOD1_MASK)
- {
- strcat (buffer, MENU_ITEM_CLASS (menu_item)->alt_text);
- strcat (buffer, MENU_ITEM_CLASS (menu_item)->separator_text);
- }
- strncat (buffer, &menu_item->accelerator_key, 1);
- }
-}
-
void
gtk_menu_item_configure (GtkMenuItem *menu_item,
gint show_toggle_indicator,
void
gtk_menu_item_select (GtkMenuItem *menu_item)
{
+ g_return_if_fail (menu_item != NULL);
+ g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
+
gtk_item_select (GTK_ITEM (menu_item));
}
void
gtk_menu_item_deselect (GtkMenuItem *menu_item)
{
+ g_return_if_fail (menu_item != NULL);
+ g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
+
gtk_item_deselect (GTK_ITEM (menu_item));
}
void
gtk_menu_item_activate (GtkMenuItem *menu_item)
{
+ g_return_if_fail (menu_item != NULL);
+ g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
+
gtk_signal_emit (GTK_OBJECT (menu_item), menu_item_signals[ACTIVATE]);
}
+static void
+gtk_menu_item_accel_width_foreach (GtkWidget *widget,
+ gpointer data)
+{
+ guint *width = data;
+
+ if (GTK_IS_ACCEL_LABEL (widget))
+ {
+ guint w;
+
+ w = gtk_accel_label_get_accel_width (GTK_ACCEL_LABEL (widget));
+ *width = MAX (*width, w);
+ }
+ else if (GTK_IS_CONTAINER (widget))
+ gtk_container_foreach (GTK_CONTAINER (widget),
+ gtk_menu_item_accel_width_foreach,
+ data);
+}
static void
gtk_menu_item_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
+ GtkMenuItem *menu_item;
GtkBin *bin;
+ guint accel_width;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_MENU_ITEM (widget));
g_return_if_fail (requisition != NULL);
bin = GTK_BIN (widget);
-
- gtk_menu_item_accelerator_size (GTK_MENU_ITEM (widget));
+ menu_item = GTK_MENU_ITEM (widget);
requisition->width = (GTK_CONTAINER (widget)->border_width +
widget->style->klass->xthickness +
requisition->width += bin->child->requisition.width;
requisition->height += bin->child->requisition.height;
}
+
+ if (menu_item->submenu && menu_item->show_submenu_indicator)
+ requisition->width += 21;
+
+ accel_width = 0;
+ gtk_container_foreach (GTK_CONTAINER (menu_item),
+ gtk_menu_item_accel_width_foreach,
+ &accel_width);
+ menu_item->accelerator_width = accel_width;
}
static void
gtk_menu_item_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
+ GtkMenuItem *menu_item;
GtkBin *bin;
GtkAllocation child_allocation;
g_return_if_fail (GTK_IS_MENU_ITEM (widget));
g_return_if_fail (allocation != NULL);
- widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
- gdk_window_move_resize (widget->window,
- allocation->x, allocation->y,
- allocation->width, allocation->height);
-
+ menu_item = GTK_MENU_ITEM (widget);
bin = GTK_BIN (widget);
+
+ widget->allocation = *allocation;
if (bin->child)
{
child_allocation.x = (GTK_CONTAINER (widget)->border_width +
widget->style->klass->xthickness +
BORDER_SPACING);
- child_allocation.y = GTK_CONTAINER (widget)->border_width;
+ child_allocation.y = (GTK_CONTAINER (widget)->border_width +
+ widget->style->klass->ythickness);
child_allocation.width = MAX (1, allocation->width - child_allocation.x * 2);
child_allocation.height = MAX (1, allocation->height - child_allocation.y * 2);
child_allocation.x += GTK_MENU_ITEM (widget)->toggle_size;
- child_allocation.width -= (GTK_MENU_ITEM (widget)->toggle_size +
- GTK_MENU_ITEM (widget)->accelerator_size);
-
+ child_allocation.width -= GTK_MENU_ITEM (widget)->toggle_size;
+ if (menu_item->submenu && menu_item->show_submenu_indicator)
+ child_allocation.width -= 21;
+
gtk_widget_size_allocate (bin->child, &child_allocation);
}
-}
-
-static gint
-gtk_menu_item_install_accel (GtkWidget *widget,
- const gchar *signal_name,
- gchar key,
- guint8 modifiers)
-{
- GtkMenuItem *menu_item;
-
- g_return_val_if_fail (widget != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
- g_return_val_if_fail (signal_name != NULL, FALSE);
-
- menu_item = GTK_MENU_ITEM (widget);
-
- menu_item->accelerator_signal = gtk_signal_lookup (signal_name, GTK_OBJECT_TYPE (widget));
- if (menu_item->accelerator_signal > 0)
- {
- menu_item->accelerator_key = key;
- menu_item->accelerator_mods = modifiers;
-
- if (widget->parent)
- gtk_widget_queue_resize (widget);
-
- return TRUE;
- }
-
- return FALSE;
-}
-
-static void
-gtk_menu_item_remove_accel (GtkWidget *widget,
- const gchar *signal_name)
-{
- GtkMenuItem *menu_item;
- guint signal_num;
-
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MENU_ITEM (widget));
- g_return_if_fail (signal_name != NULL);
-
- menu_item = GTK_MENU_ITEM (widget);
- signal_num = gtk_signal_lookup (signal_name, GTK_OBJECT_TYPE (widget));
- if (menu_item->accelerator_signal == signal_num)
- {
- menu_item->accelerator_key = 0;
- menu_item->accelerator_mods = 0;
- menu_item->accelerator_signal = 0;
+ if (GTK_WIDGET_REALIZED (widget))
+ gdk_window_move_resize (widget->window,
+ allocation->x, allocation->y,
+ allocation->width, allocation->height);
- if (GTK_WIDGET_VISIBLE (widget))
- {
- gtk_widget_queue_draw (widget);
- GTK_MENU_SHELL (widget->parent)->menu_flag = TRUE;
- }
- else
- gtk_container_need_resize (GTK_CONTAINER (widget->parent));
- }
+ if (menu_item->submenu)
+ gtk_menu_reposition (GTK_MENU (menu_item->submenu));
}
static void
GtkMenuItem *menu_item;
GtkStateType state_type;
GtkShadowType shadow_type;
- GdkFont *font;
gint width, height;
gint x, y;
- char buf[32];
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_MENU_ITEM (widget));
if (!GTK_WIDGET_IS_SENSITIVE (widget))
state_type = GTK_STATE_INSENSITIVE;
- gtk_style_set_background (widget->style, widget->window, state_type);
- gdk_window_clear_area (widget->window, area->x, area->y, area->width, area->height);
-
x = GTK_CONTAINER (menu_item)->border_width;
y = GTK_CONTAINER (menu_item)->border_width;
width = widget->allocation.width - x * 2;
height = widget->allocation.height - y * 2;
-
+
if ((state_type == GTK_STATE_PRELIGHT) &&
(GTK_BIN (menu_item)->child))
- gtk_draw_shadow (widget->style,
- widget->window,
- GTK_STATE_PRELIGHT,
- GTK_SHADOW_OUT,
- x, y, width, height);
-
- if (menu_item->accelerator_key)
+ gtk_paint_box (widget->style,
+ widget->window,
+ GTK_STATE_PRELIGHT,
+ GTK_SHADOW_OUT,
+ area, widget, "menuitem",
+ x, y, width, height);
+ else
{
- gtk_menu_item_accelerator_text (menu_item, buf);
-
- font = widget->style->font;
- x = x + width - menu_item->accelerator_size + 13 - 4;
- y = y + ((height - (font->ascent + font->descent)) / 2) + font->ascent;
-
- if (state_type == GTK_STATE_INSENSITIVE)
- gdk_draw_string (widget->window, widget->style->font,
- widget->style->white_gc,
- x + 1, y + 1, buf);
-
- gdk_draw_string (widget->window, widget->style->font,
- widget->style->fg_gc[state_type],
- x, y, buf);
+ gdk_window_set_back_pixmap (widget->window, NULL, TRUE);
+ gdk_window_clear_area (widget->window, area->x, area->y, area->width, area->height);
}
- else if (menu_item->submenu && menu_item->show_submenu_indicator)
+
+ if (menu_item->submenu && menu_item->show_submenu_indicator)
{
shadow_type = GTK_SHADOW_OUT;
if (state_type == GTK_STATE_PRELIGHT)
shadow_type = GTK_SHADOW_IN;
- gtk_draw_arrow (widget->style, widget->window,
- state_type, shadow_type, GTK_ARROW_RIGHT, FALSE,
- x + width - 15, y + height / 2 - 5, 10, 10);
+ gtk_paint_arrow (widget->style, widget->window,
+ state_type, shadow_type,
+ area, widget, "menuitem",
+ GTK_ARROW_RIGHT, TRUE,
+ x + width - 15, y + height / 2 - 5, 10, 10);
}
else if (!GTK_BIN (menu_item)->child)
{
- gtk_draw_hline (widget->style, widget->window, GTK_STATE_NORMAL,
- 0, widget->allocation.width, 0);
+ gtk_paint_hline (widget->style, widget->window, GTK_STATE_NORMAL,
+ area, widget, "menuitem",
+ 0, widget->allocation.width, 0);
}
}
}
return FALSE;
}
-static gint
-gtk_menu_item_enter (GtkWidget *widget,
- GdkEventCrossing *event)
-{
- g_return_val_if_fail (widget != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- return gtk_widget_event (widget->parent, (GdkEvent*) event);
-}
-
-static gint
-gtk_menu_item_leave (GtkWidget *widget,
- GdkEventCrossing *event)
-{
- g_return_val_if_fail (widget != NULL, FALSE);
- g_return_val_if_fail (GTK_IS_MENU_ITEM (widget), FALSE);
- g_return_val_if_fail (event != NULL, FALSE);
-
- return gtk_widget_event (widget->parent, (GdkEvent*) event);
-}
-
static void
gtk_real_menu_item_select (GtkItem *item)
{
menu_item = GTK_MENU_ITEM (item);
- if (menu_item->submenu && !GTK_WIDGET_VISIBLE (menu_item->submenu))
- menu_item->timer = gtk_timeout_add (SELECT_TIMEOUT, gtk_menu_item_select_timeout, menu_item);
-
+ /* if (menu_item->submenu && !GTK_WIDGET_VISIBLE (menu_item->submenu))*/
+ if (menu_item->submenu)
+ {
+ guint32 etime;
+ GdkEvent *event = gtk_get_current_event ();
+
+ etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
+ if (etime >= last_submenu_deselect_time &&
+ last_submenu_deselect_time + SELECT_TIMEOUT > etime)
+ menu_item->timer = gtk_timeout_add (SELECT_TIMEOUT - (etime - last_submenu_deselect_time),
+ gtk_menu_item_select_timeout,
+ menu_item);
+ else
+ gtk_menu_item_select_timeout (menu_item);
+ if(event) gdk_event_free(event);
+ }
+
gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_PRELIGHT);
gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
}
if (menu_item->submenu)
{
+ guint32 etime;
+ GdkEvent *event = gtk_get_current_event ();
+
if (menu_item->timer)
- gtk_timeout_remove (menu_item->timer);
+ {
+ gtk_timeout_remove (menu_item->timer);
+ menu_item->timer = 0;
+ }
else
gtk_menu_popdown (GTK_MENU (menu_item->submenu));
+
+ etime = event ? gdk_event_get_time (event) : GDK_CURRENT_TIME;
+ if (etime > last_submenu_deselect_time)
+ last_submenu_deselect_time = etime;
+ if(event) gdk_event_free(event);
}
gtk_widget_set_state (GTK_WIDGET (menu_item), GTK_STATE_NORMAL);
gtk_widget_draw (GTK_WIDGET (menu_item), NULL);
}
+static void
+gtk_real_menu_item_activate_item (GtkMenuItem *menu_item)
+{
+ GtkWidget *widget;
+
+ g_return_if_fail (menu_item != NULL);
+ g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
+
+ widget = GTK_WIDGET (menu_item);
+
+ if (widget->parent &&
+ GTK_IS_MENU_SHELL (widget->parent))
+ {
+ if (menu_item->submenu == NULL)
+ gtk_menu_shell_activate_item (GTK_MENU_SHELL (widget->parent),
+ widget, TRUE);
+ else
+ {
+ GtkMenuShell *menu_shell = GTK_MENU_SHELL (widget->parent);
+
+ if (!menu_shell->active)
+ {
+ gtk_grab_add (GTK_WIDGET (menu_shell));
+ menu_shell->have_grab = TRUE;
+ menu_shell->active = TRUE;
+ }
+
+ gtk_menu_shell_select_item (GTK_MENU_SHELL (widget->parent), widget);
+ }
+ }
+}
+
static gint
gtk_menu_item_select_timeout (gpointer data)
{
GtkMenuItem *menu_item;
+ GDK_THREADS_ENTER ();
+
menu_item = GTK_MENU_ITEM (data);
menu_item->timer = 0;
GTK_MENU_SHELL (GTK_WIDGET (menu_item)->parent)->button,
0);
+ /* This is a bit of a hack - we want to select the first item
+ * of menus hanging of a menu bar, but not for cascading submenus
+ */
+ if (GTK_IS_MENU_BAR (GTK_WIDGET (menu_item)->parent))
+ {
+ GtkMenuShell *submenu = GTK_MENU_SHELL (menu_item->submenu);
+ if (submenu->children)
+ gtk_menu_shell_select_item (submenu, submenu->children->data);
+ }
+
+ GDK_THREADS_LEAVE ();
+
return FALSE;
}
menuitem->right_justify = 1;
}
+
static void
gtk_menu_item_show_all (GtkWidget *widget)
{
- GtkContainer *container;
- GtkMenuItem *menu_item;
+ GtkMenuItem *menu_item;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_MENU_ITEM (widget));
- container = GTK_CONTAINER (widget);
+
menu_item = GTK_MENU_ITEM (widget);
- /* Show children, traverse to submenu, show self. */
- gtk_container_foreach (container, (GtkCallback) gtk_widget_show_all, NULL);
+ /* show children including submenu */
if (menu_item->submenu)
gtk_widget_show_all (menu_item->submenu);
+ gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);
+
gtk_widget_show (widget);
}
-
static void
gtk_menu_item_hide_all (GtkWidget *widget)
{
- GtkContainer *container;
- GtkMenuItem *menu_item;
+ GtkMenuItem *menu_item;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_MENU_ITEM (widget));
- container = GTK_CONTAINER (widget);
- menu_item = GTK_MENU_ITEM (widget);
- /* Reverse order of gtk_menu_item_show_all */
gtk_widget_hide (widget);
+
+ menu_item = GTK_MENU_ITEM (widget);
+
+ /* hide children including submenu */
+ gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
if (menu_item->submenu)
gtk_widget_hide_all (menu_item->submenu);
- gtk_container_foreach (container, (GtkCallback) gtk_widget_hide_all, NULL);
+}
+
+static void
+gtk_menu_item_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
+{
+ GtkBin *bin;
+ GtkMenuItem *menu_item;
+
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (GTK_IS_MENU_ITEM (container));
+ g_return_if_fail (callback != NULL);
+
+ bin = GTK_BIN (container);
+ menu_item = GTK_MENU_ITEM (container);
+
+ if (bin->child)
+ (* callback) (bin->child, callback_data);
+ if (include_internals && menu_item->submenu)
+ (* callback) (menu_item->submenu, callback_data);
}
projects / ~andy / gtk / blobdiff