int
menu_select_cb(GtkMenuItem * menuitem, GtkWidget * menu)
{
const char *label = menuitem_get_label(menuitem);
// printf( "menuitem = %s(%p), menu = %s(%p)\n", G_OBJECT_TYPE_NAME(menuitem), menuitem, G_OBJECT_TYPE_NAME(menu), menu );
if(label[0] == '<')
{
GtkWidget *selection = menu_get_first_menuitem(GTK_MENU(menu));
gtk_widget_hide(selection);
}
else
{
char *str = g_strdup(label);
GtkWidget *parent;
for (;;)
{
GtkMenuItem *parentitem;
const char *label2;
char *temp;
parent = gtk_widget_get_parent(GTK_WIDGET(menuitem));
// printf( "parent = %s(%p)\n", G_OBJECT_TYPE_NAME(parent), parent);
if(menu == parent)
break;
parentitem = GTK_MENU_ITEM(gtk_menu_get_attach_widget(GTK_MENU(parent)));
// printf( "parentitem = %s(%p)\n", G_OBJECT_TYPE_NAME(parentitem), parentitem);
label2 = menuitem_get_label(parentitem);
if(strcmp(label2, MORE_STRING) != 0)
{
temp = g_strconcat(label2, "/", str, NULL);
g_free(str);
str = temp;
}
menuitem = parentitem;
}
{
GtkLabel *label;
GtkWidget *selection = menu_get_first_menuitem(GTK_MENU(menu));
GtkOptionMenu *optionmenu = GTK_OPTION_MENU(gtk_menu_get_attach_widget(GTK_MENU(menu)));
label = GTK_LABEL(gtk_bin_get_child(GTK_BIN(selection)));
gtk_label_set_text(label, str);
gtk_widget_show(GTK_WIDGET(selection));
gtk_option_menu_set_history(optionmenu, 0);
g_free(str);
}
}
return 0;
}
ui::Widget
lookup_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;
}
static void
menu_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);
}
}
/** 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;
}
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;
}
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;
}
void panel_menu_bar_popup_menu(PanelMenuBar* menubar, guint32 activate_time)
{
GtkMenu* menu;
GtkMenuShell* menu_shell;
g_return_if_fail(PANEL_IS_MENU_BAR(menubar));
menu = GTK_MENU(menubar->priv->applications_menu);
/*
* We need to call _gtk_menu_shell_activate() here as is done in
* window_key_press_handler in gtkmenubar.c which pops up menu
* when F10 is pressed.
*
* As that function is private its code is replicated here.
*/
menu_shell = GTK_MENU_SHELL(menubar);
#if !GTK_CHECK_VERSION (3, 0, 0)
if (!menu_shell->active)
{
gtk_grab_add(GTK_WIDGET(menu_shell));
menu_shell->have_grab = TRUE;
menu_shell->active = TRUE;
}
#endif
gtk_menu_shell_select_item(menu_shell, gtk_menu_get_attach_widget(menu));
}
static gint
menu_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 void
do_popup_menu (GtkWidget* widget, GdkEventButton *event, SearchBox* search_box)
{
int button, event_time;
if (event)
{
button = event->button;
event_time = event->time;
}
else
{
button = 0;
event_time = gtk_get_current_event_time ();
}
if (!gtk_menu_get_attach_widget(GTK_MENU (search_box->priv->popup_menu)))
gtk_menu_attach_to_widget (GTK_MENU (search_box->priv->popup_menu), widget, NULL);
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(search_box->priv->case_action), search_box->priv->case_sensitive);
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(search_box->priv->regex_action), search_box->priv->regex_mode);
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(search_box->priv->highlight_action), search_box->priv->highlight_all);
gtk_menu_popup (GTK_MENU (search_box->priv->popup_menu), NULL, NULL, NULL, NULL,
button, event_time);
}
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;
}
/*****************************************************************************
* Useful function to retrieve p_intf
****************************************************************************/
void * E_(__GtkGetIntf)( GtkWidget * widget )
{
void *p_data;
if( GTK_IS_MENU_ITEM( widget ) )
{
/* Look for a GTK_MENU */
while( widget->parent && !GTK_IS_MENU( widget ) )
{
widget = widget->parent;
}
/* Maybe this one has the data */
p_data = gtk_object_get_data( GTK_OBJECT( widget ), "p_intf" );
if( p_data )
{
return p_data;
}
/* Otherwise, the parent widget has it */
widget = gtk_menu_get_attach_widget( GTK_MENU( widget ) );
}
/* We look for the top widget */
widget = gtk_widget_get_toplevel( GTK_WIDGET( widget ) );
p_data = gtk_object_get_data( GTK_OBJECT( widget ), "p_intf" );
return p_data;
}
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;
}
void on_empty_trash(GtkAction* act, gpointer user_data)
{
/* FIXME: This is very dirty, but it's inevitable. :-( */
GSList* proxies = gtk_action_get_proxies(act);
GtkWidget* menu_item = proxies->data ? GTK_WIDGET(proxies->data) : NULL;
GtkWidget* menu = gtk_widget_get_parent(menu_item);
GtkWidget* view = gtk_menu_get_attach_widget(GTK_MENU(menu));
fm_empty_trash(view ? GTK_WINDOW(gtk_widget_get_toplevel(view)) : NULL);
}
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 GnomenuItem* gnomenu_menu_real_get_owner (GnomenuShell* base) {
GnomenuItem* result;
GnomenuMenu* self;
GtkWidget* _tmp0_;
self = (GnomenuMenu*) base;
if (self->priv->_is_topmost) {
result = NULL;
return result;
}
result = (_tmp0_ = gtk_menu_get_attach_widget ((GtkMenu*) self), GNOMENU_IS_ITEM (_tmp0_) ? ((GnomenuItem*) _tmp0_) : NULL);
return result;
}
static void
gail_map_submenu_cb (GtkWidget *widget)
{
if (GTK_IS_MENU (widget))
{
GtkWidget *parent_menu_item;
parent_menu_item = gtk_menu_get_attach_widget (GTK_MENU (widget));
if (parent_menu_item)
gail_finish_select (parent_menu_item);
}
}
/**
* fm_widget_menu_fix_tooltips
* @menu: a #GtkMenu instance
*
* Fix on GTK bug: it does not assign tooltips of menu items from
* appropriate #GtkAction objects. This API assigns them instead.
*
* Since: 1.2.0
*/
void fm_widget_menu_fix_tooltips(GtkMenu *menu)
{
GtkWidget *parent;
GtkSettings *settings;
gboolean tooltips_enabled;
g_return_if_fail(GTK_IS_MENU(menu));
parent = gtk_menu_get_attach_widget(menu);
settings = parent ? gtk_settings_get_for_screen(gtk_widget_get_screen(parent))
: gtk_settings_get_default();
g_object_get(G_OBJECT(settings), "gtk-enable-tooltips", &tooltips_enabled, NULL);
if(tooltips_enabled)
assign_tooltips_from_actions(GTK_WIDGET(menu));
}
/* Work around a gtk bug (?): without that, the selected menu item's
* colored rectangle is drawn at 0,0 in the window...
*/
static void refresh_menu (GtkWidget *menushell, gpointer data)
{
GtkMenu *menu = (GtkMenu *)data;
GtkWidget *widget = gtk_menu_get_attach_widget(menu);
#if !GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_hide_all(widget);
gtk_widget_unrealize(widget);
gtk_widget_show_all(widget);
#else
gtk_widget_hide(widget);
gtk_widget_unrealize(widget);
gtk_widget_show(widget);
#endif
gtk_widget_queue_draw(widget);
}
/*
* Writes the source code needed to create this widget.
* You have to output everything necessary to create the widget here, though
* there are some convenience functions to help.
*/
static void
gb_menu_write_source (GtkWidget * widget, GbWidgetWriteSourceData * data)
{
gchar *accel_group_decl;
#ifdef USE_GNOME
/* For Gnome projects the menus are created using GnomeUIInfo structs, so
we just create the start of the struct here, and output code to fill
the menu from the GnomeUIInfo structs. */
if (data->project->gnome_support)
{
glade_gnome_start_menu_source (GTK_MENU_SHELL (widget), data);
/* We only need to create the toplevel menu. */
if (gtk_menu_get_attach_widget (GTK_MENU (widget)) == NULL)
{
if (data->create_widget)
{
source_add (data, " %s = gtk_menu_new ();\n", data->wname);
}
gb_widget_write_standard_source (widget, data);
source_add (data,
" gnome_app_fill_menu (GTK_MENU_SHELL (%s), %s_uiinfo,\n"
" NULL, FALSE, 0);\n",
data->wname, data->real_wname);
}
return;
}
#endif
if (data->create_widget)
{
source_add (data, " %s = gtk_menu_new ();\n", data->wname);
}
gb_widget_write_standard_source (widget, data);
accel_group_decl = g_strdup_printf (" GtkAccelGroup *%s_accels;\n",
data->real_wname);
source_ensure_decl (data, accel_group_decl);
source_add (data,
" %s_accels = gtk_menu_ensure_uline_accel_group (GTK_MENU (%s));\n",
data->wname, data->wname);
g_free (accel_group_decl);
}
/* Helper function to get the toplevel window that contains the action's proxy,
in case it wasn't passed as a user data parameter to the action callback. */
static GtkWindow *
get_toplevel_for_action(GtkAction *action)
{
GSList *list;
GtkWidget *parent = NULL;
for(list = gtk_action_get_proxies(action) ; list; list = g_slist_next(list)) {
GtkWidget *toplevel = gtk_widget_get_toplevel((GtkWidget *)list->data);
if(GTK_IS_MENU(toplevel))
toplevel = gtk_widget_get_toplevel(gtk_menu_get_attach_widget(GTK_MENU(toplevel)));
if(toplevel && gtk_widget_is_toplevel(toplevel)) {
parent = toplevel;
break;
}
}
return GTK_WINDOW(parent);
}
GtkMenu* getPopupMenu()
{
GOwnPtr<GList> toplevels(gtk_window_list_toplevels());
for (GList* iter = toplevels.get(); iter; iter = g_list_next(iter)) {
if (!GTK_IS_WINDOW(iter->data))
continue;
GtkWidget* child = gtk_bin_get_child(GTK_BIN(iter->data));
if (!GTK_IS_MENU(child))
continue;
if (gtk_menu_get_attach_widget(GTK_MENU(child)) == GTK_WIDGET(m_webView))
return GTK_MENU(child);
}
g_assert_not_reached();
return 0;
}
static WnckActionMenu*
get_action_menu (GtkWidget *widget)
{
while (widget) {
if (GTK_IS_MENU_ITEM (widget))
widget = widget->parent;
if (WNCK_IS_ACTION_MENU (widget))
return WNCK_ACTION_MENU (widget);
widget = gtk_menu_get_attach_widget (GTK_MENU (widget));
if (widget == NULL)
break;
}
return NULL;
}
static gboolean
is_attached_menu_window (GtkWidget *widget)
{
GtkWidget *child;
child = gtk_bin_get_child (GTK_BIN (widget));
if (GTK_IS_MENU (child))
{
GtkWidget *attach;
attach = gtk_menu_get_attach_widget (GTK_MENU (child));
/* Allow for menu belonging to the Panel Menu, which is a GtkButton */
if (GTK_IS_MENU_ITEM (attach) || GTK_IS_BUTTON (attach))
return TRUE;
}
return FALSE;
}
static void
matewnck_selector_drag_begin (GtkWidget *widget,
GdkDragContext *context,
MatewnckWindow *window)
{
while (widget)
{
if (MATEWNCK_IS_SELECTOR (widget))
break;
if (GTK_IS_MENU (widget))
widget = gtk_menu_get_attach_widget (GTK_MENU (widget));
else
widget = gtk_widget_get_parent (widget);
}
if (widget)
_matewnck_window_set_as_drag_icon (window, context, widget);
}
static void
gail_menu_item_real_initialize (AtkObject *obj,
gpointer data)
{
GtkWidget *widget;
GtkWidget *parent;
ATK_OBJECT_CLASS (gail_menu_item_parent_class)->initialize (obj, data);
g_signal_connect (data,
"select",
G_CALLBACK (menu_item_select),
NULL);
g_signal_connect (data,
"deselect",
G_CALLBACK (menu_item_deselect),
NULL);
widget = GTK_WIDGET (data);
parent = gtk_widget_get_parent (widget);
if (GTK_IS_MENU (parent))
{
GtkWidget *parent_widget;
parent_widget = gtk_menu_get_attach_widget (GTK_MENU (parent));
if (!GTK_IS_MENU_ITEM (parent_widget))
parent_widget = gtk_widget_get_parent (widget);
if (parent_widget)
{
atk_object_set_parent (obj, gtk_widget_get_accessible (parent_widget));
}
}
g_object_set_data (G_OBJECT (obj), "atk-component-layer",
GINT_TO_POINTER (ATK_LAYER_POPUP));
if (GTK_IS_TEAROFF_MENU_ITEM (data))
obj->role = ATK_ROLE_TEAR_OFF_MENU_ITEM;
else if (GTK_IS_SEPARATOR_MENU_ITEM (data))
obj->role = ATK_ROLE_SEPARATOR;
else
obj->role = ATK_ROLE_MENU_ITEM;
}
/* Blocks the ::show-menu signal if the menu's parent toggle button was inactive in the previous run.
* This is a hack to workaround https://bugzilla.gnome.org/show_bug.cgi?id=769287
* and should NOT be used for any other version than 3.15.9 to 3.21.4, although the code tries and
* not block a legitimate signal in case the GTK version in use has been patched */
static void show_menu_gtk316_fix(GtkMenuToolButton *button, gpointer data)
{
/* we assume only a single menu can popup at once, so reentrency isn't an issue.
* if it was, we could use custom data on the button, but it shouldn't be required */
static gboolean block_next = FALSE;
if (block_next)
{
g_signal_stop_emission_by_name(button, "show-menu");
block_next = FALSE;
}
else
{
GtkWidget *menu = gtk_menu_tool_button_get_menu(button);
GtkWidget *parent = gtk_menu_get_attach_widget(GTK_MENU(menu));
if (parent && GTK_IS_TOGGLE_BUTTON(parent) && ! gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(parent)))
block_next = TRUE;
}
}
// This returns the toplevel window/dialog/menu that contains the given
// widget. It even walks up menus, which gtk_widget_get_toplevel() does not.
GtkWidget*
getToplevel(GtkWidget *widget)
{
GtkWidget *parent;
if (widget == NULL)
return 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;
}
return widget;
}
/**
* hildon_program_set_common_menu:
* @self: The #HildonProgram in which the common menu should be used
* @menu: A GtkMenu to use as common menu for the program
*
* Sets a GtkMenu that will appear in all the @HildonWindow registered
* to the #HildonProgram. Only one common GtkMenu can be set, further
* call will detach the previous common GtkMenu. A @HildonWindow
* can use it's own GtkMenu with @hildon_window_set_menu
**/
void
hildon_program_set_common_menu (HildonProgram *self,
GtkMenu *menu)
{
HildonProgramPrivate *priv;
g_return_if_fail (HILDON_IS_PROGRAM (self));
priv = HILDON_PROGRAM_GET_PRIVATE (self);
g_assert (priv);
if (priv->common_menu)
{
if (GTK_WIDGET_VISIBLE (priv->common_menu))
{
gtk_menu_popdown (GTK_MENU (priv->common_menu));
gtk_menu_shell_deactivate (GTK_MENU_SHELL (priv->common_menu));
}
if (gtk_menu_get_attach_widget (GTK_MENU (priv->common_menu)))
{
gtk_menu_detach (GTK_MENU (priv->common_menu));
}
else
{
g_object_unref (priv->common_menu);
}
}
priv->common_menu = GTK_WIDGET (menu);
if (priv->common_menu)
{
g_object_ref (menu);
gtk_object_sink (GTK_OBJECT (menu));
gtk_widget_show_all (GTK_WIDGET (menu));
}
}
static void
gtk_menu_item_accessible_initialize (AtkObject *obj,
gpointer data)
{
GtkWidget *widget;
GtkWidget *parent;
GtkWidget *menu;
ATK_OBJECT_CLASS (_gtk_menu_item_accessible_parent_class)->initialize (obj, data);
g_signal_connect (data, "select", G_CALLBACK (menu_item_select), NULL);
g_signal_connect (data, "deselect", G_CALLBACK (menu_item_deselect), NULL);
widget = GTK_WIDGET (data);
parent = gtk_widget_get_parent (widget);
if (GTK_IS_MENU (parent))
{
GtkWidget *parent_widget;
parent_widget = gtk_menu_get_attach_widget (GTK_MENU (parent));
if (!GTK_IS_MENU_ITEM (parent_widget))
parent_widget = gtk_widget_get_parent (widget);
if (parent_widget)
atk_object_set_parent (obj, gtk_widget_get_accessible (parent_widget));
}
GTK_WIDGET_ACCESSIBLE (obj)->layer = ATK_LAYER_POPUP;
obj->role = ATK_ROLE_MENU_ITEM;
menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (data));
if (menu)
{
g_signal_connect (menu, "add", G_CALLBACK (menu_item_add_gtk), NULL);
g_signal_connect (menu, "remove", G_CALLBACK (menu_item_remove_gtk), NULL);
}
}
static GtkWidget*
find_popup (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 = gtk_widget_get_parent (widget);
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);
return found_widget;
}
