自学教程：C++ GTK_IS_MENU函数代码示例

PanelWidget *menu_get_panel (GtkWidget *menu){	PanelWidget *retval = NULL;	g_return_val_if_fail (menu != NULL, NULL);	if (GTK_IS_MENU_ITEM (menu))		menu = gtk_widget_get_parent (menu);	g_return_val_if_fail (GTK_IS_MENU (menu), NULL);	while (menu) {		retval = g_object_get_data (G_OBJECT (menu), "menu_panel");		if (retval)			break;		menu = gtk_widget_get_parent (gtk_menu_get_attach_widget (GTK_MENU (menu)));		if (!GTK_IS_MENU (menu))			break;	}	if (retval && !PANEL_IS_WIDGET (retval)) {		g_warning ("Invalid PanelWidget associated with menu");		retval = NULL;	}	if (!retval) {		g_warning ("Cannot find the PanelWidget associated with menu");		retval = panels->data;	}	return retval;}

static void serializer_visit (Serializer* self, GtkWidget* widget) {    g_return_if_fail (self != NULL);    g_return_if_fail (widget != NULL);    if (GTK_IS_MENU_BAR (widget)) {        GtkWidget* _tmp0_;        serializer_visit_menubar (self, (_tmp0_ = widget, GTK_IS_MENU_BAR (_tmp0_) ? ((GtkMenuBar*) _tmp0_) : NULL));    } else {        if (GTK_IS_MENU (widget)) {            GtkWidget* _tmp1_;            serializer_visit_menu (self, (_tmp1_ = widget, GTK_IS_MENU (_tmp1_) ? ((GtkMenu*) _tmp1_) : NULL));        } else {            if (GTK_IS_MENU_ITEM (widget)) {                GtkWidget* _tmp2_;                serializer_visit_menuitem (self, (_tmp2_ = widget, GTK_IS_MENU_ITEM (_tmp2_) ? ((GtkMenuItem*) _tmp2_) : NULL));            } else {                if (GTK_IS_LABEL (widget)) {                    GtkWidget* _tmp3_;                    serializer_visit_label (self, (_tmp3_ = widget, GTK_IS_LABEL (_tmp3_) ? ((GtkLabel*) _tmp3_) : NULL));                } else {                    if (GTK_IS_IMAGE (widget)) {                        GtkWidget* _tmp4_;                        serializer_visit_image (self, (_tmp4_ = widget, GTK_IS_IMAGE (_tmp4_) ? ((GtkImage*) _tmp4_) : NULL));                    } else {                        if (GTK_IS_CONTAINER (widget)) {                            GtkWidget* _tmp5_;                            serializer_visit_container (self, (_tmp5_ = widget, GTK_IS_CONTAINER (_tmp5_) ? ((GtkContainer*) _tmp5_) : NULL));                        }                    }                }            }        }    }}

static voidmenu_choice_activate (GtkWidget *item,		      gpointer   data){  gpointer udata = gtk_object_get_user_data (GTK_OBJECT (item));    if (GTK_IS_MENU (current_popup_menu))    {      gtk_object_set_data (GTK_OBJECT (current_popup_menu), "BstChoice", udata);            if (modal_loop_quit_on_menu_item_activate)	modal_loop_running = FALSE;    }  else	/* current_popup_menu is not set e.g. for option menus */    {      while (GTK_IS_MENU (item->parent))	{	  GtkWidget *tmp;          	  item = item->parent;	  tmp = gtk_menu_get_attach_widget (GTK_MENU (item));	  if (GTK_IS_MENU_ITEM (tmp))	    item = tmp;	}      g_assert (GTK_IS_MENU (item));            gtk_object_set_data (GTK_OBJECT (item), "BstChoice", udata);    }}

ui::Widgetlookup_widget(ui::Widget       widget,			   const gchar     *widget_name ){    ui::Widget parent{ui::null};	for (;; )	{		if ( GTK_IS_MENU( widget ) ) {			parent = ui::Widget::from(gtk_menu_get_attach_widget( GTK_MENU( widget ) ));		}		else{			parent = ui::Widget::from(gtk_widget_get_parent(widget));		}		if ( !parent ) {			parent = ui::Widget::from(g_object_get_data( G_OBJECT( widget ), "GladeParentKey" ));		}		if ( parent == NULL ) {			break;		}		widget = parent;	}	auto found_widget = ui::Widget::from(g_object_get_data( G_OBJECT( widget ), widget_name ));	if ( !found_widget ) {		g_warning( "Widget not found: %s", widget_name );	}	return found_widget;}

