void menu_info_item_rename_dialog(menu_info_item_t* mii)
{
gtk_menu_popdown(GTK_MENU(mii->menu_info->menu_infos->menu));
char* title = g_strdup_printf("Rename %s %s",
menu_info_type_name(mii->menu_info->type), mii->desc);
char* text = g_strdup_printf("%s to:", title);
GtkDialog* dialog = ui_renamedialog();
gtk_window_set_title(GTK_WINDOW(dialog), title);
gtk_label_set_text(ui_renamedialog_label(), text);
gtk_entry_set_text(ui_renamedialog_entry(), mii->desc);
g_free(text);
g_free(title);
gtk_widget_show_all(GTK_WIDGET(dialog));
if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
{
const char* entry = gtk_entry_get_text(GTK_ENTRY(ui_renamedialog_entry()));
char* name = g_strstrip(g_strdup(entry));
if(!g_str_equal(name, mii->desc))
pulseaudio_rename(mii, name);
g_free(name);
}
gtk_widget_hide(GTK_WIDGET(dialog));
}
static gboolean
panel_popup_menu_left (PanelToplevel *toplevel,
guint button,
guint32 activate_time)
{
PanelWidget *panel_widget;
GtkWidget *menu;
PanelData *panel_data;
GdkEvent *current_event;
panel_widget = panel_toplevel_get_panel_widget (toplevel);
panel_data = g_object_get_data (G_OBJECT (toplevel), "PanelData");
current_event = gtk_get_current_event ();
if (current_event->type == GDK_BUTTON_PRESS)
panel_data->insertion_pos = panel_widget_get_cursorloc (panel_widget);
else
panel_data->insertion_pos = -1;
menu = make_popup_panel_menu (panel_widget);
//gtk_widget_set_usize(GTK_WINDOW (menu),10,10);
if (!menu)
return FALSE;
gtk_menu_set_screen (GTK_MENU (menu),
gtk_window_get_screen (GTK_WINDOW (toplevel)));
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, activate_time);
gtk_menu_popdown (GTK_MENU (menu));
return FALSE;
}
void FrameLoaderClient::transitionToCommittedForNewPage()
{
WebKitWebView* containingWindow = getViewFromFrame(m_frame);
IntSize size = IntSize(GTK_WIDGET(containingWindow)->allocation.width,
GTK_WIDGET(containingWindow)->allocation.height);
bool transparent = webkit_web_view_get_transparent(containingWindow);
Color backgroundColor = transparent ? WebCore::Color::transparent : WebCore::Color::white;
Frame* frame = core(m_frame);
ASSERT(frame);
frame->createView(size, backgroundColor, transparent, IntSize(), false);
// We need to do further manipulation on the FrameView if it was the mainFrame
if (frame != frame->page()->mainFrame())
return;
WebKitWebViewPrivate* priv = WEBKIT_WEB_VIEW_GET_PRIVATE(containingWindow);
frame->view()->setGtkAdjustments(priv->horizontalAdjustment, priv->verticalAdjustment);
if (priv->currentMenu) {
GtkMenu* menu = priv->currentMenu;
priv->currentMenu = NULL;
gtk_menu_popdown(menu);
g_object_unref(menu);
}
}
static gboolean tab_completion_popup_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
TabCompData *td = data;
if (event->keyval == GDK_KEY_Tab ||
event->keyval == GDK_KEY_BackSpace ||
(event->keyval >= 0x20 && event->keyval <= 0xFF) )
{
if (event->keyval >= 0x20 && event->keyval <= 0xFF)
{
gchar buf[2];
gint p = -1;
buf[0] = event->keyval;
buf[1] = '\0';
gtk_editable_insert_text(GTK_EDITABLE(td->entry), buf, 1, &p);
gtk_editable_set_position(GTK_EDITABLE(td->entry), -1);
/* Reduce the number of entries in the menu */
td->choices = 0;
gtk_container_foreach(GTK_CONTAINER(widget), tab_completion_iter_menu_items, (gpointer) td);
if (td->choices > 1) return TRUE; /* multiple choices */
if (td->choices > 0) tab_completion_do(td); /* one choice */
}
/* close the menu */
gtk_menu_popdown(GTK_MENU(widget));
/* doing this does not emit the "selection done" signal, unref it ourselves */
g_object_unref(widget);
return TRUE;
}
return FALSE;
}
void
hn_others_button_close_menu (HNOthersButton *button)
{
g_return_if_fail (button && HN_IS_OTHERS_BUTTON (button));
g_return_if_fail (TASKNAVIGATOR_ITEM (button)->menu != NULL);
gtk_menu_popdown (TASKNAVIGATOR_ITEM (button)->menu);
}
static gboolean tray_icon_release (GtkWidget *widget, GdkEventButton *event, struct _tray_icon *tray)
{
if (widget){};
if (event->button != 3)
return TRUE;
gtk_menu_popdown(GTK_MENU(tray->popup_menu));
return FALSE;
}
/* Handler for all of the menu items on a root change to ensure that
the menus are hidden before we start going and deleting things. */
static void
popdown_all (DbusmenuMenuitem * mi, gpointer user_data)
{
GtkMenu * menu = dbusmenu_gtkclient_menuitem_get_submenu(DBUSMENU_GTKCLIENT(user_data), mi);
if (menu != NULL) {
gtk_menu_popdown(menu);
}
return;
}
void PlatformWebView::dismissAllPopupMenus()
{
// gtk_menu_popdown doesn't modify the GList of attached menus, so it should
// be safe to walk this list while calling it.
GList* attachedMenusList = gtk_menu_get_for_attach_widget(GTK_WIDGET(m_view));
g_list_foreach(attachedMenusList, [] (void* data, void*) {
ASSERT(data);
gtk_menu_popdown(GTK_MENU(data));
}, nullptr);
}
/**
@brief delete bookmark at @a iter
@param iter pointer to tree iter for row to be deleted
@return
*/
static void _e2_bookmark_delete_mark (GtkTreeIter *iter)
{
ViewInfo *view = curr_view;
e2_option_tree_del_direct (bookmarks_set, iter);
_e2_bookmark_recreate_toolbars ();
if (GTK_IS_MENU (app.context_menu))
gtk_menu_popdown (GTK_MENU (app.context_menu));
if (view != curr_view)
e2_pane_activate_other ();
gtk_widget_grab_focus (view->treeview);
}
void menu_shift_button_release(GtkWidget *widget, GdkEventButton *event, GtkWidget *menu,
void (*action)(const MenuItem *menu_item))
{
if (event->state & GDK_SHIFT_MASK)
{
gtk_menu_popdown(GTK_MENU(menu));
action(NULL);
}
else
utils_handle_button_release(widget, event);
}
int
clip_GTK_MENUPOPDOWN(ClipMachine * ClipMachineMemory)
{
C_widget *cmnu = _fetch_cw_arg(ClipMachineMemory);
CHECKCWID(cmnu, GTK_IS_MENU);
gtk_menu_popdown(GTK_MENU(cmnu->widget));
return 0;
err:
return 1;
}
void menu_mber_button_release(GtkTreeSelection *selection, GtkWidget *item,
GdkEventButton *event, GtkWidget *menu)
{
if (event->state & GDK_SHIFT_MASK)
{
gtk_check_menu_item_set_inconsistent(GTK_CHECK_MENU_ITEM(item), TRUE);
menu_mode_update(selection, MR_DEFAULT, FALSE);
gtk_menu_popdown(GTK_MENU(menu));
}
else
utils_handle_button_release(item, event);
}
static void
popup_icon_menu (GtkToggleButton *button, UmPhotoDialog *um)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) && !gtk_widget_get_visible (um->photo_popup)) {
gtk_menu_popup (GTK_MENU (um->photo_popup),
NULL, NULL,
(GtkMenuPositionFunc) popup_menu_below_button, um->popup_button,
0, gtk_get_current_event_time ());
} else {
gtk_menu_popdown (GTK_MENU (um->photo_popup));
}
}
static void
killswitch_state_changed (GObject *gobject,
GParamSpec *pspec,
gpointer user_data)
{
GObject *object;
BluetoothApplet *applet = BLUETOOTH_APPLET (gobject);
BluetoothKillswitchState state = bluetooth_applet_get_killswitch_state (applet);
gboolean sensitive = TRUE;
gboolean bstate = FALSE;
const char *label, *status_label;
if (state == BLUETOOTH_KILLSWITCH_STATE_NO_ADAPTER) {
object = gtk_builder_get_object (xml, "bluetooth-applet-popup");
gtk_menu_popdown (GTK_MENU (object));
update_icon_visibility ();
return;
}
if (state == BLUETOOTH_KILLSWITCH_STATE_SOFT_BLOCKED) {
label = N_("Turn on Bluetooth");
status_label = N_("Bluetooth: Off");
bstate = FALSE;
} else if (state == BLUETOOTH_KILLSWITCH_STATE_UNBLOCKED) {
label = N_("Turn off Bluetooth");
status_label = N_("Bluetooth: On");
bstate = TRUE;
} else if (state == BLUETOOTH_KILLSWITCH_STATE_HARD_BLOCKED) {
sensitive = FALSE;
label = NULL;
status_label = N_("Bluetooth: Disabled");
} else {
g_assert_not_reached ();
}
object = gtk_builder_get_object (xml, "killswitch-label");
gtk_action_set_label (GTK_ACTION (object), _(status_label));
gtk_action_set_visible (GTK_ACTION (object), TRUE);
object = gtk_builder_get_object (xml, "killswitch");
gtk_action_set_visible (GTK_ACTION (object), sensitive);
gtk_action_set_label (GTK_ACTION (object), _(label));
if (sensitive != FALSE) {
gtk_action_set_label (GTK_ACTION (object), _(label));
g_object_set_data (object, "bt-active", GINT_TO_POINTER (bstate));
}
object = gtk_builder_get_object (xml, "bluetooth-applet-ui-manager");
gtk_ui_manager_ensure_update (GTK_UI_MANAGER (object));
update_icon_visibility ();
}
static void
chooser_button_clicked (GtkButton *button, charpick_data *curr_data)
{
if (gtk_widget_get_visible (curr_data->menu))
gtk_menu_popdown (GTK_MENU (curr_data->menu));
else {
gtk_menu_set_screen (GTK_MENU (curr_data->menu),
gtk_widget_get_screen (GTK_WIDGET (curr_data->applet)));
gtk_menu_popup (GTK_MENU (curr_data->menu), NULL, NULL, get_menu_pos, curr_data,
0, gtk_get_current_event_time());
}
}
static void
menu_item_clicked (GtkWidget *item, GdkEventButton *ev, gpointer data)
{
NetkWindow *win = data;
if (ev->button == 1) {
plugin_activate_window (NULL, win);
} else if (ev->button == 3) {
popup_action_menu (item, win);
}
gtk_menu_popdown (GTK_MENU(gtk_widget_get_parent(item)));
}
static gint
hide_popup_menu_cb (G_GNUC_UNUSED GtkWidget *widget,
G_GNUC_UNUSED GdkEventButton *event,
gpointer data)
{
GtkWidget *popup = GTK_WIDGET (data);
if (gtk_widget_get_visible (popup)) {
gtk_menu_popdown (GTK_MENU (popup));
return TRUE;
}
else
return FALSE;
}
static gboolean
on_popup_button_button_pressed (GtkToggleButton *button,
GdkEventButton *event,
UmPhotoDialog *um)
{
if (event->button == 1) {
if (!gtk_widget_get_visible (um->photo_popup)) {
popup_icon_menu (button, um);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
} else {
gtk_menu_popdown (GTK_MENU (um->photo_popup));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
}
return TRUE;
}
return FALSE;
}
gboolean
menu_popup (Menu * menu, int root_x, int root_y, int button,
guint32 timestamp)
{
GdkPoint *pt;
TRACE ("entering menu_popup");
g_return_val_if_fail (menu != NULL, FALSE);
g_return_val_if_fail (GTK_IS_MENU (menu->menu), FALSE);
pt = g_new (GdkPoint, 1);
pt->x = root_x;
pt->y = root_y;
if (!menu_check_and_close ())
{
if (!grab_available (gdk_screen_get_root_window (menu->screen), timestamp))
{
g_free (pt);
TRACE ("Cannot get grab on pointer/keyboard, cancel.");
return FALSE;
}
TRACE ("opening new menu");
menu_open = menu->menu;
eventFilterPush (menu->filter_setup, menu_filter, NULL);
gtk_menu_popup (GTK_MENU (menu->menu), NULL, NULL,
popup_position_func, pt, 0, timestamp);
if (!GTK_MENU_SHELL (GTK_MENU (menu->menu))->have_xgrab)
{
gdk_beep ();
g_message (_("%s: GtkMenu failed to grab the pointer\n"), g_get_prgname ());
gtk_menu_popdown (GTK_MENU (menu->menu));
menu_open = NULL;
eventFilterPop (menu->filter_setup);
return FALSE;
}
}
return TRUE;
}
/**
* shell_status_menu_toggle:
* @menu: a #ShellStatusMenu
*
* If the menu is not currently up, pops it up. Otherwise, hides it.
* Popping up may fail if another grab is already active; check with
* shell_status_menu_is_active().
*/
void
shell_status_menu_toggle (ShellStatusMenu *status, ClutterEvent *event)
{
ShellStatusMenuPrivate *priv = status->priv;
if (GTK_WIDGET_VISIBLE (priv->menu))
{
gtk_menu_popdown (GTK_MENU (priv->menu));
}
else
{
/* We don't want to overgrab a Mutter grab with the grab that GTK+
* uses on menus.
*/
ShellGlobal *global = shell_global_get ();
if (shell_global_display_is_grabbed (global))
return;
gtk_menu_popup (GTK_MENU (priv->menu), NULL, NULL, position_menu,
status, 1, event->button.time);
}
}
/**
* 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));
}
}
/* hide the menu */
void menu_hide(GtkMenu* menu)
{
gtk_menu_popdown(GTK_MENU(menu));
return;
}
void GtkPopupMenu::popDown()
{
gtk_menu_popdown(GTK_MENU(m_popup.get()));
resetTypeAheadFindState();
}
void PopupMenu::hide()
{
ASSERT(m_popup);
gtk_menu_popdown(m_popup);
}
void WebPopupMenuProxyGtk::hidePopupMenu()
{
gtk_menu_popdown(GTK_MENU(m_popup));
resetTypeAheadFindState();
}
static gboolean
update_menu_state (WnckActionMenu *menu)
{
WnckActionMenuPrivate *priv;
WnckWindowActions actions;
WnckScreen *screen;
WnckWorkspace *workspace;
gboolean viewport_mode;
gboolean move_workspace_sensitive;
priv = menu->priv;
priv->idle_handler = 0;
actions = wnck_window_get_actions (priv->window);
screen = wnck_window_get_screen (priv->window);
viewport_mode = wnck_screen_get_workspace_count (screen) == 1 &&
wnck_workspace_is_virtual (wnck_screen_get_workspace (screen,
0));
move_workspace_sensitive = viewport_mode ||
(actions & WNCK_WINDOW_ACTION_CHANGE_WORKSPACE) != 0;
if (wnck_window_is_minimized (priv->window))
{
set_item_text (priv->minimize_item, _("Unmi_nimize"));
set_item_stock (priv->minimize_item, NULL);
gtk_widget_set_sensitive (priv->minimize_item,
(actions & WNCK_WINDOW_ACTION_UNMINIMIZE) != 0);
}
else
{
set_item_text (priv->minimize_item, _("Mi_nimize"));
set_item_stock (priv->minimize_item, WNCK_STOCK_MINIMIZE);
gtk_widget_set_sensitive (priv->minimize_item,
(actions & WNCK_WINDOW_ACTION_MINIMIZE) != 0);
}
if (wnck_window_is_maximized (priv->window))
{
set_item_text (priv->maximize_item, _("Unma_ximize"));
set_item_stock (priv->maximize_item, NULL);
gtk_widget_set_sensitive (priv->maximize_item,
(actions & WNCK_WINDOW_ACTION_UNMAXIMIZE) != 0);
}
else
{
set_item_text (priv->maximize_item, _("Ma_ximize"));
set_item_stock (priv->maximize_item, WNCK_STOCK_MAXIMIZE);
gtk_widget_set_sensitive (priv->maximize_item,
(actions & WNCK_WINDOW_ACTION_MAXIMIZE) != 0);
}
g_signal_handlers_block_by_func (G_OBJECT (priv->above_item),
item_activated_callback,
GINT_TO_POINTER (ABOVE));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->above_item),
wnck_window_is_above (priv->window));
g_signal_handlers_unblock_by_func (G_OBJECT (priv->above_item),
item_activated_callback,
GINT_TO_POINTER (ABOVE));
gtk_widget_set_sensitive (priv->above_item,
(actions & WNCK_WINDOW_ACTION_ABOVE) != 0);
g_signal_handlers_block_by_func (G_OBJECT (priv->pin_item),
item_activated_callback,
GINT_TO_POINTER (PIN));
g_signal_handlers_block_by_func (G_OBJECT (priv->unpin_item),
item_activated_callback,
GINT_TO_POINTER (UNPIN));
if ((viewport_mode && wnck_window_is_sticky (priv->window)) ||
(!viewport_mode && wnck_window_is_pinned (priv->window)))
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->pin_item),
TRUE);
else
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->unpin_item),
TRUE);
g_signal_handlers_unblock_by_func (G_OBJECT (priv->pin_item),
item_activated_callback,
GINT_TO_POINTER (PIN));
g_signal_handlers_unblock_by_func (G_OBJECT (priv->unpin_item),
item_activated_callback,
GINT_TO_POINTER (UNPIN));
gtk_widget_set_sensitive (priv->pin_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->unpin_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->close_item,
(actions & WNCK_WINDOW_ACTION_CLOSE) != 0);
gtk_widget_set_sensitive (priv->move_item,
(actions & WNCK_WINDOW_ACTION_MOVE) != 0);
gtk_widget_set_sensitive (priv->resize_item,
(actions & WNCK_WINDOW_ACTION_RESIZE) != 0);
gtk_widget_set_sensitive (priv->workspace_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->left_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->right_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->up_item,
move_workspace_sensitive);
gtk_widget_set_sensitive (priv->down_item,
move_workspace_sensitive);
workspace = wnck_window_get_workspace (priv->window);
if (viewport_mode && !wnck_window_is_sticky (priv->window))
{
int window_x, window_y;
int viewport_x, viewport_y;
int viewport_width, viewport_height;
int screen_width, screen_height;
if (!workspace)
workspace = wnck_screen_get_workspace (screen, 0);
wnck_window_get_geometry (priv->window, &window_x, &window_y, NULL, NULL);
viewport_x = wnck_workspace_get_viewport_x (workspace);
viewport_y = wnck_workspace_get_viewport_y (workspace);
window_x += viewport_x;
window_y += viewport_y;
viewport_width = wnck_workspace_get_width (workspace);
viewport_height = wnck_workspace_get_height (workspace);
screen_width = wnck_screen_get_width (screen);
screen_height = wnck_screen_get_height (screen);
if (window_x >= screen_width)
gtk_widget_show (priv->left_item);
else
gtk_widget_hide (priv->left_item);
if (window_x < viewport_width - screen_width)
gtk_widget_show (priv->right_item);
else
gtk_widget_hide (priv->right_item);
if (window_y >= screen_height)
gtk_widget_show (priv->up_item);
else
gtk_widget_hide (priv->up_item);
if (window_y < viewport_height - screen_height)
gtk_widget_show (priv->down_item);
else
gtk_widget_hide (priv->down_item);
}
else if (!viewport_mode && workspace && !wnck_window_is_pinned (priv->window))
{
if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_LEFT))
gtk_widget_show (priv->left_item);
else
gtk_widget_hide (priv->left_item);
if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_RIGHT))
gtk_widget_show (priv->right_item);
else
gtk_widget_hide (priv->right_item);
if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_UP))
gtk_widget_show (priv->up_item);
else
gtk_widget_hide (priv->up_item);
if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_DOWN))
gtk_widget_show (priv->down_item);
else
gtk_widget_hide (priv->down_item);
}
else
{
gtk_widget_hide (priv->left_item);
gtk_widget_hide (priv->right_item);
gtk_widget_hide (priv->up_item);
gtk_widget_hide (priv->down_item);
}
if (viewport_mode)
{
int viewport_width, viewport_height;
int screen_width, screen_height;
viewport_width = wnck_workspace_get_width (workspace);
viewport_height = wnck_workspace_get_height (workspace);
screen_width = wnck_screen_get_width (screen);
screen_height = wnck_screen_get_height (screen);
gtk_widget_show (priv->workspace_separator);
gtk_widget_show (priv->pin_item);
gtk_widget_show (priv->unpin_item);
if (viewport_width >= 2 * screen_width ||
viewport_height >= 2 * screen_height)
{
gtk_widget_show (priv->workspace_item);
refill_submenu_viewport (menu);
}
else
{
gtk_widget_hide (priv->workspace_item);
gtk_menu_popdown (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (priv->workspace_item))));
}
}
else if (wnck_screen_get_workspace_count (screen) > 1)
{
gtk_widget_show (priv->workspace_separator);
gtk_widget_show (priv->pin_item);
gtk_widget_show (priv->unpin_item);
gtk_widget_show (priv->workspace_item);
refill_submenu_workspace (menu);
}
else
{
gtk_widget_hide (priv->workspace_separator);
gtk_widget_hide (priv->pin_item);
gtk_widget_hide (priv->unpin_item);
gtk_widget_hide (priv->workspace_item);
gtk_menu_popdown (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (priv->workspace_item))));
}
gtk_menu_reposition (GTK_MENU (menu));
return FALSE;
}
void WebContextMenuProxyGtk::hideContextMenu()
{
gtk_menu_popdown(m_menu.platformDescription());
}
static void on_selection_changed(G_GNUC_UNUSED GtkTreeSelection *selection, GtkWidget *menu)
{
if (gtk_widget_get_visible(menu))
gtk_menu_popdown(GTK_MENU(menu));
}
static VALUE
rg_popdown(VALUE self)
{
gtk_menu_popdown(_SELF(self));
return self;
}
void PopupMenuGtk::hide()
{
ASSERT(m_popup);
gtk_menu_popdown(m_popup.get());
}
