static void
popup_individual_menu_cb (EmpathyRosterView *self,
const gchar *group,
FolksIndividual *individual,
guint button,
guint time,
gpointer user_data)
{
GtkWidget *menu, *item;
g_print ("'%s' (group: %s) popup menu\n",
folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual)), group);
menu = gtk_menu_new ();
g_signal_connect (menu, "deactivate",
G_CALLBACK (gtk_widget_destroy), NULL);
item = gtk_menu_item_new_with_label (folks_alias_details_get_alias (
FOLKS_ALIAS_DETAILS (individual)));
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_menu_attach_to_widget (GTK_MENU (menu), GTK_WIDGET (self), NULL);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, time);
}
static void
do_popup (GtkWidget *swatch,
gint button,
gint time)
{
GtkWidget *menu;
GtkWidget *item;
menu = gtk_menu_new ();
gtk_style_context_add_class (gtk_widget_get_style_context (menu),
GTK_STYLE_CLASS_CONTEXT_MENU);
item = gtk_menu_item_new_with_mnemonic (_("_Customize"));
gtk_menu_attach_to_widget (GTK_MENU (menu), swatch, NULL);
g_signal_connect_swapped (item, "activate",
G_CALLBACK (emit_customize), swatch);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show_all (item);
if (button != 0)
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
NULL, NULL, button, time);
else
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
popup_position_func, swatch,
button, time);
}
static void
presence_chooser_menu_popup (EmpathyPresenceChooser *chooser)
{
EmpathyPresenceChooserPriv *priv;
GtkWidget *menu;
priv = GET_PRIV (chooser);
if (priv->menu) {
return;
}
menu = empathy_presence_chooser_create_menu ();
g_signal_connect_after (menu, "selection-done",
G_CALLBACK (presence_chooser_menu_selection_done_cb),
chooser);
g_signal_connect (menu, "destroy",
G_CALLBACK (presence_chooser_menu_destroy_cb),
chooser);
gtk_menu_attach_to_widget (GTK_MENU (menu),
GTK_WIDGET (chooser),
presence_chooser_menu_detach);
gtk_menu_popup (GTK_MENU (menu),
NULL, NULL,
(GtkMenuPositionFunc) presence_chooser_menu_align_func,
chooser,
1,
gtk_get_current_event_time ());
priv->menu = menu;
}
static void
default_show_entry_view_popup (RBPlaylistSource *source,
RBEntryView *view,
gboolean over_entry)
{
GtkWidget *menu;
GMenuModel *playlist_menu;
if (over_entry == FALSE)
return;
/* update add to playlist menu links */
g_object_get (source, "playlist-menu", &playlist_menu, NULL);
rb_menu_update_link (source->priv->popup, "rb-playlist-menu-link", playlist_menu);
g_object_unref (playlist_menu);
menu = gtk_menu_new_from_model (G_MENU_MODEL (source->priv->popup));
gtk_menu_attach_to_widget (GTK_MENU (menu), GTK_WIDGET (source), NULL);
gtk_menu_popup (GTK_MENU (menu),
NULL,
NULL,
NULL,
NULL,
3,
gtk_get_current_event_time ());
}
/* This function shows a menu for the user to select which item to launch. */
void show_menu(pqi inst)
{
menu_iter iter; int i = 0,
orient = mate_panel_applet_get_orient(inst->applet);
GtkMenu* menu = GTK_MENU(gtk_menu_new());
gboolean reverse;
if (inst->clicked && inst->items)
{
reverse = (orient == MATE_PANEL_APPLET_ORIENT_UP);
for (reverse? menu_iterate_rbegin(inst,&iter,inst->show_primary):menu_iterate_begin(inst,&iter,inst->show_primary); iter.valid; menu_iter_next(&iter))
{
GtkWidget *mi = gtk_image_menu_item_new(),
*lbl = gtk_label_new(iter.text),
*icon = gtk_image_new_from_gicon(iter.icon, GTK_ICON_SIZE_DND);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), icon);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(mi), TRUE);
gtk_label_set_justify(GTK_LABEL(lbl),GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(lbl),0,0.5);
gtk_container_add(GTK_CONTAINER(mi),lbl);
gtk_widget_show_all(mi);
gtk_menu_insert(menu,mi,i++);
g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menu_launch), iter.si);
}
gtk_menu_attach_to_widget(menu,inst->box,NULL);
gtk_menu_popup(menu,NULL,NULL,set_to_corner, inst, 1, 0);
}
inst->clicked = FALSE;
}
void WebContextMenuProxyGtk::showContextMenu()
{
Vector<RefPtr<WebContextMenuItem>> proposedAPIItems;
for (auto& item : m_context.menuItems()) {
if (item.action() != ContextMenuItemTagShareMenu)
proposedAPIItems.append(WebContextMenuItem::create(item));
}
Vector<RefPtr<WebContextMenuItem>> clientItems;
bool useProposedItems = true;
if (m_page->contextMenuClient().getContextMenuFromProposedMenu(*m_page, proposedAPIItems, clientItems, m_context.webHitTestResultData(), m_page->process().transformHandlesToObjects(m_userData.object()).get()))
useProposedItems = false;
const Vector<RefPtr<WebContextMenuItem>>& items = useProposedItems ? proposedAPIItems : clientItems;
if (!items.isEmpty())
populate(items);
if (!m_menu.itemCount())
return;
m_popupPosition = convertWidgetPointToScreenPoint(m_webView, m_context.menuLocation());
// Display menu initiated by right click (mouse button pressed = 3).
NativeWebMouseEvent* mouseEvent = m_page->currentlyProcessedMouseDownEvent();
const GdkEvent* event = mouseEvent ? mouseEvent->nativeEvent() : 0;
gtk_menu_attach_to_widget(m_menu.platformDescription(), GTK_WIDGET(m_webView), 0);
gtk_menu_popup(m_menu.platformDescription(), 0, 0, reinterpret_cast<GtkMenuPositionFunc>(menuPositionFunction), this,
event ? event->button.button : 3, event ? event->button.time : GDK_CURRENT_TIME);
}
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);
}
static void
create_popup_menu(GtkWidget *widget)
{
GtkWidget *menu = gtk_menu_new();
GtkWidget *open_item = gtk_menu_item_new_with_label("Open");
GtkWidget *quit_item = gtk_menu_item_new_with_label("Quit");
GtkWidget *quit_all_item = gtk_menu_item_new_with_label("Quit All");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), open_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), quit_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), quit_all_item);
gtk_widget_show(open_item);
gtk_widget_show(quit_item);
gtk_widget_show(quit_all_item);
gtk_menu_attach_to_widget(GTK_MENU(menu),GTK_WIDGET(widget),popup_menu_detacher);
g_signal_connect_swapped(G_OBJECT(widget), "destroy",
G_CALLBACK(gtk_menu_detach), menu);
g_signal_connect_swapped(G_OBJECT(widget), "button_press_event",
G_CALLBACK(popup_menu_handler), menu);
g_signal_connect(G_OBJECT(open_item), "activate",
G_CALLBACK(select_lwobject), NULL);
g_signal_connect_swapped(G_OBJECT(quit_item), "activate",
G_CALLBACK(gtk_widget_destroy), widget);
g_signal_connect(G_OBJECT(quit_all_item), "activate",
G_CALLBACK(gtk_main_quit), NULL);
}
static void
rb_import_errors_source_songs_show_popup_cb (RBEntryView *view,
gboolean over_entry,
RBImportErrorsSource *source)
{
GtkWidget *menu;
GtkBuilder *builder;
if (over_entry == FALSE)
return;
if (source->priv->popup == NULL) {
builder = rb_builder_load ("import-errors-popup.ui", NULL);
source->priv->popup = G_MENU_MODEL (gtk_builder_get_object (builder, "import-errors-popup"));
g_object_ref (source->priv->popup);
g_object_unref (builder);
}
menu = gtk_menu_new_from_model (source->priv->popup);
gtk_menu_attach_to_widget (GTK_MENU (menu), GTK_WIDGET (source), NULL);
gtk_menu_popup (GTK_MENU (menu),
NULL,
NULL,
NULL,
NULL,
3,
gtk_get_current_event_time ());
}
static void
create_proc_view(GsmApplication *app, GtkBuilder * builder)
{
GsmTreeView *proctree;
GtkScrolledWindow *scrolled;
proctree = proctable_new (app);
scrolled = GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "processes_scrolled"));
gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (proctree));
app->proc_actionbar_revealer = GTK_REVEALER (gtk_builder_get_object (builder, "proc_actionbar_revealer"));
/* create popup_menu for the processes tab */
GMenuModel *menu_model = G_MENU_MODEL (gtk_builder_get_object (builder, "process-popup-menu"));
app->popup_menu = GTK_MENU (gtk_menu_new_from_model (menu_model));
gtk_menu_attach_to_widget (app->popup_menu, GTK_WIDGET (app->main_window), NULL);
app->search_bar = GTK_SEARCH_BAR (gtk_builder_get_object (builder, "proc_searchbar"));
app->search_entry = GTK_SEARCH_ENTRY (gtk_builder_get_object (builder, "proc_searchentry"));
gtk_search_bar_connect_entry (app->search_bar, GTK_ENTRY (app->search_entry));
g_signal_connect (app->main_window, "key-press-event",
G_CALLBACK (cb_window_key_press_event), app->search_bar);
g_signal_connect (app->search_entry, "changed", G_CALLBACK (search_text_changed), app);
g_object_bind_property (app->search_bar, "search-mode-enabled", app->search_button, "active", (GBindingFlags)(G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE));
}
static void
show_tree_popup_menu (GtkTreeView *tree,
EomPluginManager *pm,
GdkEventButton *event)
{
if (pm->priv->popup_menu)
gtk_widget_destroy (pm->priv->popup_menu);
pm->priv->popup_menu = create_tree_popup_menu (pm);
if (pm->priv->popup_menu == NULL)
return;
gtk_menu_attach_to_widget (GTK_MENU (pm->priv->popup_menu),
GTK_WIDGET (pm),
(GtkMenuDetachFunc) tree_popup_menu_detach);
if (event != NULL) {
gtk_menu_popup (GTK_MENU (pm->priv->popup_menu), NULL, NULL,
NULL, NULL,
event->button, event->time);
} else {
gtk_menu_popup (GTK_MENU (pm->priv->popup_menu), NULL, NULL,
menu_position_under_tree_view, tree,
0, gtk_get_current_event_time ());
gtk_menu_shell_select_first (GTK_MENU_SHELL (pm->priv->popup_menu),
FALSE);
}
}
static void
opts_clicked(GtkToolButton *toolbutton, gpointer user_data)
{
int event_time = gtk_get_current_event_time();
gu_tab_t *gt = user_data;
gtk_ui_t *gu = gt->gt_gw->gw_gu;
dyn_menu_t *dm = calloc(1, sizeof(dyn_menu_t));
dm->dm_menu = gtk_menu_new();
gtk_widget_show_all(dm->dm_menu);
gtk_menu_attach_to_widget(GTK_MENU(dm->dm_menu), GTK_WIDGET(toolbutton), NULL);
gtk_menu_popup(GTK_MENU(dm->dm_menu), NULL, NULL, NULL, NULL,
0, event_time);
gu_cloner_init(&dm->dm_nodes, dm, dyn_menu_item_add, dyn_menu_item_del,
sizeof(dyn_menu_item_t), gu, GU_CLONER_TRACK_POSITION);
dm->dm_node_sub =
prop_subscribe(0,
PROP_TAG_NAME("nav", "currentpage", "model", "options"),
PROP_TAG_CALLBACK, gu_cloner_subscription, &dm->dm_nodes,
PROP_TAG_NAMED_ROOT, gt->gt_nav, "nav",
PROP_TAG_COURIER, gu->gu_pc,
NULL);
g_signal_connect(dm->dm_menu, "destroy", G_CALLBACK(dyn_menu_destroyed), dm);
}
static void
do_popup (GtkWidget *swatch,
GdkEventButton *event)
{
GtkWidget *menu;
GtkWidget *item;
menu = gtk_menu_new ();
item = gtk_menu_item_new_with_mnemonic (_("_Customize"));
gtk_menu_attach_to_widget (GTK_MENU (menu), swatch, NULL);
g_signal_connect_swapped (item, "activate",
G_CALLBACK (emit_customize), swatch);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show_all (item);
if (event)
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
NULL, NULL, event->button, event->time);
else
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
popup_position_func, swatch,
0, gtk_get_current_event_time ());
}
static void
panel_applet_menu_popup (PanelApplet *applet,
guint button,
guint32 time)
{
GtkWidget *menu;
GMenu *gmenu;
GList *children, *l;
gboolean visible = FALSE;
gmenu = G_MENU (gtk_builder_get_object (applet->priv->builder, "panel-applet-popup"));
menu = gtk_menu_new_from_model (G_MENU_MODEL (gmenu));
gtk_menu_attach_to_widget (GTK_MENU (menu), GTK_WIDGET (applet), NULL);
children = gtk_container_get_children (GTK_CONTAINER (menu));
for (l = children; l != NULL; l = l->next) {
visible = gtk_widget_get_visible (GTK_WIDGET (l->data));
if (visible)
break;
}
g_list_free (children);
if (!visible)
return;
gtk_menu_popup (GTK_MENU (menu),
NULL, NULL,
(GtkMenuPositionFunc) panel_applet_position_menu,
applet,
button, time);
}
static void
build_menu (NemoBlankDesktopWindow *window)
{
if (window->details->popup_menu) {
return;
}
NemoActionManager *desktop_action_manager = nemo_desktop_manager_get_action_manager ();
if (window->details->actions_changed_id == 0) {
window->details->actions_changed_id = g_signal_connect_swapped (desktop_action_manager,
"changed",
G_CALLBACK (actions_changed_cb),
window);
}
GList *action_list = nemo_action_manager_list_actions (desktop_action_manager);
if (g_list_length (action_list) == 0)
return;
window->details->popup_menu = gtk_menu_new ();
gboolean show;
g_object_get (gtk_settings_get_default (), "gtk-menu-images", &show, NULL);
gtk_menu_attach_to_widget (GTK_MENU (window->details->popup_menu),
GTK_WIDGET (window),
NULL);
GtkWidget *item;
GList *l;
NemoAction *action;
for (l = action_list; l != NULL; l = l->next) {
action = l->data;
if (action->show_in_blank_desktop && action->dbus_satisfied) {
gchar *label = nemo_action_get_label (action, NULL, NULL);
item = gtk_image_menu_item_new_with_mnemonic (label);
g_free (label);
const gchar *stock_id = gtk_action_get_stock_id (GTK_ACTION (action));
const gchar *icon_name = gtk_action_get_icon_name (GTK_ACTION (action));
if (stock_id || icon_name) {
GtkWidget *image = stock_id ? gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU) :
gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_image_menu_item_set_always_show_image (GTK_IMAGE_MENU_ITEM (item), show);
}
gtk_widget_set_visible (item, TRUE);
g_signal_connect (item, "activate", G_CALLBACK (action_activated_callback), action);
gtk_menu_shell_append (GTK_MENU_SHELL (window->details->popup_menu), item);
}
}
}
static GtkWidget*
CreateMenuPopupWidget()
{
GtkWidget* widget = gtk_menu_new();
gtk_menu_attach_to_widget(GTK_MENU(widget), GetWidget(MOZ_GTK_WINDOW),
nullptr);
return widget;
}
static void
button_toggled_cb (GtkToggleButton* button)
{
if (gtk_toggle_button_get_active (button))
{
GtkWidget* item = NULL;
GList * window;
g_return_if_fail (!menu);
menu = g_object_ref_sink (gtk_menu_new ());
item = gtk_menu_item_new_with_label (wnck_workspace_get_name (PRIV (button)->workspace));
gtk_widget_set_sensitive (item, FALSE);
#if 0
g_signal_connect (item, "select",
G_CALLBACK (select_cb), PRIV (button)->workspace);
g_signal_connect (item, "deselect",
G_CALLBACK (unselect_cb), PRIV (button)->workspace);
#endif
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_separator_menu_item_new ();
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
for (window = wnck_screen_get_windows (wnck_workspace_get_screen (PRIV (button)->workspace)); window; window = window->next)
{
if (!wnck_window_is_on_workspace (window->data, PRIV (button)->workspace) ||
(wnck_window_get_state (window->data) & WNCK_WINDOW_STATE_SKIP_TASKLIST))
{
continue;
}
item = window_menu_item_new (window->data);
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
}
gtk_menu_attach_to_widget (GTK_MENU (menu),
GTK_WIDGET (button),
NULL);
gtk_menu_set_screen (GTK_MENU (menu),
gtk_widget_get_screen (GTK_WIDGET (button)));
gtk_menu_popup (GTK_MENU (menu),
NULL, NULL,
menu_position_func, button,
0, gtk_get_current_event_time ());
g_object_add_weak_pointer (G_OBJECT (menu), (gpointer*)&menu);
g_signal_connect (menu, "selection-done",
G_CALLBACK (untoggle), button);
}
}
static VALUE
rg_attach_to_widget(VALUE self, VALUE attach_widget)
{
menu_detacher = rb_block_proc();
G_RELATIVE(self, menu_detacher);
gtk_menu_attach_to_widget(_SELF(self),
GTK_WIDGET(RVAL2GOBJ(attach_widget)),
(GtkMenuDetachFunc)detach_func);
return self;
}
static GtkWidget *linphone_gtk_create_call_log_menu(GtkWidget *call_log){
GtkWidget *menu=gtk_menu_new();
GtkWidget *menu_item;
gchar *call_label=NULL;
gchar *text_label=NULL;
gchar *name=NULL;
GtkWidget *image;
GtkTreeSelection *select;
GtkTreeIter iter;
select=gtk_tree_view_get_selection(GTK_TREE_VIEW(call_log));
if (select!=NULL){
GtkTreeModel *model=NULL;
if (gtk_tree_selection_get_selected (select,&model,&iter)){
gpointer pcl;
LinphoneAddress *la;
LinphoneCallLog *cl;
gtk_tree_model_get(model,&iter,2,&pcl,-1);
cl = (LinphoneCallLog *)pcl;
la = linphone_call_log_get_dir(cl)==LinphoneCallIncoming ? linphone_call_log_get_from(cl) : linphone_call_log_get_to(cl);
name=linphone_address_as_string(la);
call_label=g_strdup_printf(_("Call %s"),name);
text_label=g_strdup_printf(_("Send text to %s"),name);
g_free(name);
}
}
if (call_label){
menu_item=gtk_image_menu_item_new_with_label(call_label);
image=gtk_image_new_from_stock(GTK_STOCK_NETWORK,GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),image);
gtk_widget_show(image);
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_call_selected,call_log);
}
if (text_label){
menu_item=gtk_image_menu_item_new_with_label(text_label);
image=gtk_image_new_from_stock(GTK_STOCK_NETWORK,GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),image);
gtk_widget_show(image);
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_call_log_chat_selected,call_log);
}
menu_item=gtk_image_menu_item_new_from_stock(GTK_STOCK_ADD,NULL);
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menu_item);
g_signal_connect_swapped(G_OBJECT(menu_item),"activate",(GCallback)linphone_gtk_call_log_add_contact,call_log);
gtk_widget_show(menu);
gtk_menu_attach_to_widget(GTK_MENU(menu),call_log, NULL);
if (call_label) g_free(call_label);
if (text_label) g_free(text_label);
return menu;
}
/**
* nma_utils_setup_password_storage:
* @passwd_entry: password #GtkEntry which the icon is attached to
* @initial_flags: initial secret flags to setup password menu from
* @setting: #NMSetting containing the password, or NULL
* @password_flags_name: name of the secret flags (like psk-flags), or NULL
* @with_not_required: whether to include "Not required" menu item
* @ask_mode: %TRUE if the entrie is shown in ASK mode. That means,
* while prompting for a password, contrary to being inside the
* editor mode.
* If %TRUE, the entry should be sensivive on selected "always-ask"
* icon (this is e.f. for nm-applet asking for password), otherwise
* not.
* If %TRUE, it shall not be possible to select a different storage,
* because we only prompt for a password, we cannot change the password
* location.
*
* Adds a secondary icon and creates a popup menu for password entry.
* The active menu item is set up according to initial_flags, or
* from @setting/@password_flags_name (if they are not NULL).
* If the @setting/@password_flags_name are not NULL, secret flags will
* be automatically updated in the setting when menu is changed.
*/
void
nma_utils_setup_password_storage (GtkWidget *passwd_entry,
NMSettingSecretFlags initial_flags,
NMSetting *setting,
const char *password_flags_name,
gboolean with_not_required,
gboolean ask_mode)
{
GtkWidget *popup_menu;
GtkWidget *item[4];
GSList *group;
MenuItem idx;
NMSettingSecretFlags secret_flags;
/* Whether entry should be sensitive if "always-ask" is active " */
g_object_set_data (G_OBJECT (passwd_entry), ASK_MODE_TAG, GUINT_TO_POINTER (ask_mode));
popup_menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (popup_menu), PASSWORD_STORAGE_MENU_TAG, GUINT_TO_POINTER (TRUE));
g_object_set_data (G_OBJECT (popup_menu), MENU_WITH_NOT_REQUIRED_TAG, GUINT_TO_POINTER (with_not_required));
group = NULL;
item[0] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[0]));
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item[0]));
item[1] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[1]));
item[2] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[2]));
if (with_not_required)
item[3] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[3]));
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[0]);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[1]);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[2]);
if (with_not_required)
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[3]);
popup_menu_item_info_register (item[0], setting, password_flags_name, ITEM_STORAGE_USER, passwd_entry);
popup_menu_item_info_register (item[1], setting, password_flags_name, ITEM_STORAGE_SYSTEM, passwd_entry);
popup_menu_item_info_register (item[2], setting, password_flags_name, ITEM_STORAGE_ASK, passwd_entry);
if (with_not_required)
popup_menu_item_info_register (item[3], setting, password_flags_name, ITEM_STORAGE_UNUSED, passwd_entry);
g_signal_connect (passwd_entry, "icon-release", G_CALLBACK (icon_release_cb), popup_menu);
gtk_entry_set_icon_activatable (GTK_ENTRY (passwd_entry), GTK_ENTRY_ICON_SECONDARY,
!ask_mode);
gtk_menu_attach_to_widget (GTK_MENU (popup_menu), passwd_entry, NULL);
/* Initialize active item for password-storage popup menu */
if (setting && password_flags_name)
nm_setting_get_secret_flags (setting, password_flags_name, &secret_flags, NULL);
else
secret_flags = initial_flags;
idx = secret_flags_to_menu_item (secret_flags, with_not_required);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item[idx]), TRUE);
change_password_storage_icon (passwd_entry, idx);
}
static void
popup_targets_received (GtkClipboard *clipboard,
GtkSelectionData *data,
gpointer user_data)
{
PopupInfo *popup_info = user_data;
g_autoptr(IdeTerminal) self = NULL;
g_autoptr(GdkEvent) event = NULL;
IdeTerminalPrivate *priv;
g_assert (popup_info != NULL);
g_assert (IDE_IS_TERMINAL (popup_info->terminal));
self = g_steal_pointer (&popup_info->terminal);
priv = ide_terminal_get_instance_private (self);
event = g_steal_pointer (&popup_info->event);
if (gtk_widget_get_realized (GTK_WIDGET (self)))
{
DzlWidgetActionGroup *group;
GMenu *menu;
gboolean clipboard_contains_text;
gboolean have_selection;
clipboard_contains_text = gtk_selection_data_targets_include_text (data);
have_selection = vte_terminal_get_has_selection (VTE_TERMINAL (self));
g_clear_pointer (&priv->popup_menu, gtk_widget_destroy);
priv->url = vte_terminal_match_check_event (VTE_TERMINAL (self), event, NULL);
menu = dzl_application_get_menu_by_id (DZL_APPLICATION_DEFAULT, "ide-terminal-view-popup-menu");
priv->popup_menu = gtk_menu_new_from_model (G_MENU_MODEL (menu));
group = DZL_WIDGET_ACTION_GROUP (gtk_widget_get_action_group (GTK_WIDGET (self), "terminal"));
dzl_widget_action_group_set_action_enabled (group, "copy-link-address", priv->url != NULL);
dzl_widget_action_group_set_action_enabled (group, "open-link", priv->url != NULL);
dzl_widget_action_group_set_action_enabled (group, "copy-clipboard", have_selection);
dzl_widget_action_group_set_action_enabled (group, "paste-clipboard", clipboard_contains_text);
dzl_gtk_widget_add_style_class (priv->popup_menu, GTK_STYLE_CLASS_CONTEXT_MENU);
gtk_menu_attach_to_widget (GTK_MENU (priv->popup_menu), GTK_WIDGET (self), popup_menu_detach);
g_signal_emit (self, signals[POPULATE_POPUP], 0, priv->popup_menu);
gtk_menu_popup_at_pointer (GTK_MENU (priv->popup_menu), event);
}
g_slice_free (PopupInfo, popup_info);
}
gboolean
on_metalist_button_press_event (GtkWidget *widget,
GdkEventButton *event,
gpointer user_data)
{
if (event->button == 3) {
GtkWidget *menu = create_trkproperties_popup_menu ();
if (numtracks != 1) {
gtk_widget_set_sensitive (lookup_widget (menu, "trkproperties_edit"), FALSE);
}
gtk_menu_attach_to_widget (GTK_MENU (menu), GTK_WIDGET (widget), NULL);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, event->button, gtk_get_current_event_time());
}
return FALSE;
}
/* This function is used in GtkMenuToolButton, the call back will
* be called when GtkMenuToolButton would have emitted the “show-menu”
* signal.
*/
void
_gtk_menu_button_set_popup_with_func (GtkMenuButton *menu_button,
GtkWidget *menu,
GtkMenuButtonShowMenuCallback func,
gpointer user_data)
{
GtkMenuButtonPrivate *priv;
g_return_if_fail (GTK_IS_MENU_BUTTON (menu_button));
g_return_if_fail (GTK_IS_MENU (menu) || menu == NULL);
priv = menu_button->priv;
priv->func = func;
priv->user_data = user_data;
if (priv->menu == GTK_WIDGET (menu))
return;
if (priv->menu)
{
if (gtk_widget_get_visible (priv->menu))
gtk_menu_shell_deactivate (GTK_MENU_SHELL (priv->menu));
g_signal_handlers_disconnect_by_func (priv->menu,
menu_deactivate_cb,
menu_button);
gtk_menu_detach (GTK_MENU (priv->menu));
}
priv->menu = menu;
if (priv->menu)
{
gtk_menu_attach_to_widget (GTK_MENU (priv->menu), GTK_WIDGET (menu_button),
menu_detacher);
gtk_widget_set_visible (priv->menu, FALSE);
g_signal_connect_swapped (priv->menu, "deactivate",
G_CALLBACK (menu_deactivate_cb), menu_button);
gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (menu_button)), "menu-button");
}
update_sensitivity (menu_button);
g_object_notify (G_OBJECT (menu_button), "popup");
g_object_notify (G_OBJECT (menu_button), "menu-model");
}
GuiObject GuiMenuBar_addMenu3 (GuiObject parent, const wchar_t *title, long flags, GuiObject *button) {
GuiObject menu;
menu = gtk_menu_new ();
*button = gtk_button_new_with_label (Melder_peekWcsToUtf8 (title));
g_signal_connect_object (G_OBJECT (*button), "event",
GTK_SIGNAL_FUNC (button_press), G_OBJECT (menu), G_CONNECT_SWAPPED);
g_object_set_data (G_OBJECT (menu), "button", *button);
if (flags & GuiMenu_INSENSITIVE)
gtk_widget_set_sensitive (menu, FALSE);
gtk_menu_attach_to_widget (GTK_MENU (menu), *button, NULL);
/* TODO: Free button? */
gtk_container_add (GTK_CONTAINER (parent), *button);
gtk_widget_show (menu);
gtk_widget_show (*button);
return menu;
}
void WebContextMenuProxyGtk::showContextMenu(const WebCore::IntPoint& position, const Vector<WebContextMenuItemData>& items)
{
if (!items.isEmpty())
populate(items);
if (!m_menu.itemCount())
return;
m_popupPosition = convertWidgetPointToScreenPoint(m_webView, position);
// Display menu initiated by right click (mouse button pressed = 3).
NativeWebMouseEvent* mouseEvent = m_page->currentlyProcessedMouseDownEvent();
const GdkEvent* event = mouseEvent ? mouseEvent->nativeEvent() : 0;
gtk_menu_attach_to_widget(m_menu.platformDescription(), GTK_WIDGET(m_webView), 0);
gtk_menu_popup(m_menu.platformDescription(), 0, 0, reinterpret_cast<GtkMenuPositionFunc>(menuPositionFunction), this,
event ? event->button.button : 3, event ? event->button.time : GDK_CURRENT_TIME);
}
static GtkWidget*
create_tab_popup_menu(AnjutaMsgman* msgman)
{
GtkWidget* menu;
GtkWidget* item_close_all;
menu = gtk_menu_new();
item_close_all = gtk_menu_item_new_with_label(_("Close all message tabs"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item_close_all);
g_signal_connect(G_OBJECT(item_close_all), "activate", G_CALLBACK(on_msgman_close_all),
msgman);
gtk_widget_show_all(menu);
gtk_menu_attach_to_widget(GTK_MENU(menu), GTK_WIDGET(msgman), NULL);
return menu;
}
gboolean on_icon_released(GtkWidget *title, GdkEventButton *event, WindowckPlugin *wckp)
{
GtkWidget *menu;
if ((event->button != 1)
|| (wnck_window_get_window_type (wckp->win->controlwindow) == WNCK_WINDOW_DESKTOP))
return FALSE;
menu = wnck_action_menu_new (wckp->win->controlwindow);
gtk_menu_attach_to_widget(GTK_MENU(menu), GTK_WIDGET(wckp->icon->eventbox), NULL);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
xfce_panel_plugin_position_menu,
wckp->plugin,
1, gtk_get_current_event_time ());
return TRUE;
}
static void
hn_others_button_create_menu (HNOthersButton *button)
{
GtkWidget * menu;
g_return_if_fail (button);
/* Create the menu shell, and connect callbacks */
menu = gtk_menu_new ();
gtk_widget_set_name (menu, NAVIGATOR_MENU_NAME);
g_signal_connect (G_OBJECT (menu),
"size-request",
G_CALLBACK (hn_others_menu_size_request),
button);
g_signal_connect (G_OBJECT (menu),
"deactivate",
G_CALLBACK (hn_others_menu_deactivate),
button);
g_signal_connect (G_OBJECT (menu),
"key-press-event",
G_CALLBACK (hn_others_menu_key_press),
button);
if (TASKNAVIGATOR_ITEM (button)->menu)
{
/* Destroy the previous version of the menu */
g_debug ("Destroying previous menu... ");
gtk_widget_destroy (GTK_WIDGET (TASKNAVIGATOR_ITEM (button)->menu));
g_debug ("done.");
}
gtk_menu_attach_to_widget (GTK_MENU (menu),
button->priv->button,
NULL);
TASKNAVIGATOR_ITEM (button)->menu = GTK_MENU (menu);
/* Now populate the menu */
hn_others_menu_populate (button);
}
static gboolean
widget_button_press_event_cb (GtkWidget *widget,
GdkEventButton *event,
gpointer user_data)
{
GtkAppChooserWidget *self = user_data;
if (event->button == GDK_BUTTON_SECONDARY && event->type == GDK_BUTTON_PRESS)
{
GAppInfo *info;
GtkWidget *menu;
GList *children;
gint n_children;
info = get_app_info_for_event (self, event);
if (info == NULL)
return FALSE;
menu = gtk_menu_new ();
g_signal_emit (self, signals[SIGNAL_POPULATE_POPUP], 0,
menu, info);
g_object_unref (info);
/* see if clients added menu items to this container */
children = gtk_container_get_children (GTK_CONTAINER (menu));
n_children = g_list_length (children);
if (n_children > 0)
{
/* actually popup the menu */
gtk_menu_attach_to_widget (GTK_MENU (menu), self->priv->program_list, NULL);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
event->button, event->time);
}
g_list_free (children);
}
return FALSE;
}
/* Convenient function to create a GtkMenu attached to @attach_to and detach
* it when the menu is not displayed any more. This is useful when creating a
* context menu that we want to get rid as soon as it as been displayed. */
GtkWidget *
empathy_context_menu_new (GtkWidget *attach_to)
{
GtkWidget *menu;
menu = gtk_menu_new ();
gtk_menu_attach_to_widget (GTK_MENU (menu), attach_to, NULL);
/* menu is initially unowned but gtk_menu_attach_to_widget () taked its
* floating ref. We can either wait that @attach_to releases its ref when
* it will be destroyed (when leaving Empathy most of the time) or explicitely
* detach the menu when it's not displayed any more.
* We go for the latter as we don't want to keep useless menus in memory
* during the whole lifetime of Empathy. */
g_signal_connect (menu, "deactivate", G_CALLBACK (menu_deactivate_cb), NULL);
return menu;
}