voidbook_view_gtk_populate_menu (BookViewGtk *self,			     GtkWidget *menu){  g_return_if_fail (IS_BOOK_VIEW_GTK (self));  g_return_if_fail (GTK_IS_MENU (menu));  GtkTreeSelection *selection = NULL;  GtkTreeModel *model = NULL;  GtkTreeIter iter;  Ekiga::Contact *contact = NULL;  GtkWidget *item = NULL;  MenuBuilderGtk builder (menu);  self->priv->book->populate_menu (builder);  selection = gtk_tree_view_get_selection (self->priv->tree_view);  if (gtk_tree_selection_get_selected (selection, &model, &iter)) {    gtk_tree_model_get (model, &iter, COLUMN_CONTACT_POINTER, &contact, -1);    if (contact) {      item = gtk_separator_menu_item_new ();      gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);      contact->populate_menu (builder);    }  }}

static voidgtk_tearoff_menu_item_parent_set (GtkWidget *widget,                                  GtkWidget *previous){    GtkTearoffMenuItem *tearoff_menu_item = GTK_TEAROFF_MENU_ITEM (widget);    GtkTearoffMenuItemPrivate *priv = tearoff_menu_item->priv;    GtkMenu *menu;    GtkWidget *parent;    parent = gtk_widget_get_parent (widget);    menu = GTK_IS_MENU (parent) ? GTK_MENU (parent) : NULL;    if (previous)        g_signal_handlers_disconnect_by_func (previous,                                              tearoff_state_changed,                                              tearoff_menu_item);    if (menu)    {        priv->torn_off = gtk_menu_get_tearoff_state (menu);        g_signal_connect (menu, "notify::tearoff-state",                          G_CALLBACK (tearoff_state_changed),                          tearoff_menu_item);    }}

static voidgtk_tearoff_menu_item_get_preferred_height (GtkWidget      *widget,        gint           *minimum,        gint           *natural){    GtkStyleContext *context;    GtkBorder padding;    GtkStateFlags state;    GtkWidget *parent;    guint border_width;    context = gtk_widget_get_style_context (widget);    state = gtk_widget_get_state_flags (widget);    gtk_style_context_get_padding (context, state, &padding);    border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));    *minimum = *natural = (border_width * 2) + padding.top + padding.bottom;    parent = gtk_widget_get_parent (widget);    if (GTK_IS_MENU (parent) && gtk_menu_get_tearoff_state (GTK_MENU (parent)))    {        *minimum += ARROW_SIZE;        *natural += ARROW_SIZE;    }    else    {        *minimum += padding.top + 4;        *natural += padding.top + 4;    }}

GtkWidget*lookup_widget                          (GtkWidget       *widget,                                        const gchar     *widget_name){  GtkWidget *parent = 0, *found_widget = 0;  if (widget) {     for (;;)      {	if (GTK_IS_MENU (widget))	  parent = gtk_menu_get_attach_widget (GTK_MENU (widget));	else	  parent = widget->parent;	if (parent == NULL)	  break;	widget = parent;      }    found_widget = (GtkWidget*) gtk_object_get_data (GTK_OBJECT (widget),						     widget_name);    if (!found_widget)      g_warning ("Widget not found: %s", widget_name);  } else {     g_warning ("Widget is NULL: %s", widget_name);  }   return found_widget;}

static voidmaybe_check_submenu_state (GtkMenuItem    *menu_item,                           ThemeMatchData *match_data){  /* Distinguish between active and passive focus, depending on whether the   * focus is in submenu.   *   * Active focus:   *   function = BOX   *   state    = PRELIGHT   *   * Passive focus:   *   function = BOX   *   state    = SELECTED   */  if (menu_item->submenu)    {      GtkWidget *sub_item;      sub_item = GTK_MENU_SHELL (menu_item->submenu)->active_menu_item;      if (sub_item && gtk_widget_get_state (sub_item) != GTK_STATE_NORMAL)	match_data->state = GTK_STATE_SELECTED;    }  /* This is a hack to cover the cases where a menu item is being    * used outside the usual a GtkMenu. More specificaly, this covers   * menu items inside the hildon-desktop custom menu widget. */  if (!GTK_IS_MENU (GTK_WIDGET (menu_item)->parent) &&      !gtk_widget_is_focus (GTK_WIDGET (menu_item)) &&      gtk_widget_get_state (GTK_WIDGET (menu_item)) != GTK_STATE_NORMAL)    match_data->state = GTK_STATE_SELECTED;}

