void panel_menu_button_popup_menu (PanelMenuButton *button, guint n_button, guint32 activate_time) { GdkScreen *screen; g_return_if_fail (PANEL_IS_MENU_BUTTON (button)); panel_menu_button_create_menu (button); panel_toplevel_push_autohide_disabler (button->priv->toplevel); button_widget_set_ignore_leave (BUTTON_WIDGET (button), TRUE); screen = gtk_window_get_screen (GTK_WINDOW (button->priv->toplevel)); gtk_menu_set_screen (GTK_MENU (button->priv->menu), screen); gtk_menu_popup (GTK_MENU (button->priv->menu), NULL, NULL, (GtkMenuPositionFunc) mate_panel_applet_position_menu, GTK_WIDGET (button), n_button, activate_time); }
static void popup_menu (GtkStatusIcon *icon, guint button, guint32 activate_time) { GtkWidget *menu, *menuitem; menu = gtk_menu_new (); gtk_menu_set_screen (GTK_MENU (menu), gtk_status_icon_get_screen (icon)); menuitem = gtk_menu_item_new_with_label ("Quit"); g_signal_connect (menuitem, "activate", G_CALLBACK (do_quit), NULL); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); menuitem = gtk_menu_item_new_with_label ("Exit abruptly"); g_signal_connect (menuitem, "activate", G_CALLBACK (do_exit), NULL); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, gtk_status_icon_position_menu, icon, button, activate_time); }
static gboolean panel_popup_menu (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->insert_pack_type = panel_widget_get_insert_pack_type_at_cursor (panel_widget); else panel_data->insert_pack_type = PANEL_OBJECT_PACK_START; menu = make_popup_panel_menu (panel_widget); 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); return TRUE; }
static void applet_show_menu (AppletInfo *info, GtkWidget *menu, gboolean custom_position, GdkEventButton *event) { PanelWidget *panel_widget; g_return_if_fail (info != NULL); if (menu == NULL) return; panel_widget = panel_applet_get_panel_widget (info); panel_applet_menu_set_recurse (GTK_MENU (menu), "menu_panel", panel_widget); gtk_menu_set_screen (GTK_MENU (menu), gtk_window_get_screen (GTK_WINDOW (panel_widget->toplevel))); if (!gtk_widget_get_realized (menu)) gtk_widget_show (menu); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, custom_position ? (GtkMenuPositionFunc) panel_applet_position_menu : NULL, info->widget, event->button, event->time); }
static void applet_show_menu (AppletInfo *info, GdkEventButton *event) { PanelWidget *panel_widget; g_return_if_fail (info != NULL); panel_widget = mate_panel_applet_get_panel_widget (info); if (info->menu == NULL) info->menu = mate_panel_applet_create_menu (info); if (info->menu == NULL) return; mate_panel_applet_menu_set_recurse (GTK_MENU (info->menu), "menu_panel", panel_widget); gtk_menu_set_screen (GTK_MENU (info->menu), gtk_window_get_screen (GTK_WINDOW (panel_widget->toplevel))); if (!gtk_widget_get_realized (info->menu)) gtk_widget_show (info->menu); gtk_menu_popup (GTK_MENU (info->menu), NULL, NULL, (GtkMenuPositionFunc) mate_panel_applet_position_menu, info->widget, event->button, event->time); }
GdkDragAction _gtk_menu_ask_drag_drop_action(GtkWidget *widget, GdkDragAction actions, guint32 activate_time) { DropActionData drop_data; GtkWidget *menu; GtkWidget *item; drop_data.action_name = 0; drop_data.loop = g_main_loop_new(NULL, FALSE); menu = gtk_menu_new(); gtk_menu_set_screen(GTK_MENU(menu), gtk_widget_get_screen(widget)); _gtk_menu_ask_drag_drop_action_append_item(menu, _("_Copy Here"), actions, GDK_ACTION_COPY, &drop_data); _gtk_menu_ask_drag_drop_action_append_item(menu, _("_Move Here"), actions, GDK_ACTION_MOVE, &drop_data); _gtk_menu_ask_drag_drop_action_append_item(menu, _("_Link Here"), actions, GDK_ACTION_LINK, &drop_data); item = gtk_separator_menu_item_new(); gtk_widget_show(item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); item = gtk_menu_item_new_with_label(_("Cancel")); gtk_widget_show(item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(menu, "deactivate", G_CALLBACK(ask_drag_drop_action_menu_deactivate_cb), &drop_data); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, activate_time); gtk_grab_add(menu); g_main_loop_run(drop_data.loop); gtk_grab_remove(menu); gtk_widget_destroy(menu); g_main_loop_unref(drop_data.loop); return drop_data.action_name; }
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; }
static gboolean show_item_menu (GtkWidget *item, GdkEventButton *bevent) { PanelWidget *panel_widget; GtkWidget *menu; if (panel_lockdown_get_locked_down ()) return FALSE; panel_widget = menu_get_panel (item); menu = g_object_get_data (G_OBJECT (item), "panel-item-context-menu"); if (!menu) menu = create_item_context_menu (item, panel_widget); if (!menu) return FALSE; gtk_menu_set_screen (GTK_MENU (menu), gtk_window_get_screen (GTK_WINDOW (panel_widget->toplevel))); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, bevent->button, bevent->time); return TRUE; }
static void panel_action_protocol_main_menu (GdkScreen *screen, guint32 activate_time) { PanelWidget *panel_widget; GtkWidget *menu; AppletInfo *info; info = panel_applet_get_by_type (PANEL_OBJECT_MENU_BAR, screen); if (info) { panel_menu_bar_popup_menu (PANEL_MENU_BAR (info->widget), activate_time); return; } info = panel_applet_get_by_type (PANEL_OBJECT_MENU, screen); if (info && panel_menu_button_is_main_menu (PANEL_MENU_BUTTON (info->widget))) { panel_menu_button_popup_menu (PANEL_MENU_BUTTON (info->widget), 1, activate_time); return; } panel_widget = panels->data; menu = create_main_menu (panel_widget); panel_toplevel_push_autohide_disabler (panel_widget->toplevel); gtk_menu_set_screen (GTK_MENU (menu), screen); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, activate_time); }
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 gboolean _button_clicked_event (CairoMainIcon *icon, GdkEventButton *event, gpointer null) { g_return_val_if_fail (AWN_IS_CAIRO_MAIN_ICON(icon), FALSE); CairoMainIconPrivate * priv = GET_PRIVATE (icon); if (event->button == 1) { awn_icon_popup_gtk_menu (AWN_ICON (icon), priv->menu, event->button, event->time); if (!priv->autohide_cookie) { priv->autohide_cookie = awn_applet_inhibit_autohide (AWN_APPLET(priv->applet),"CairoMenu" ); } g_object_set(awn_overlayable_get_effects (AWN_OVERLAYABLE(icon)), "depressed", FALSE,NULL); } else if (event->button == 3) { GtkWidget * item; if (!priv->context_menu) { priv->context_menu = awn_applet_create_default_menu (AWN_APPLET(priv->applet)); gtk_menu_set_screen(GTK_MENU(priv->context_menu), NULL); item = awn_themed_icon_create_remove_custom_icon_item (AWN_THEMED_ICON(icon),NULL); gtk_menu_shell_append (GTK_MENU_SHELL(priv->context_menu), item); /* item = gtk_image_menu_item_new_with_label("Applet Preferences"); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(item), gtk_image_new_from_stock (GTK_STOCK_PREFERENCES,GTK_ICON_SIZE_MENU)); gtk_widget_show(item); gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item); */ // g_signal_connect(G_OBJECT(item), "button-press-event", G_CALLBACK(_show_prefs), NULL); item=awn_applet_create_about_item_simple(AWN_APPLET(priv->applet), "Copyright 2007,2008, 2009 Rodney Cryderman <*****@*****.**>", AWN_APPLET_LICENSE_GPLV2, VERSION); gtk_menu_shell_append(GTK_MENU_SHELL(priv->context_menu), item); g_signal_connect(G_OBJECT(priv->context_menu), "deactivate", G_CALLBACK(_deactivate_event), icon); } if (!priv->autohide_cookie) { priv->autohide_cookie = awn_applet_inhibit_autohide (AWN_APPLET(priv->applet),"CairoMenu" ); } awn_icon_popup_gtk_menu (AWN_ICON (icon), priv->context_menu, event->button, event->time); g_object_set(awn_overlayable_get_effects (AWN_OVERLAYABLE(icon)), "depressed", FALSE,NULL); awn_utils_show_menu_images (GTK_MENU (priv->context_menu)); } else { return TRUE; } awn_icon_set_is_active (AWN_ICON(icon), TRUE); return TRUE; }
static void menu_popup(GtkWidget *menu, GdkEventButton * event, gpointer objtounref) { #if (GTK_MAJOR_VERSION != 2) || (GTK_MINOR_VERSION != 0) if (event && event->window) gtk_menu_set_screen(GTK_MENU(menu), gdk_drawable_get_screen(event->window)); #endif g_object_ref(menu); g_object_ref_sink(menu); g_object_unref(menu); g_signal_connect(G_OBJECT(menu), "selection-done", G_CALLBACK(menu_destroy), objtounref); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, event ? event->time : 0); }
GdkDragAction nautilus_drag_drop_background_ask (GtkWidget *widget, GdkDragAction actions) { GtkWidget *menu; GtkWidget *menu_item; DropActionMenuData damd; /* Create the menu and set the sensitivity of the items based on the * allowed actions. */ menu = gtk_menu_new (); gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (widget)); append_drop_action_menu_item (menu, _("Set as background for _all folders"), NAUTILUS_DND_ACTION_SET_AS_GLOBAL_BACKGROUND, (actions & NAUTILUS_DND_ACTION_SET_AS_GLOBAL_BACKGROUND) != 0, &damd); append_drop_action_menu_item (menu, _("Set as background for _this folder"), NAUTILUS_DND_ACTION_SET_AS_FOLDER_BACKGROUND, (actions & NAUTILUS_DND_ACTION_SET_AS_FOLDER_BACKGROUND) != 0, &damd); eel_gtk_menu_append_separator (GTK_MENU (menu)); menu_item = gtk_menu_item_new_with_mnemonic (_("Cancel")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item); gtk_widget_show (menu_item); damd.chosen = 0; damd.loop = g_main_loop_new (NULL, FALSE); g_signal_connect (menu, "deactivate", G_CALLBACK (menu_deactivate_callback), &damd); gtk_grab_add (menu); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME); g_main_loop_run (damd.loop); gtk_grab_remove (menu); g_main_loop_unref (damd.loop); gtk_object_sink (GTK_OBJECT (menu)); return damd.chosen; }
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 gimp_ui_manager_menu_position (GtkMenu *menu, gint *x, gint *y, gpointer data) { GdkScreen *screen; GtkRequisition requisition; GdkRectangle rect; gint monitor; gint pointer_x; gint pointer_y; g_return_if_fail (GTK_IS_MENU (menu)); g_return_if_fail (x != NULL); g_return_if_fail (y != NULL); g_return_if_fail (GTK_IS_WIDGET (data)); gdk_display_get_pointer (gtk_widget_get_display (GTK_WIDGET (data)), &screen, &pointer_x, &pointer_y, NULL); monitor = gdk_screen_get_monitor_at_point (screen, pointer_x, pointer_y); gdk_screen_get_monitor_geometry (screen, monitor, &rect); gtk_menu_set_screen (menu, screen); gtk_widget_size_request (GTK_WIDGET (menu), &requisition); if (gtk_widget_get_direction (GTK_WIDGET (menu)) == GTK_TEXT_DIR_RTL) { *x = pointer_x - 2 - requisition.width; if (*x < rect.x) *x = pointer_x + 2; } else { *x = pointer_x + 2; if (*x + requisition.width > rect.x + rect.width) *x = pointer_x - 2 - requisition.width; } *y = pointer_y + 2; if (*y + requisition.height > rect.y + rect.height) *y = pointer_y - 2 - requisition.height; if (*x < rect.x) *x = rect.x; if (*y < rect.y) *y = rect.y; }
static gboolean remap_popup_menu (GtkWidget *widget, GdkEventButton *event) { GtkWidget *menu = gtk_ui_manager_get_widget (remap_ui, "/remap-popup"); gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (widget)); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, event ? event->button : 0, event ? event->time : gtk_get_current_event_time ()); return TRUE; }
static void setup_menu_panel (GtkWidget *menu) { PanelWidget *panel; panel = g_object_get_data (G_OBJECT (menu), "menu_panel"); if (panel) return; panel = menu_get_panel (menu); g_object_set_data (G_OBJECT (menu), "menu_panel", panel); if (panel) gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (GTK_WIDGET (panel))); }
/** * gimp_menu_position: * @menu: a #GtkMenu widget * @x: pointer to horizontal position * @y: pointer to vertical position * * Positions a #GtkMenu so that it pops up on screen. This function * takes care of the preferred popup direction (taken from the widget * render direction) and it handles multiple monitors representing a * single #GdkScreen (Xinerama). * * You should call this function with @x and @y initialized to the * origin of the menu. This is typically the center of the widget the * menu is popped up from. gimp_menu_position() will then decide if * and how these initial values need to be changed. **/ void gimp_menu_position (GtkMenu *menu, gint *x, gint *y) { GtkWidget *widget; GdkScreen *screen; GtkRequisition requisition; GdkRectangle rect; gint monitor; g_return_if_fail (GTK_IS_MENU (menu)); g_return_if_fail (x != NULL); g_return_if_fail (y != NULL); widget = GTK_WIDGET (menu); screen = gtk_widget_get_screen (widget); monitor = gdk_screen_get_monitor_at_point (screen, *x, *y); gdk_screen_get_monitor_geometry (screen, monitor, &rect); gtk_menu_set_screen (menu, screen); gtk_widget_size_request (widget, &requisition); if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) { *x -= requisition.width; if (*x < rect.x) *x += requisition.width; } else { if (*x + requisition.width > rect.x + rect.width) *x -= requisition.width; } if (*x < rect.x) *x = rect.x; if (*y + requisition.height > rect.y + rect.height) *y -= requisition.height; if (*y < rect.y) *y = rect.y; }
static gboolean _button_clicked_event (GtkWidget *widget, GdkEventButton *event, WebApplet *webapplet) { static GtkWidget *menu=NULL; if (event->button == 1) { if (GTK_WIDGET_VISIBLE (webapplet->mainwindow)) { gtk_widget_hide (webapplet->mainwindow); } else { gtk_widget_show_all (webapplet->mainwindow); } } else if (event->button == 3) { if (!menu) { GtkWidget *item; menu = awn_applet_create_default_menu (webapplet->applet); gtk_menu_set_screen (GTK_MENU (menu), NULL); if (config_get_enable_location_dialog(webapplet)) { item = gtk_image_menu_item_new_with_label (_("Open Location")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show_all (item); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (_show_location_dialog), webapplet); } item = awn_applet_create_about_item_simple(webapplet->applet, "2008 Rodney Cryderman <*****@*****.**>\n" "2008 Mark Lee <*****@*****.**>\n", AWN_APPLET_LICENSE_GPLV2, NULL); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); } awn_applet_popup_gtk_menu (webapplet->applet, menu, event->button, event->time); } return TRUE; }
static gboolean _button_clicked_event (GtkWidget *widget, GdkEventButton *event, AwnApplet *applet) { static GtkWidget *menu=NULL; if (event->button == 3) { if (!menu) { menu = awn_applet_create_default_menu (applet); } gtk_menu_set_screen (GTK_MENU (menu), NULL); awn_applet_popup_gtk_menu (applet, menu, event->button, event->time); } return TRUE; }
static gboolean chanlist_button_cb (GtkTreeView *tree, GdkEventButton *event, server *serv) { GtkWidget *menu; GtkTreeSelection *sel; GtkTreePath *path; char *chan; if (event->button != 3) return FALSE; if (!gtk_tree_view_get_path_at_pos (tree, event->x, event->y, &path, 0, 0, 0)) return FALSE; /* select what they right-clicked on */ sel = gtk_tree_view_get_selection (tree); gtk_tree_selection_unselect_all (sel); gtk_tree_selection_select_path (sel, path); gtk_tree_path_free (path); menu = gtk_menu_new (); if (event->window) gtk_menu_set_screen (GTK_MENU (menu), gdk_drawable_get_screen (event->window)); g_object_ref (menu); g_object_ref_sink (menu); g_object_unref (menu); g_signal_connect (G_OBJECT (menu), "selection-done", G_CALLBACK (chanlist_menu_destroy), NULL); mg_create_icon_item (_("_Join Channel"), GTK_STOCK_JUMP_TO, menu, chanlist_join, serv); mg_create_icon_item (_("_Copy Channel Name"), GTK_STOCK_COPY, menu, chanlist_copychannel, serv); mg_create_icon_item (_("Copy _Topic Text"), GTK_STOCK_COPY, menu, chanlist_copytopic, serv); chan = chanlist_get_selected (serv, FALSE); menu_addfavoritemenu (serv, menu, chan); g_free (chan); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, event->time); return TRUE; }
/** * gnome_popup_menu_do_popup_modal: * @popup: A menu widget. * @pos_func: A user supplied function to position the menu or %NULL. * @pos_data: User supplied data to pass to @pos_func. * @event: A #GdkEventButton structure containing the event that triggered the * menu (or %NULL). * @user_data: Application specific data passed to the menu callback. * @for_widget: The widget for which the popup was triggered. * * Same as gnome_popup_do_modal(), but runs the popup menu modally. * * Returns: The index of the selected item or -1 if no item selected. */ int gnome_popup_menu_do_popup_modal (GtkWidget *popup, GtkMenuPositionFunc pos_func, gpointer pos_data, GdkEventButton *event, gpointer user_data, GtkWidget *for_widget) { guint id; guint button; guint32 timestamp; g_return_val_if_fail (popup != NULL, -1); g_return_val_if_fail (GTK_IS_WIDGET (popup), -1); /* Connect to the deactivation signal to be able to quit our modal main loop */ id = g_signal_connect (popup, "deactivate", G_CALLBACK (menu_shell_deactivated), NULL); g_object_set_data (G_OBJECT (popup), "gnome_popup_menu_active_item", NULL); g_object_set_data (G_OBJECT (popup), "gnome_popup_menu_do_popup_user_data", user_data); g_object_set_data (G_OBJECT (popup), "gnome_popup_menu_do_popup_for_widget", for_widget); if (event) { button = event->button; timestamp = event->time; } else { button = 0; timestamp = GDK_CURRENT_TIME; } #ifdef HAVE_GTK_MULTIHEAD gtk_menu_set_screen (GTK_MENU (popup), gtk_widget_get_screen (for_widget)); #endif gtk_menu_popup (GTK_MENU (popup), NULL, NULL, pos_func, pos_data, button, timestamp); gtk_grab_add (popup); gtk_main (); gtk_grab_remove (popup); g_signal_handler_disconnect (G_OBJECT (popup), id); return get_active_index (GTK_MENU (popup)); }
static gboolean view_popup_menu (GtkWidget *widget, GdkEventButton *event) { GtkWidget *menu; const gchar *path; if (webkit_web_view_can_copy_clipboard (WEBKIT_WEB_VIEW (view))) path = "/help-browser-copy-popup"; else path = "/help-browser-popup"; menu = gtk_ui_manager_get_widget (ui_manager, path); gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (widget)); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, event ? event->button : 0, event ? event->time : gtk_get_current_event_time ()); return TRUE; }
static GtkWidget * menu_workspace (Menu * menu, MenuOp insensitive, gint ws, gint nws, gchar **wsn, gint wsn_items) { GtkWidget *menu_widget; GtkWidget *menuitem; MenuData *menudata; gchar *name; gint i; menu_widget = gtk_menu_new (); gtk_menu_set_screen (GTK_MENU (menu->menu), menu->screen); for (i = 0; i < nws; i++) { if ((i < wsn_items) && wsn[i]) { name = g_strdup_printf ("%i (%s)", i+ 1, wsn[i]); } else { name = g_strdup_printf ("%i", i + 1); } menuitem = gtk_menu_item_new_with_label (name); g_free (name); gtk_widget_set_sensitive (menuitem, !(insensitive & MENU_OP_WORKSPACES) && (i != ws)); gtk_widget_show (menuitem); menudata = g_new (MenuData, 1); menudata->menu = menu; menudata->op = MENU_OP_WORKSPACES; menudata->data = GINT_TO_POINTER (i); menu_item_connect (menuitem, menudata); gtk_menu_shell_append (GTK_MENU_SHELL (menu_widget), menuitem); } return (menu_widget); }
static gboolean gimp_color_button_button_press (GtkWidget *widget, GdkEventButton *bevent) { GimpColorButton *button = GIMP_COLOR_BUTTON (widget); if (gdk_event_triggers_context_menu ((GdkEvent *) bevent)) { GtkWidget *menu = gtk_ui_manager_get_widget (button->popup_menu, "/color-button-popup"); gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (widget)); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, bevent->button, bevent->time); } if (GTK_WIDGET_CLASS (parent_class)->button_press_event) return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, bevent); return FALSE; }
gboolean matecomponent_control_do_popup_path (MateComponentControl *control, GtkWidget *parent_menu_shell, GtkWidget *parent_menu_item, GtkMenuPositionFunc func, gpointer data, guint button, const char *popup_path, guint32 activate_time) { GtkWidget *menu; g_return_val_if_fail (MATECOMPONENT_IS_CONTROL (control), FALSE); if (!control->priv->popup_ui_container) return FALSE; menu = gtk_menu_new (); matecomponent_ui_sync_menu_add_popup ( MATECOMPONENT_UI_SYNC_MENU (control->priv->popup_ui_sync), GTK_MENU (menu), popup_path); gtk_menu_set_screen ( GTK_MENU (menu), gtk_window_get_screen (GTK_WINDOW (control->priv->plug))); gtk_widget_show (menu); gtk_menu_popup (GTK_MENU (menu), parent_menu_shell, parent_menu_item, func, data, button, activate_time); return TRUE; }
/** * gnumeric_popup_menu : * @menu : #GtkMenu * @event : #GdkEventButton optionally NULL * * Bring up a popup and if @event is non-NULL ensure that the popup is on the * right screen. **/ void gnumeric_popup_menu (GtkMenu *menu, GdkEventButton *event) { g_return_if_fail (menu != NULL); g_return_if_fail (GTK_IS_MENU (menu)); g_object_ref_sink (menu); if (event) gtk_menu_set_screen (menu, gdk_drawable_get_screen (event->window)); g_signal_connect (G_OBJECT (menu), "hide", G_CALLBACK (kill_popup_menu), menu); /* Do NOT pass the button used to create the menu. * instead pass 0. Otherwise bringing up a menu with * the right button will disable clicking on the menu with the left. */ gtk_menu_popup (menu, NULL, NULL, NULL, NULL, 0, (event != NULL) ? event->time : gtk_get_current_event_time()); }
LOCAL_SYMBOL MetaWindowMenu* meta_window_menu_new (MetaFrames *frames, MetaMenuOp ops, MetaMenuOp insensitive, Window client_xwindow, unsigned long active_workspace, int n_workspaces, MetaWindowMenuFunc func, gpointer data) { int i; MetaWindowMenu *menu; /* FIXME: Modifications to 'ops' should happen in meta_window_show_menu */ if (n_workspaces < 2) ops &= ~(META_MENU_OP_STICK | META_MENU_OP_UNSTICK | META_MENU_OP_WORKSPACES); menu = g_new (MetaWindowMenu, 1); menu->frames = frames; menu->client_xwindow = client_xwindow; menu->func = func; menu->data = data; menu->ops = ops; menu->insensitive = insensitive; menu->menu = gtk_menu_new (); gtk_menu_set_screen (GTK_MENU (menu->menu), gtk_widget_get_screen (GTK_WIDGET (frames))); for (i = 0; i < (int) G_N_ELEMENTS (menuitems); i++) { MenuItem menuitem = menuitems[i]; if (ops & menuitem.op || menuitem.op == 0) { GtkWidget *mi; MenuData *md; unsigned int key; MetaVirtualModifier mods; mi = menu_item_new (&menuitem, -1); /* Set the activeness of radiobuttons. */ switch (menuitem.op) { case META_MENU_OP_STICK: gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), active_workspace == 0xFFFFFFFF); break; case META_MENU_OP_UNSTICK: gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), active_workspace != 0xFFFFFFFF); break; default: break; } if (menuitem.type == MENU_ITEM_WORKSPACE_LIST) { if (ops & META_MENU_OP_WORKSPACES) { Display *display; Window xroot; GdkScreen *screen; GdkWindow *window; GtkWidget *submenu; int j; MenuItem to_another_workspace = { 0, MENU_ITEM_NORMAL, NULL, FALSE, N_("Move to Another _Workspace") }; meta_verbose ("Creating %d-workspace menu current space %lu\n", n_workspaces, active_workspace); window = gtk_widget_get_window (GTK_WIDGET (frames)); display = GDK_WINDOW_XDISPLAY (window); screen = gdk_window_get_screen (window); xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen)); submenu = gtk_menu_new (); g_assert (mi==NULL); mi = menu_item_new (&to_another_workspace, -1); gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), submenu); for (j = 0; j < n_workspaces; j++) { char *label; MenuData *md; unsigned int key; MetaVirtualModifier mods; MenuItem moveitem; GtkWidget *submi; meta_core_get_menu_accelerator (META_MENU_OP_WORKSPACES, j + 1, &key, &mods); label = get_workspace_name_with_accel (display, xroot, j); moveitem.type = MENU_ITEM_NORMAL; moveitem.op = META_MENU_OP_WORKSPACES; moveitem.label = label; submi = menu_item_new (&moveitem, j + 1); g_free (label); if ((active_workspace == (unsigned)j) && (ops & META_MENU_OP_UNSTICK)) gtk_widget_set_sensitive (submi, FALSE); md = g_new (MenuData, 1); md->menu = menu; md->op = META_MENU_OP_WORKSPACES; g_object_set_data (G_OBJECT (submi), "workspace", GINT_TO_POINTER (j)); g_signal_connect_data (G_OBJECT (submi), "activate", G_CALLBACK (activate_cb), md, (GClosureNotify) g_free, 0); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), submi); gtk_widget_show (submi); } } else meta_verbose ("not creating workspace menu\n"); } else if (menuitem.type != MENU_ITEM_SEPARATOR) { meta_core_get_menu_accelerator (menuitems[i].op, -1, &key, &mods); if (insensitive & menuitem.op) gtk_widget_set_sensitive (mi, FALSE); md = g_new (MenuData, 1); md->menu = menu; md->op = menuitem.op; g_signal_connect_data (G_OBJECT (mi), "activate", G_CALLBACK (activate_cb), md, (GClosureNotify) g_free, 0); } if (mi) { gtk_menu_shell_append (GTK_MENU_SHELL (menu->menu), mi); gtk_widget_show (mi); } } } g_signal_connect (menu->menu, "selection_done", G_CALLBACK (menu_closed), menu); return menu; }
void action_menu_map (WnckWindow *win, long button, Time time) { GdkDisplay *gdkdisplay; GdkScreen *screen; gdkdisplay = gdk_display_get_default (); screen = gdk_display_get_default_screen (gdkdisplay); if (action_menu) { if (action_menu_mapped) { gtk_widget_destroy (action_menu); action_menu_mapped = FALSE; action_menu = NULL; return; } else gtk_widget_destroy (action_menu); } switch (wnck_window_get_window_type (win)) { case WNCK_WINDOW_DESKTOP: case WNCK_WINDOW_DOCK: /* don't allow window action */ return; case WNCK_WINDOW_NORMAL: case WNCK_WINDOW_DIALOG: #ifndef HAVE_LIBWNCK_2_19_4 case WNCK_WINDOW_MODAL_DIALOG: #endif case WNCK_WINDOW_TOOLBAR: case WNCK_WINDOW_MENU: case WNCK_WINDOW_UTILITY: case WNCK_WINDOW_SPLASHSCREEN: /* allow window action menu */ break; } action_menu = wnck_create_window_action_menu (win); gtk_menu_set_screen (GTK_MENU (action_menu), screen); g_signal_connect_object (G_OBJECT (action_menu), "unmap", G_CALLBACK (action_menu_unmap), 0, 0); gtk_widget_show (action_menu); if (!button || button == 1) { gtk_menu_popup (GTK_MENU (action_menu), NULL, NULL, position_action_menu, (gpointer) win, button, time); } else { gtk_menu_popup (GTK_MENU (action_menu), NULL, NULL, NULL, NULL, button, time); } action_menu_mapped = TRUE; }
static VALUE rg_set_screen(VALUE self, VALUE screen) { gtk_menu_set_screen(_SELF(self), GDK_SCREEN(RVAL2GOBJ(screen))); return self; }