static voidppg_menu_tool_item_set_menu (PpgMenuToolItem *item,                             GtkMenu         *menu){	PpgMenuToolItemPrivate *priv;	g_return_if_fail(PPG_IS_MENU_TOOL_ITEM(item));	g_return_if_fail(!menu || GTK_IS_MENU(menu));	priv = item->priv;	if (priv->menu) {		g_signal_handler_disconnect(priv->menu, priv->menu_deactivate);		priv->menu = NULL;		priv->menu_deactivate = 0;	}	if (menu) {		priv->menu = GTK_WIDGET(menu);		priv->menu_deactivate =			g_signal_connect(menu, "deactivate",			                 G_CALLBACK(ppg_menu_tool_item_menu_deactivate),			                 item);	}}

static voidadwaita_draw_box (GtkStyle * style,                  GdkWindow * window,                  GtkStateType state_type,                  GtkShadowType shadow_type,                  GdkRectangle * area,                  GtkWidget * widget,                  const gchar * detail,                  gint x,                  gint y,                  gint width,                  gint height){  if (GTK_IS_MENU (widget) &&      g_strcmp0 (detail, "menu") == 0 &&      wm_is_fallback ())    {      cairo_t *cr = drawable_to_cairo (window, area);      cairo_set_source_rgb (cr, 0.34, 0.34, 0.33);      cairo_rectangle (cr, x, y, width, height);      cairo_stroke (cr);      cairo_destroy (cr);    }  else    {      GTK_STYLE_CLASS (adwaita_style_parent_class)->draw_box (style, window, state_type, shadow_type,                                                              area, widget, detail,                                                              x, y, width, height);    }}

GtkWidget*lookup_widget (GtkWidget   *widget,               const gchar *widget_name){  GtkWidget *parent, *found_widget;  GtkBuilder *builder;  g_return_val_if_fail(widget != NULL, NULL);  for (;;)    {      if (GTK_IS_MENU (widget))        parent = gtk_menu_get_attach_widget (GTK_MENU (widget));      else        parent = widget->parent;      if (parent == NULL)        break;      widget = parent;    }  builder = g_object_get_data (G_OBJECT (widget), "_sheet_dialogs_builder");  found_widget = GTK_WIDGET (gtk_builder_get_object (builder, widget_name));  /* not everything is under control of the builder,   * e.g. "wrapbox_left" */  if (!found_widget)    found_widget = (GtkWidget*) g_object_get_data (G_OBJECT (widget), widget_name);  if (!found_widget)    g_warning (_("Widget not found: %s"), widget_name);  return found_widget;}

GtkWidget*search_box_new (AnjutaDocman *docman){	SearchBox* search_box;	AnjutaUI *ui;	search_box = SEARCH_BOX (g_object_new (SEARCH_TYPE_BOX, "homogeneous",											FALSE, NULL));	g_signal_connect (G_OBJECT (docman), "document-changed",					  G_CALLBACK (on_document_changed), search_box);	search_box->priv->status = anjuta_shell_get_status (docman->shell, NULL);		ui = anjuta_shell_get_ui (docman->shell, NULL);	search_box->priv->popup_menu = gtk_ui_manager_get_widget (GTK_UI_MANAGER (ui),											"/SearchboxPopup");	g_assert (search_box->priv->popup_menu != NULL && GTK_IS_MENU (search_box->priv->popup_menu));	search_box->priv->case_action = 		gtk_ui_manager_get_action (GTK_UI_MANAGER (ui),		                           "/SearchboxPopup/CaseCheck");	search_box->priv->highlight_action =		gtk_ui_manager_get_action (GTK_UI_MANAGER (ui),		                           "/SearchboxPopup/HighlightAll");	search_box->priv->regex_action = 		gtk_ui_manager_get_action (GTK_UI_MANAGER (ui),		                           "/SearchboxPopup/RegexSearch");	g_signal_connect (search_box->priv->popup_menu, "deactivate",					  G_CALLBACK (gtk_widget_hide), NULL);	return GTK_WIDGET (search_box);}

voidglade_gtk_menu_item_action_activate (GladeWidgetAdaptor * adaptor,                                     GObject * object,                                     const gchar * action_path){  GObject *obj = NULL, *shell = NULL;  GladeWidget *w = glade_widget_get_from_gobject (object);  while ((w = glade_widget_get_parent (w)))    {      obj = glade_widget_get_object (w);      if (GTK_IS_MENU_SHELL (obj))        shell = obj;    }  if (strcmp (action_path, "launch_editor") == 0)    {      if (shell)        object = shell;      if (GTK_IS_MENU_BAR (object))        glade_gtk_menu_shell_launch_editor (object, _("Edit Menu Bar"));      else if (GTK_IS_MENU (object))        glade_gtk_menu_shell_launch_editor (object, _("Edit Menu"));    }  else    GWA_GET_CLASS (GTK_TYPE_CONTAINER)->action_activate (adaptor,                                                         object, action_path);  if (shell)    gtk_menu_shell_deactivate (GTK_MENU_SHELL (shell));}

/** * eel_pop_up_context_menu: * * Pop up a context menu under the mouse. * The menu is sunk after use, so it will be destroyed unless the * caller first ref'ed it. * * This function is more of a helper function than a gtk extension, * so perhaps it belongs in a different file. * * @menu: The menu to pop up under the mouse. * @offset_x: Ignored. * @offset_y: Ignored. * @event: The event that invoked this popup menu, or #NULL if there * is no event available.  This is used to get the timestamp for the menu's popup. * In case no event is provided, gtk_get_current_event_time() will be used automatically. **/voideel_pop_up_context_menu (GtkMenu *menu,                         GdkEventButton *event){    int button;    g_return_if_fail (GTK_IS_MENU (menu));    /* The event button needs to be 0 if we're popping up this menu from     * a button release, else a 2nd click outside the menu with any button     * other than the one that invoked the menu will be ignored (instead     * of dismissing the menu). This is a subtle fragility of the GTK menu code.     */    if (event) {        button = event->type == GDK_BUTTON_RELEASE                 ? 0                 : event->button;    } else {        button = 0;    }    gtk_menu_popup (menu,					/* menu */                    NULL,					/* parent_menu_shell */                    NULL,					/* parent_menu_item */                    NULL,					/* popup_position_func */                    NULL,					/* popup_position_data */                    button,					/* button */                    event ? event->time : gtk_get_current_event_time ()); /* activate_time */    g_object_ref_sink (menu);    g_object_unref (menu);}

static voidclearlooks_style_draw_check (DRAW_ARGS){	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);	WidgetParameters params;	CheckboxParameters checkbox;	cairo_t *cr;	CHECK_ARGS	SANITIZE_SIZE	cr = ge_gdk_drawable_to_cairo (window, area);	clearlooks_set_widget_parameters (widget, style, state_type, &params);	params.corners = CR_CORNER_ALL;	checkbox.shadow_type = shadow_type;	checkbox.in_cell = DETAIL("cellcheck");	checkbox.in_menu = (widget && widget->parent && GTK_IS_MENU(widget->parent));	STYLE_FUNCTION(draw_checkbox) (cr, &clearlooks_style->colors, &params, &checkbox,	                          x, y, width, height);	cairo_destroy (cr);}

/** Returns a widget from a name in a component, usually created by Glade. * Call it with the toplevel widget in the component (i.e. a window/dialog), * or alternatively any widget in the component, and the name of the widget * you want returned. * @param widget Widget with the @a widget_name property set. * @param widget_name Name to lookup. * @return The widget found. * @see ui_hookup_widget(). * */GtkWidget *ui_lookup_widget(GtkWidget *widget, const gchar *widget_name){	GtkWidget *parent, *found_widget;	g_return_val_if_fail(widget != NULL, NULL);	g_return_val_if_fail(widget_name != NULL, NULL);	for (;;)	{		if (GTK_IS_MENU(widget))			parent = gtk_menu_get_attach_widget(GTK_MENU(widget));		else			parent = gtk_widget_get_parent(widget);		if (parent == NULL)			parent = (GtkWidget*) g_object_get_data(G_OBJECT(widget), "GladeParentKey");		if (parent == NULL)			break;		widget = parent;	}	found_widget = (GtkWidget*) g_object_get_data(G_OBJECT(widget), widget_name);	if (G_UNLIKELY(found_widget == NULL))		g_warning("Widget not found: %s", widget_name);	return found_widget;}

static gintmenu_item_remove_gtk (GtkContainer *container,                      GtkWidget    *widget){  GtkWidget *parent_widget;  AtkObject *atk_parent;  AtkObject *atk_child;  GtkContainerAccessible *container_accessible;  gint index;  gint list_length;  g_return_val_if_fail (GTK_IS_MENU (container), 1);  parent_widget = gtk_menu_get_attach_widget (GTK_MENU (container));  if (GTK_IS_MENU_ITEM (parent_widget))    {      atk_parent = gtk_widget_get_accessible (parent_widget);      atk_child = gtk_widget_get_accessible (widget);      g_object_notify (G_OBJECT (atk_child), "accessible-parent");      container_accessible = GTK_CONTAINER_ACCESSIBLE (atk_parent);      index = g_list_index (container_accessible->children, widget);      list_length = g_list_length (container_accessible->children);      g_list_free (container_accessible->children);      container_accessible->children = gtk_container_get_children (container);      if (index >= 0 && index <= list_length)        g_signal_emit_by_name (atk_parent, "children-changed::remove",                               index, atk_child, NULL);    }  return 1;}

static voidclearlooks_style_draw_option (DRAW_ARGS){	const ClearlooksColors *colors;	WidgetParameters params;	CheckboxParameters checkbox;	cairo_t *cr;	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);	(void) detail;	CHECK_ARGS	SANITIZE_SIZE	cr = ge_gdk_drawable_to_cairo (window, area);	colors = &clearlooks_style->colors;	checkbox.shadow_type = shadow_type;	checkbox.in_menu = (widget && GTK_IS_MENU(widget->parent));	clearlooks_set_widget_parameters (widget, style, state_type, &params);	STYLE_FUNCTION(draw_radiobutton) (cr, colors, &params, &checkbox, x, y, width, height);	cairo_destroy (cr);}

GtkWidget*lookup_widget                          (GtkWidget       *widget,                                        const gchar     *widget_name){  GtkWidget *parent, *found_widget;  for (;;)    {      if (GTK_IS_MENU (widget))        parent = gtk_menu_get_attach_widget (GTK_MENU (widget));      else        parent = widget->parent;      if (!parent)        parent = (GtkWidget*) g_object_get_data (G_OBJECT (widget), "GladeParentKey");      if (parent == NULL)        break;      widget = parent;    }  found_widget = (GtkWidget*) g_object_get_data (G_OBJECT (widget),                                                 widget_name);  if (!found_widget)    g_warning ("Widget not found: %s", widget_name);  return found_widget;}

static gbooleanqtcMenuShellLeave(GtkWidget *widget, GdkEventCrossing *event, void *data){    QTC_UNUSED(data);    QTC_UNUSED(event);    if (GTK_IS_MENU_SHELL(widget) && GTK_IS_CONTAINER(widget)) {        GList *children = gtk_container_get_children(GTK_CONTAINER(widget));        for (GList *child = children;child;child = g_list_next(child)) {            if ((child->data) && GTK_IS_MENU_ITEM(child->data) &&                (gtk_widget_get_state(GTK_WIDGET(child->data)) !=                 GTK_STATE_INSENSITIVE)) {                GtkWidget *submenu =                    gtk_menu_item_get_submenu(GTK_MENU_ITEM(child->data));                GtkWidget *topLevel =                    submenu ? gtk_widget_get_toplevel(submenu) : NULL;                if (submenu &&                    ((!GTK_IS_MENU(submenu)) ||                     (!(gtk_widget_get_realized(submenu) &&                        gtk_widget_get_visible(submenu) &&                        gtk_widget_get_realized(topLevel) &&                        gtk_widget_get_visible(topLevel))))) {                    gtk_widget_set_state(GTK_WIDGET(child->data),                                         GTK_STATE_NORMAL);                }            }        }        if (children) {            g_list_free(children);        }    }    return false;}

static voidon_license_textview_populate_popup (GtkTextView            *text_view,                                    GtkWidget              *popup,                                    GladeProjectProperties *properties){  if (!GTK_IS_MENU (popup))    return;  gpp_append_new_item (properties, popup, _("Clear text"),                       G_CALLBACK (on_clear_text_activate));    gpp_append_new_item (properties, popup, NULL, NULL);    gpp_append_new_item (properties, popup, _("Insert GPL v2"),                       G_CALLBACK (on_gplv2_activate));  gpp_append_new_item (properties, popup, _("Insert GPL v3"),                       G_CALLBACK (on_gplv3_activate));  gpp_append_new_item (properties, popup, _("Insert LGPL v2.1"),                       G_CALLBACK (on_lgplv2_activate));  gpp_append_new_item (properties, popup, _("Insert LGPL v3"),                       G_CALLBACK (on_lgplv3_activate));  gpp_append_new_item (properties, popup, _("Insert BSD 2-clause"),                       G_CALLBACK (on_bsd2c_activate));  gpp_append_new_item (properties, popup, _("Insert BSD 3-clause"),                       G_CALLBACK (on_bsd3c_activate));}

static gintmy_popup_handler (GtkWidget *widget, GdkEvent *event){    GtkMenu *menu;    GdkEventButton *event_button;    g_return_val_if_fail (widget != NULL, FALSE);    g_return_val_if_fail (GTK_IS_MENU (widget), FALSE);    g_return_val_if_fail (event != NULL, FALSE);    /* The "widget" is the menu that was supplied when    *    * g_signal_connect_swapped() was called.    *       */    menu = GTK_MENU (widget);    if (event->type == GDK_BUTTON_PRESS)    {        event_button = (GdkEventButton *) event;        if (event_button->button == 3)        {            gtk_menu_popup (menu, NULL, NULL, NULL, NULL,                            event_button->button, event_button->time);            return TRUE;        }    }    return FALSE;}

gbooleanglade_gtk_menu_tool_button_add_verify (GladeWidgetAdaptor *adaptor,				       GtkWidget          *container,				       GtkWidget          *child,				       gboolean            user_feedback){  if (!GTK_IS_MENU (child))    {      if (user_feedback)	{	  GladeWidgetAdaptor *menu_adaptor = 	    glade_widget_adaptor_get_by_type (GTK_TYPE_MENU);	  glade_util_ui_message (glade_app_get_window (),				 GLADE_UI_INFO, NULL,				 ONLY_THIS_GOES_IN_THAT_MSG,				 glade_widget_adaptor_get_title (menu_adaptor),				 glade_widget_adaptor_get_title (adaptor));	}      return FALSE;    }  return TRUE;}

static voidkill_popup_menu (GtkWidget *widget, GtkMenu *menu){    g_return_if_fail (menu != NULL);    g_return_if_fail (GTK_IS_MENU (menu));    g_object_unref (G_OBJECT (menu));}

static voidgail_map_submenu_cb (GtkWidget *widget){  if (GTK_IS_MENU (widget))    {      if (GTK_MENU (widget)->parent_menu_item)        gail_finish_select (GTK_MENU (widget)->parent_menu_item);    }}

voidgb_menu_item_add_child (GtkWidget * widget, GtkWidget * child, GbWidgetSetArgData *data){  if (GTK_IS_MENU (child))    {      MSG ("Trying to add a menu to a menu item");      gtk_menu_item_set_submenu (GTK_MENU_ITEM (widget), child);    }}

static GtkWidget *action_ancestor (GtkWidget *widget){  if (GTK_IS_MENU (widget))    return gtk_menu_get_attach_widget (GTK_MENU (widget));  else if (GTK_IS_POPOVER (widget))    return gtk_popover_get_relative_to (GTK_POPOVER (widget));  else    return gtk_widget_get_parent (widget);}

static voidgb_option_menu_add_child (GtkWidget *widget,			  GtkWidget *child,			  GbWidgetSetArgData *data){  if (GTK_IS_MENU (child))    gtk_option_menu_set_menu (GTK_OPTION_MENU (widget), child);  else    g_warning (_("Cannot add a %s to a GtkOptionMenu."),	       g_type_name (G_OBJECT_TYPE (child)));}