static gboolean on_button_release(G_GNUC_UNUSED GtkWidget * widget, GdkEventButton * event, G_GNUC_UNUSED gpointer user_data) { if (event->button == 3) { GtkTreeSelection *treesel; GtkTreeModel *model; GtkTreeIter iter; treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(s_file_view)); if (!gtk_tree_selection_get_selected(treesel, &model, &iter)) return FALSE; gtk_widget_set_sensitive(s_popup_menu.expand, gtk_tree_model_iter_has_child(model, &iter)); gtk_widget_set_sensitive(s_popup_menu.remove_external_dir, topmost_selected(model, &iter, FALSE)); gtk_menu_popup(GTK_MENU(s_popup_menu.widget), NULL, NULL, NULL, NULL, event->button, event->time); return TRUE; } return FALSE; }
/* Keep track of the last menu item selected. (For the purposes * of the option menu */ int clip_GTK_MENUGETACTIVE(ClipMachine * ClipMachineMemory) { C_widget *cmnu = _fetch_cw_arg(ClipMachineMemory); GtkWidget *item; C_widget *citem; CHECKCWID(cmnu, GTK_IS_MENU); item = gtk_menu_get_active(GTK_MENU(cmnu->widget)); citem = _list_get_cwidget(ClipMachineMemory, item); if (!citem) citem = _register_widget(ClipMachineMemory, item, NULL); if (citem) { ClipVar *ret = RETPTR(ClipMachineMemory); _clip_mclone(ClipMachineMemory, ret, &citem->obj); } return 0; err: return 1; }
void panel_menu_button_set_menu_path (PanelMenuButton *button, const char *menu_uri) { const char *menu_path; char *scheme; g_return_if_fail (PANEL_IS_MENU_BUTTON (button)); scheme = NULL; menu_path = split_menu_uri (menu_uri, &scheme); if (!scheme) return; button->priv->path_root = panel_menu_scheme_to_path_root (scheme); g_free (scheme); if (!button->priv->menu_path && (!menu_path || !menu_path [0])) return; if (button->priv->menu_path && menu_path && !strcmp (button->priv->menu_path, menu_path)) return; g_free (button->priv->menu_path); button->priv->menu_path = NULL; button->priv->menu_path = g_strdup (menu_path); if (button->priv->menu) gtk_menu_detach (GTK_MENU (button->priv->menu)); button->priv->menu = NULL; panel_menu_button_set_icon (button); }
void wxFrame::AttachMenuBar( wxMenuBar *menuBar ) { wxFrameBase::AttachMenuBar(menuBar); if (m_frameMenuBar) { #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 hildon_window_set_menu(HILDON_WINDOW(m_widget), GTK_MENU(m_frameMenuBar->m_menubar)); #else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2 m_frameMenuBar->SetParent(this); // menubar goes into top of vbox (m_mainWidget) gtk_box_pack_start( GTK_BOX(m_mainWidget), menuBar->m_widget, false, false, 0); gtk_box_reorder_child(GTK_BOX(m_mainWidget), menuBar->m_widget, 0); // disconnect wxWindowGTK "size_request" handler, // it interferes with sizing of detached GtkHandleBox gulong handler_id = g_signal_handler_find( menuBar->m_widget, GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA), g_signal_lookup("size_request", GTK_TYPE_WIDGET), 0, NULL, NULL, menuBar); if (handler_id != 0) g_signal_handler_disconnect(menuBar->m_widget, handler_id); // reset size request to allow native sizing to work gtk_widget_set_size_request(menuBar->m_widget, -1, -1); gtk_widget_show( m_frameMenuBar->m_widget ); #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2 } // make sure next size_allocate causes a wxSizeEvent m_oldClientWidth = 0; }
void glade_popup_simple_pop (GladeProject *project, GdkEventButton *event) { GtkWidget *popup_menu; gint button; gint event_time; popup_menu = glade_popup_create_menu (NULL, NULL, project, FALSE); if (!popup_menu) return; if (event) { button = event->button; event_time = event->time; } else { button = 0; event_time = gtk_get_current_event_time (); } gtk_menu_popup (GTK_MENU (popup_menu), NULL, NULL, NULL, NULL, button, event_time); }
void on_trayicon_menu (GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data) { GromitData *data = (GromitData *) user_data; if(data->debug) g_printerr("DEBUG: trayicon menu popup\n"); /* create the menu */ GtkWidget *menu = gtk_menu_new (); /* Create the menu items */ //TODO option menu GtkWidget* sep_item = gtk_separator_menu_item_new(); GtkWidget* quit_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL); /* Add them to the menu */ gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep_item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), quit_item); /* Attach the callback functions to the respective activate signal */ g_signal_connect(G_OBJECT (quit_item), "activate", G_CALLBACK (gtk_main_quit), NULL); /* We do need to show menu items */ gtk_widget_show (sep_item); gtk_widget_show (quit_item); /* show menu */ gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time()); }
static gboolean select_verse_button_press_callback(GtkWidget *widget, GdkEventButton *event, EDITOR *editor) { GtkWidget *menu; menu = main_versekey_drop_down_verse_menu(editor->navbar, NB_EDITOR, NULL, editor); if (!menu) return 0; g_signal_connect(menu, "deactivate", G_CALLBACK(menu_deactivate_callback), widget); if ((event->type == GDK_BUTTON_PRESS) && event->button == 1) { gtk_widget_grab_focus(widget); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, menu_position_under, widget, event->button, event->time); return TRUE; } return FALSE; }
static GtkWidget *bmark_popup_menu(Tbfwin * bfwin, gboolean show_bmark_specific, gboolean show_file_specific) { GtkWidget *menu, *menu_item; menu = gtk_menu_new(); if (show_bmark_specific) { menu_item = gtk_menu_item_new_with_label(_("Goto bookmark")); g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_goto_lcb), bfwin); gtk_menu_append(GTK_MENU(menu), menu_item); menu_item = gtk_separator_menu_item_new(); gtk_menu_append(GTK_MENU(menu), menu_item); menu_item = gtk_menu_item_new_with_label(_("Edit")); g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_rename_lcb), bfwin); gtk_menu_append(GTK_MENU(menu), menu_item); menu_item = gtk_menu_item_new_with_label(_("Delete")); g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_del_lcb), bfwin); gtk_menu_append(GTK_MENU(menu), menu_item); } if (show_file_specific) { menu_item = gtk_menu_item_new_with_label(_("Delete all in document")); g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_deldoc_lcb), bfwin); gtk_menu_append(GTK_MENU(menu), menu_item); } menu_item = gtk_menu_item_new_with_label(_("Delete all")); g_signal_connect(GTK_OBJECT(menu_item), "activate", G_CALLBACK(bmark_popup_menu_delall_lcb), bfwin); gtk_menu_append(GTK_MENU(menu), menu_item); gtk_widget_show_all(menu); g_signal_connect_after(G_OBJECT(menu), "destroy", G_CALLBACK(destroy_disposable_menu_cb), menu); return menu; }
void ptt_menu_show(GtkWidget *button) { ptt_menu_clear(); ptt_menu_update(); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, 0); }
static gboolean _on_click_item (GtkWidget *pWidget, GdkEventButton* pButton, CDQuickBrowserItem *pItem) { g_return_val_if_fail (pItem != NULL, FALSE); GldiModuleInstance *myApplet = pItem->pApplet; CD_APPLET_ENTER; if (pButton->button == 3) // right click { gchar *cUri = g_filename_to_uri (pItem->cPath, NULL, NULL); g_return_val_if_fail (cUri != NULL, FALSE); GtkWidget *pMenu = gldi_menu_new (NULL); GList *pApps = cairo_dock_fm_list_apps_for_file (cUri); if (pApps != NULL) { GtkWidget *pSubMenu = CD_APPLET_ADD_SUB_MENU_WITH_IMAGE (D_("Open with"), pMenu, GLDI_ICON_NAME_OPEN); cd_quick_browser_free_apps_list (myApplet); GList *a; gchar **pAppInfo; gchar *cIconPath; for (a = pApps; a != NULL; a = a->next) { pAppInfo = a->data; if (pAppInfo[2] != NULL) cIconPath = cairo_dock_search_icon_s_path (pAppInfo[2], cairo_dock_search_icon_size (GTK_ICON_SIZE_MENU)); else cIconPath = NULL; gpointer *data = g_new (gpointer, 2); data[0] = pItem; data[1] = pAppInfo[1]; myData.pAppList = g_list_prepend (myData.pAppList, data); // to save the exec command CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (pAppInfo[0], cIconPath, _cd_launch_with, pSubMenu, data); g_free (cIconPath); g_free (pAppInfo[0]); g_free (pAppInfo[2]); g_free (pAppInfo); } g_list_free (pApps); } CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (D_("Open parent folder"), GLDI_ICON_NAME_DIRECTORY, _cd_open_parent, pMenu, pItem); CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (D_("Copy the location"), GLDI_ICON_NAME_COPY, _cd_copy_location, pMenu, pItem); gtk_widget_show_all (pMenu); gtk_menu_popup (GTK_MENU (pMenu), NULL, NULL, NULL, // popup on mouse. NULL, 1, gtk_get_current_event_time ()); g_free (cUri); CD_APPLET_LEAVE (TRUE); // do not remove quick_browser menu now } CD_APPLET_LEAVE (FALSE); }
nsSystemFontsGTK2::nsSystemFontsGTK2() : mDefaultFontName(NS_LITERAL_STRING("sans-serif")) , mButtonFontName(NS_LITERAL_STRING("sans-serif")) , mFieldFontName(NS_LITERAL_STRING("sans-serif")) , mMenuFontName(NS_LITERAL_STRING("sans-serif")) { InitPangoLib(); /* * Much of the widget creation code here is similar to the code in * nsLookAndFeel::InitColors(). */ // mDefaultFont GtkWidget *label = gtk_label_new("M"); GtkWidget *parent = gtk_fixed_new(); GtkWidget *window = gtk_window_new(GTK_WINDOW_POPUP); gtk_container_add(GTK_CONTAINER(parent), label); gtk_container_add(GTK_CONTAINER(window), parent); gtk_widget_ensure_style(label); GetSystemFontInfo(label, &mDefaultFontName, &mDefaultFontStyle); gtk_widget_destroy(window); // no unref, windows are different // mFieldFont GtkWidget *entry = gtk_entry_new(); parent = gtk_fixed_new(); window = gtk_window_new(GTK_WINDOW_POPUP); gtk_container_add(GTK_CONTAINER(parent), entry); gtk_container_add(GTK_CONTAINER(window), parent); gtk_widget_ensure_style(entry); GetSystemFontInfo(entry, &mFieldFontName, &mFieldFontStyle); gtk_widget_destroy(window); // no unref, windows are different // mMenuFont GtkWidget *accel_label = gtk_accel_label_new("M"); GtkWidget *menuitem = gtk_menu_item_new(); GtkWidget *menu = gtk_menu_new(); g_object_ref_sink(GTK_OBJECT(menu)); gtk_container_add(GTK_CONTAINER(menuitem), accel_label); gtk_menu_shell_append((GtkMenuShell *)GTK_MENU(menu), menuitem); gtk_widget_ensure_style(accel_label); GetSystemFontInfo(accel_label, &mMenuFontName, &mMenuFontStyle); g_object_unref(menu); // mButtonFont parent = gtk_fixed_new(); GtkWidget *button = gtk_button_new(); label = gtk_label_new("M"); window = gtk_window_new(GTK_WINDOW_POPUP); gtk_container_add(GTK_CONTAINER(button), label); gtk_container_add(GTK_CONTAINER(parent), button); gtk_container_add(GTK_CONTAINER(window), parent); gtk_widget_ensure_style(label); GetSystemFontInfo(label, &mButtonFontName, &mButtonFontStyle); gtk_widget_destroy(window); // no unref, windows are different }
void create_range_controls( void ) { GtkWidget *window; GtkWidget *box1, *box2, *box3; GtkWidget *button; GtkWidget *scrollbar; GtkWidget *separator; GtkWidget *opt, *menu, *item; GtkWidget *label; GtkWidget *scale; GtkObject *adj1, *adj2; /* Standard window-creating stuff */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC(gtk_main_quit), NULL); gtk_window_set_title (GTK_WINDOW (window), "range controls"); box1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), box1); gtk_widget_show (box1); box2 = gtk_hbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); /* value, lower, upper, step_increment, page_increment, page_size */ /* Note that the page_size value only makes a difference for * scrollbar widgets, and the highest value you'll get is actually * (upper - page_size). */ adj1 = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0); vscale = gtk_vscale_new (GTK_ADJUSTMENT (adj1)); scale_set_default_values (GTK_SCALE (vscale)); gtk_box_pack_start (GTK_BOX (box2), vscale, TRUE, TRUE, 0); gtk_widget_show (vscale); box3 = gtk_vbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (box2), box3, TRUE, TRUE, 0); gtk_widget_show (box3); /* Reuse the same adjustment */ hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj1)); gtk_widget_set_usize (GTK_WIDGET (hscale), 200, 30); scale_set_default_values (GTK_SCALE (hscale)); gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0); gtk_widget_show (hscale); /* Reuse the same adjustment again */ scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adj1)); /* Notice how this causes the scales to always be updated * continuously when the scrollbar is moved */ gtk_range_set_update_policy (GTK_RANGE (scrollbar), GTK_UPDATE_CONTINUOUS); gtk_box_pack_start (GTK_BOX (box3), scrollbar, TRUE, TRUE, 0); gtk_widget_show (scrollbar); box2 = gtk_hbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); /* A checkbutton to control whether the value is displayed or not */ button = gtk_check_button_new_with_label("Display value on scale widgets"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC(cb_draw_value), NULL); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); box2 = gtk_hbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); /* An option menu to change the position of the value */ label = gtk_label_new ("Scale Value Position:"); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); gtk_widget_show (label); opt = gtk_option_menu_new(); menu = gtk_menu_new(); item = make_menu_item ("Top", GTK_SIGNAL_FUNC(cb_pos_menu_select), GINT_TO_POINTER (GTK_POS_TOP)); gtk_menu_append (GTK_MENU (menu), item); item = make_menu_item ("Bottom", GTK_SIGNAL_FUNC (cb_pos_menu_select), GINT_TO_POINTER (GTK_POS_BOTTOM)); gtk_menu_append (GTK_MENU (menu), item); item = make_menu_item ("Left", GTK_SIGNAL_FUNC (cb_pos_menu_select), GINT_TO_POINTER (GTK_POS_LEFT)); gtk_menu_append (GTK_MENU (menu), item); item = make_menu_item ("Right", GTK_SIGNAL_FUNC (cb_pos_menu_select), GINT_TO_POINTER (GTK_POS_RIGHT)); gtk_menu_append (GTK_MENU (menu), item); gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu); gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0); gtk_widget_show (opt); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); box2 = gtk_hbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); /* Yet another option menu, this time for the update policy of the * scale widgets */ label = gtk_label_new ("Scale Update Policy:"); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); gtk_widget_show (label); opt = gtk_option_menu_new(); menu = gtk_menu_new(); item = make_menu_item ("Continuous", GTK_SIGNAL_FUNC (cb_update_menu_select), GINT_TO_POINTER (GTK_UPDATE_CONTINUOUS)); gtk_menu_append (GTK_MENU (menu), item); item = make_menu_item ("Discontinuous", GTK_SIGNAL_FUNC (cb_update_menu_select), GINT_TO_POINTER (GTK_UPDATE_DISCONTINUOUS)); gtk_menu_append (GTK_MENU (menu), item); item = make_menu_item ("Delayed", GTK_SIGNAL_FUNC (cb_update_menu_select), GINT_TO_POINTER (GTK_UPDATE_DELAYED)); gtk_menu_append (GTK_MENU (menu), item); gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu); gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0); gtk_widget_show (opt); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); box2 = gtk_hbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); /* An HScale widget for adjusting the number of digits on the * sample scales. */ label = gtk_label_new ("Scale Digits:"); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); gtk_widget_show (label); adj2 = gtk_adjustment_new (1.0, 0.0, 5.0, 1.0, 1.0, 0.0); gtk_signal_connect (GTK_OBJECT (adj2), "value_changed", GTK_SIGNAL_FUNC (cb_digits_scale), NULL); scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2)); gtk_scale_set_digits (GTK_SCALE (scale), 0); gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0); gtk_widget_show (scale); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); box2 = gtk_hbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); /* And, one last HScale widget for adjusting the page size of the * scrollbar. */ label = gtk_label_new ("Scrollbar Page Size:"); gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0); gtk_widget_show (label); adj2 = gtk_adjustment_new (1.0, 1.0, 101.0, 1.0, 1.0, 0.0); gtk_signal_connect (GTK_OBJECT (adj2), "value_changed", GTK_SIGNAL_FUNC (cb_page_size), adj1); scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2)); gtk_scale_set_digits (GTK_SCALE (scale), 0); gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0); gtk_widget_show (scale); gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0); gtk_widget_show (box2); separator = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0); gtk_widget_show (separator); box2 = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0); gtk_widget_show (box2); button = gtk_button_new_with_label ("Quit"); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_main_quit), NULL); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_widget_show (button); gtk_widget_show (window); }
void tray_icon_on_menu(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data) { gtk_menu_popup(GTK_MENU(menu), NULL, NULL, gtk_status_icon_position_menu, status_icon, button, activate_time); }
void PopupMenu::show(const IntRect& rect, FrameView* view, int index) { ASSERT(client()); if (!m_popup) { m_popup = GTK_MENU(gtk_menu_new()); #if GLIB_CHECK_VERSION(2,10,0) g_object_ref_sink(G_OBJECT(m_popup)); #else g_object_ref(G_OBJECT(m_popup)); gtk_object_sink(GTK_OBJECT(m_popup)); #endif g_signal_connect(m_popup, "unmap", G_CALLBACK(menuUnmapped), this); } else gtk_container_foreach(GTK_CONTAINER(m_popup), reinterpret_cast<GtkCallback>(menuRemoveItem), this); int x, y; gdk_window_get_origin(GTK_WIDGET(view->containingWindow())->window, &x, &y); m_menuPosition = view->contentsToWindow(rect.location()); m_menuPosition = IntPoint(m_menuPosition.x() + x, m_menuPosition.y() + y + rect.height()); m_indexMap.clear(); const int size = client()->listSize(); for (int i = 0; i < size; ++i) { GtkWidget* item; if (client()->itemIsSeparator(i)) item = gtk_separator_menu_item_new(); else item = gtk_menu_item_new_with_label(client()->itemText(i).utf8().data()); m_indexMap.add(item, i); g_signal_connect(item, "activate", G_CALLBACK(menuItemActivated), this); // FIXME: Apply the RenderStyle from client()->itemStyle(i) gtk_widget_set_sensitive(item, client()->itemIsEnabled(i)); gtk_menu_shell_append(GTK_MENU_SHELL(m_popup), item); gtk_widget_show(item); } gtk_menu_set_active(m_popup, index); // The size calls are directly copied from gtkcombobox.c which is LGPL GtkRequisition requisition; gtk_widget_set_size_request(GTK_WIDGET(m_popup), -1, -1); gtk_widget_size_request(GTK_WIDGET(m_popup), &requisition); gtk_widget_set_size_request(GTK_WIDGET(m_popup), MAX(rect.width(), requisition.width), -1); GList* children = GTK_MENU_SHELL(m_popup)->children; if (size) for (int i = 0; i < size; i++) { if (i > index) break; GtkWidget* item = reinterpret_cast<GtkWidget*>(children->data); GtkRequisition itemRequisition; gtk_widget_get_child_requisition(item, &itemRequisition); m_menuPosition.setY(m_menuPosition.y() - itemRequisition.height); children = g_list_next(children); } else // Center vertically the empty popup in the combo box area m_menuPosition.setY(m_menuPosition.y() - rect.height() / 2); gtk_menu_popup(m_popup, NULL, NULL, reinterpret_cast<GtkMenuPositionFunc>(menuPositionFunction), this, 0, gtk_get_current_event_time()); }
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; }
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; }
/** * @brief Instance initializer function for the \e GtkExperimentTranscript widget * * @param klass Newly constructed \e GtkExperimentTranscript instance */ static void gtk_experiment_transcript_init(GtkExperimentTranscript *klass) { GtkWidget *item, *submenu, *image; klass->priv = GTK_EXPERIMENT_TRANSCRIPT_GET_PRIVATE(klass); klass->speaker = NULL; klass->interactive_format.default_font = NULL; klass->interactive_format.default_text_color = NULL; klass->interactive_format.default_bg_color = NULL; klass->priv->flag_mask = 0; klass->priv->time_adjustment = gtk_adjustment_new(0., 0., 0., 0., 0., 0.); g_object_ref_sink(klass->priv->time_adjustment); klass->priv->time_adj_on_value_changed_id = g_signal_connect(G_OBJECT(klass->priv->time_adjustment), "value-changed", G_CALLBACK(time_adj_on_value_changed), klass); klass->priv->layer_text = NULL; klass->priv->layer_text_layout = gtk_widget_create_pango_layout(GTK_WIDGET(klass), NULL); pango_layout_set_wrap(klass->priv->layer_text_layout, PANGO_WRAP_WORD_CHAR); pango_layout_set_ellipsize(klass->priv->layer_text_layout, PANGO_ELLIPSIZE_END); klass->priv->backdrop.start = 0; klass->priv->backdrop.end = 0; klass->priv->contribs = NULL; klass->priv->formats = NULL; klass->priv->interactive_format.regexp = NULL; klass->priv->interactive_format.attribs = NULL; /** @todo It should be possible to reset font and colors (to widget defaults) */ klass->priv->menu = gtk_menu_new(); gtk_menu_attach_to_widget(GTK_MENU(klass->priv->menu), GTK_WIDGET(klass), NULL); item = gtk_image_menu_item_new_with_mnemonic("Choose _Font..."); image = gtk_image_new_from_stock(GTK_STOCK_SELECT_FONT, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image); g_signal_connect(item, "activate", G_CALLBACK(choose_font_activated), klass); gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item); gtk_widget_show(item); item = gtk_image_menu_item_new_with_mnemonic("Choose _Text Color..."); image = gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image); g_signal_connect(item, "activate", G_CALLBACK(choose_text_color_activated), klass); gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item); gtk_widget_show(item); item = gtk_image_menu_item_new_with_mnemonic("Choose _Background Color..."); image = gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image); g_signal_connect(item, "activate", G_CALLBACK(choose_bg_color_activated), klass); gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item); gtk_widget_show(item); submenu = gtk_menu_new(); item = gtk_menu_item_new_with_label("Text Alignment"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu); gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item); gtk_widget_show(item); /* * position in alignment_group list corresponds with PangoAlignment * (PANGO_ALIGN_RIGHT, PANGO_ALIGN_CENTER, PANGO_ALIGN_LEFT) */ item = gtk_radio_menu_item_new_with_mnemonic(NULL, "_Left"); klass->priv->alignment_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); g_signal_connect(item, "activate", G_CALLBACK(text_alignment_activated), klass); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item); item = gtk_radio_menu_item_new_with_mnemonic(klass->priv->alignment_group, "_Center"); klass->priv->alignment_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); g_signal_connect(item, "activate", G_CALLBACK(text_alignment_activated), klass); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item); item = gtk_radio_menu_item_new_with_mnemonic(klass->priv->alignment_group, "_Right"); klass->priv->alignment_group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); g_signal_connect(item, "activate", G_CALLBACK(text_alignment_activated), klass); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item); gtk_widget_show_all(submenu); gtk_experiment_transcript_set_alignment(klass, PANGO_ALIGN_LEFT); item = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item); gtk_widget_show(item); klass->priv->menu_reverse_item = gtk_check_menu_item_new_with_mnemonic("_Reverse"); g_signal_connect(klass->priv->menu_reverse_item, "activate", G_CALLBACK(reverse_activated), klass); gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), klass->priv->menu_reverse_item); gtk_widget_show(klass->priv->menu_reverse_item); gtk_widget_set_can_focus(GTK_WIDGET(klass), TRUE); }
static void refill_submenu_viewport (WnckActionMenu *menu) { GtkWidget *submenu; GList *children; GList *l; WnckScreen *screen; WnckWorkspace *workspace; int window_x, window_y; int viewport_x, viewport_y; int viewport_width, viewport_height; int screen_width, screen_height; int x, y; int number; submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu->priv->workspace_item)); /* Remove existing items */ children = gtk_container_get_children (GTK_CONTAINER (submenu)); for (l = children; l; l = l->next) gtk_container_remove (GTK_CONTAINER (submenu), l->data); g_list_free (children); screen = wnck_window_get_screen (menu->priv->window); workspace = wnck_screen_get_workspace (screen, 0); wnck_window_get_geometry (menu->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); number = 1; for (y = 0; y < viewport_height; y += screen_height) { char *label; GtkWidget *item; for (x = 0; x < viewport_width; x += screen_width) { /* Keep this in sync with what is in get_workspace_name_with_accel() */ if (number == 10) label = g_strdup_printf (_("Workspace 1_0")); else label = g_strdup_printf (_("Workspace %s%d"), number < 10 ? "_" : "", number); number++; item = make_menu_item (MOVE_TO_WORKSPACE); g_object_set_data (G_OBJECT (item), "viewport_x", GINT_TO_POINTER (x)); g_object_set_data (G_OBJECT (item), "viewport_y", GINT_TO_POINTER (y)); if (window_x >= x && window_x < x + screen_width && window_y >= y && window_y < y + screen_height) gtk_widget_set_sensitive (item, FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); set_item_text (item, label); set_item_stock (item, NULL); g_free (label); } } gtk_menu_reposition (GTK_MENU (submenu)); }
void tray_icon_on_click(GtkStatusIcon *status_icon, gpointer user_data) { gtk_menu_popup(GTK_MENU(menu), NULL, NULL, gtk_status_icon_position_menu, status_icon, 0, gtk_get_current_event_time()); }
void WebPopupMenuProxyGtk::hidePopupMenu() { gtk_menu_popdown(GTK_MENU(m_popup)); resetTypeAheadFindState(); }
static gint button_press_map_cb(GtkWidget * area, GdkEventButton * event, gpointer user_data) { GuiMap *gmap = user_data; GtkWidget *menu; const Hex *adjacent; gboolean port_ok; gint num_ports; gint i; if (area->window == NULL || gmap->map == NULL) return FALSE; if (event->button != 1) return TRUE; current_hex = guimap_find_hex(gmap, event->x, event->y); if (current_hex == NULL) return TRUE; menu = NULL; if (event->button == 1) { MapElement element; Node *current_node; gint distance_node; gint distance_hex; current_node = guimap_find_node(gmap, event->x, event->y); element.node = current_node; distance_node = guimap_distance_cursor(gmap, &element, MAP_NODE, event->x, event->y); element.hex = current_hex; distance_hex = guimap_distance_cursor(gmap, &element, MAP_HEX, event->x, event->y); if (distance_node < distance_hex) { current_node->no_setup = !current_node->no_setup; for (i = 0; i < G_N_ELEMENTS(current_node->hexes); i++) { guimap_draw_hex(gmap, current_node->hexes[i]); } return TRUE; } else { menu = terrain_menu; } } else if (current_hex->roll > 0) { menu = roll_menu; for (i = 2; i <= 12; i++) { if (roll_numbers[i] != NULL) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(roll_numbers[i]), current_hex->roll == i); } gtk_check_menu_item_set_active(shuffle_tile, current_hex->shuffle); } else if (current_hex->terrain == SEA_TERRAIN) { num_ports = 0; for (i = 0; i < 6; i++) { adjacent = hex_in_direction(current_hex, i); port_ok = FALSE; if (adjacent != NULL && adjacent->terrain != LAST_TERRAIN && adjacent->terrain != SEA_TERRAIN) { num_ports++; if (current_hex->resource != NO_RESOURCE) port_ok = TRUE; } gtk_widget_set_sensitive(port_directions[i], port_ok); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (port_directions [i]), current_hex->facing == i && port_ok); } if (num_ports > 0) menu = port_menu; } if (menu != NULL) gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, event->button, event->time); return TRUE; }
static void tray_menu_cb (GtkWidget *widget, guint button, guint time, gpointer userdata) { static GtkWidget *menu; GtkWidget *submenu; GtkWidget *item; int away_status; /* ph may have an invalid context now */ hexchat_set_context (ph, hexchat_find_context (ph, NULL, NULL)); /* close any old menu */ if (G_IS_OBJECT (menu)) { tray_menu_destroy (menu, NULL); } menu = gtk_menu_new (); /*gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (widget));*/ if (tray_get_window_status () == WS_HIDDEN) tray_make_item (menu, _("_Restore Window"), tray_menu_restore_cb, NULL); else tray_make_item (menu, _("_Hide Window"), tray_menu_restore_cb, NULL); tray_make_item (menu, NULL, tray_menu_quit_cb, NULL); #ifndef WIN32 /* submenus are buggy on win32 */ submenu = mg_submenu (menu, _("_Blink on")); blink_item (&prefs.hex_input_tray_chans, submenu, _("Channel Message")); blink_item (&prefs.hex_input_tray_priv, submenu, _("Private Message")); blink_item (&prefs.hex_input_tray_hilight, submenu, _("Highlighted Message")); /*blink_item (BIT_FILEOFFER, submenu, _("File Offer"));*/ submenu = mg_submenu (menu, _("_Change status")); #else /* so show away/back in main tray menu */ submenu = menu; #endif away_status = tray_find_away_status (); item = tray_make_item (submenu, _("_Away"), tray_foreach_server, "away"); if (away_status == 1) gtk_widget_set_sensitive (item, FALSE); item = tray_make_item (submenu, _("_Back"), tray_foreach_server, "back"); if (away_status == 2) gtk_widget_set_sensitive (item, FALSE); menu_add_plugin_items (menu, "\x5$TRAY", NULL); #ifdef WIN32 tray_make_item (menu, NULL, tray_menu_quit_cb, NULL); mg_create_icon_item (_("_Preferences"), GTK_STOCK_PREFERENCES, menu, tray_menu_settings, NULL); #endif tray_make_item (menu, NULL, tray_menu_quit_cb, NULL); mg_create_icon_item (_("_Quit"), GTK_STOCK_QUIT, menu, tray_menu_quit_cb, NULL); g_object_ref (menu); g_object_ref_sink (menu); g_object_unref (menu); g_signal_connect (G_OBJECT (menu), "selection-done", G_CALLBACK (tray_menu_destroy), NULL); #ifdef WIN32 g_signal_connect (G_OBJECT (menu), "leave-notify-event", G_CALLBACK (tray_menu_left_cb), NULL); g_signal_connect (G_OBJECT (menu), "enter-notify-event", G_CALLBACK (tray_menu_enter_cb), NULL); tray_menu_timer = g_timeout_add(500, (GSourceFunc) tray_check_hide, menu); #endif gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, userdata, button, time); }
static void menushell_build_children (GladeXML *xml, GtkWidget *w, GladeWidgetInfo *info) { int i, j; MateUIInfo infos[2] = { { MATE_APP_UI_ITEM }, MATEUIINFO_END }; for (i = 0; i < info->n_children; i++) { GladeChildInfo *cinfo = &info->children[i]; GladeWidgetInfo *cwinfo = cinfo->child; GtkWidget *child; gchar *stock_name = NULL; for (j = 0; j < cwinfo->n_properties; j++) { if (!strcmp (cwinfo->properties[j].name, "stock_item")) { stock_name = cwinfo->properties[j].value; break; } } if (!stock_name) { /* this is a normal menu item */ child = glade_xml_build_widget (xml, cwinfo); gtk_menu_shell_append (GTK_MENU_SHELL (w), child); continue; } /* load the template MateUIInfo for this item */ if (!get_stock_uiinfo (stock_name, &infos[0])) { /* failure ... */ if (!strncmp (stock_name, "MATEUIINFO_", 12)) stock_name += 12; child = gtk_menu_item_new_with_label (stock_name); glade_xml_set_common_params (xml, child, cwinfo); gtk_menu_shell_append (GTK_MENU_SHELL(w), child); continue; } /* we now have the template for this item. Now fill it in */ for (j = 0; j < cwinfo->n_properties; j++) { const char *name = cwinfo->properties[j].name; const char *value = cwinfo->properties[j].value; if (!strcmp (name, "label")) infos[0].label = _(value); else if (!strcmp (name, "tooltip")) infos[0].hint = _(value); } mate_app_fill_menu (GTK_MENU_SHELL(w), infos, glade_xml_ensure_accel(xml), TRUE, i); child = infos[0].widget; gtk_menu_item_remove_submenu(GTK_MENU_ITEM(child)); glade_xml_set_common_params(xml, child, cwinfo); } #if 0 if (uline) glade_xml_pop_uline_accel(xml); #endif #if 0 if (strcmp(info->classname, "GtkMenuBar") != 0 && mate_preferences_get_menus_have_tearoff()) { GtkWidget *tearoff = gtk_tearoff_menu_item_new(); gtk_menu_prepend(GTK_MENU(w), tearoff); gtk_widget_show(tearoff); } #endif }
void gimp_ui_manager_ui_popup (GimpUIManager *manager, const gchar *ui_path, GtkWidget *parent, GimpMenuPositionFunc position_func, gpointer position_data, GDestroyNotify popdown_func, gpointer popdown_data) { GtkWidget *widget; GdkEvent *current_event; gint x, y; guint button; guint32 activate_time; MenuPos *menu_pos; g_return_if_fail (GIMP_IS_UI_MANAGER (manager)); g_return_if_fail (ui_path != NULL); g_return_if_fail (parent == NULL || GTK_IS_WIDGET (parent)); widget = gtk_ui_manager_get_widget (GTK_UI_MANAGER (manager), ui_path); if (GTK_IS_MENU_ITEM (widget)) widget = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget)); if (! widget) return; g_return_if_fail (GTK_IS_MENU (widget)); if (! position_func) { position_func = gimp_ui_manager_menu_position; position_data = parent; } (* position_func) (GTK_MENU (widget), &x, &y, position_data); current_event = gtk_get_current_event (); if (current_event && current_event->type == GDK_BUTTON_PRESS) { GdkEventButton *bevent = (GdkEventButton *) current_event; button = bevent->button; activate_time = bevent->time; } else { button = 0; activate_time = 0; } if (current_event) gdk_event_free (current_event); menu_pos = g_object_get_data (G_OBJECT (widget), "menu-pos"); if (! menu_pos) { menu_pos = g_slice_new0 (MenuPos); g_object_set_data_full (G_OBJECT (widget), "menu-pos", menu_pos, (GDestroyNotify) menu_pos_free); } menu_pos->x = x; menu_pos->y = y; if (popdown_func && popdown_data) { g_object_set_data_full (G_OBJECT (manager), "popdown-data", popdown_data, popdown_func); g_signal_connect (widget, "selection-done", G_CALLBACK (gimp_ui_manager_delete_popdown_data), manager); } gtk_menu_popup (GTK_MENU (widget), NULL, NULL, gimp_ui_manager_menu_pos, menu_pos, button, activate_time); }
int main(int argc, char *argv[]) { GApplication *app; #ifdef HAVE_APP_INDICATOR AppIndicator *indicator; #else GtkStatusIcon *statusicon; #endif /* HAVE_APP_INDICATOR */ GtkWidget *menu; GOptionContext *context; GError *error = NULL; bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain(GETTEXT_PACKAGE); g_type_init (); /* Parse command-line options */ context = g_option_context_new (N_("- Bluetooth applet")); g_option_context_set_translation_domain (context, GETTEXT_PACKAGE); g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE); g_option_context_add_group (context, gtk_get_option_group (TRUE)); if (g_option_context_parse (context, &argc, &argv, &error) == FALSE) { g_print (_("%s\nRun '%s --help' to see a full list of available command line options.\n"), error->message, argv[0]); g_error_free (error); return 1; } if (option_debug == FALSE) { GError *error = NULL; app = g_application_new ("org.cinnamon.Bluetooth.applet", G_APPLICATION_FLAGS_NONE); if (!g_application_register (app, NULL, &error)) { g_object_unref (app); g_warning ("%s", error->message); g_error_free (error); return 1; } if (g_application_get_is_remote (app)) { g_object_unref (app); g_warning ("Applet is already running, exiting"); return 0; } } else { app = NULL; } g_set_application_name(_("Bluetooth Applet")); gtk_window_set_default_icon_name("bluetooth"); applet = g_object_new (BLUETOOTH_TYPE_APPLET, NULL); g_signal_connect (G_OBJECT (applet), "notify::killswitch-state", G_CALLBACK (killswitch_state_changed), NULL); menu = create_popupmenu(); #ifdef HAVE_APP_INDICATOR indicator = init_notification(); app_indicator_set_menu(indicator, GTK_MENU(menu)); app_indicator_set_title(indicator, _("Bluetooth")); gsettings = g_settings_new (BLUETOOTH_INDICATOR_GSETTINGS_SCHEMA_ID); g_signal_connect (gsettings, "changed::" GSETTINGS_VISIBLE_KEY, G_CALLBACK(update_icon_visibility), NULL); #else statusicon = init_notification(); #endif /* HAVE_APP_INDICATOR */ g_signal_connect (G_OBJECT (applet), "devices-changed", G_CALLBACK (update_device_list), NULL); g_signal_connect (G_OBJECT (applet), "notify::discoverable", G_CALLBACK (update_discoverability), NULL); g_signal_connect (G_OBJECT (applet), "notify::show-full-menu", G_CALLBACK (update_menu_items), NULL); killswitch_state_changed ((GObject*) applet, NULL, NULL); update_menu_items ((GObject*) applet, NULL, NULL); update_discoverability ((GObject*) applet, NULL, NULL); update_device_list (applet, NULL); update_icon_visibility(); #ifndef HAVE_APP_INDICATOR g_signal_connect(statusicon, "activate", G_CALLBACK(activate_callback), menu); g_signal_connect(statusicon, "popup-menu", G_CALLBACK(popup_callback), menu); #endif /* HAVE_APP_INDICATOR */ setup_agents(applet); gtk_main(); gtk_widget_destroy(menu); cleanup_notification(); g_object_unref(applet); if (app != NULL) g_object_unref (app); return 0; }
static gboolean gimp_ui_manager_item_key_press (GtkWidget *widget, GdkEventKey *kevent, GimpUIManager *manager) { gchar *help_id = NULL; while (! help_id) { GtkWidget *menu_item = GTK_MENU_SHELL (widget)->active_menu_item; if (! menu_item && GTK_IS_MENU (widget)) { GtkWidget *parent = gtk_widget_get_parent (widget); GdkWindow *window = gtk_widget_get_window (parent); gint x, y; gdk_window_get_pointer (window, &x, &y, NULL); menu_item = find_widget_under_pointer (window, &x, &y); if (menu_item && ! GTK_IS_MENU_ITEM (menu_item)) { menu_item = gtk_widget_get_ancestor (menu_item, GTK_TYPE_MENU_ITEM); if (! GTK_IS_MENU_ITEM (menu_item)) menu_item = NULL; } } /* first, get the help page from the item... */ if (menu_item) { help_id = g_object_get_qdata (G_OBJECT (menu_item), GIMP_HELP_ID); if (help_id && ! strlen (help_id)) help_id = NULL; } /* ...then try the parent menu... */ if (! help_id) { help_id = g_object_get_qdata (G_OBJECT (widget), GIMP_HELP_ID); if (help_id && ! strlen (help_id)) help_id = NULL; } /* ...finally try the menu's parent (if any) */ if (! help_id) { menu_item = NULL; if (GTK_IS_MENU (widget)) menu_item = gtk_menu_get_attach_widget (GTK_MENU (widget)); if (! menu_item) break; widget = gtk_widget_get_parent (menu_item); if (! widget) break; } } /* For any valid accelerator key except F1, continue with the * standard GtkMenuShell callback and assign a new shortcut, but * don't assign a shortcut to the help menu entries ... */ if (kevent->keyval != GDK_KEY_F1) { if (help_id && gtk_accelerator_valid (kevent->keyval, 0) && (strcmp (help_id, GIMP_HELP_HELP) == 0 || strcmp (help_id, GIMP_HELP_HELP_CONTEXT) == 0)) { return TRUE; } return FALSE; } /* ...finally, if F1 was pressed over any menu, show its help page... */ if (help_id) { gchar *help_domain = NULL; gchar *help_string = NULL; gchar *domain_separator; help_id = g_strdup (help_id); domain_separator = strchr (help_id, '?'); if (domain_separator) { *domain_separator = '\0'; help_domain = g_strdup (help_id); help_string = g_strdup (domain_separator + 1); } else { help_string = g_strdup (help_id); } gimp_help (manager->gimp, NULL, help_domain, help_string); g_free (help_domain); g_free (help_string); g_free (help_id); } return TRUE; }
static void cb_popup_state(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data) { switch (button) { case 1: #if UNIX toggle_im_enabled(); break; case 2: #endif kbm_toggle(); break; case 3: { char bak[512], cur[512]; get_gcin_conf_fstr(PHONETIC_KEYBOARD, cur, ""); get_gcin_conf_fstr(PHONETIC_KEYBOARD_BAK, bak, ""); if (bak[0] && strcmp(bak, cur)) { char kbm[512]; strcpy(kbm, bak); char *p=strchr(kbm, ' '); if (p) { *(p++)=0; int i; for(i=0;kbm_sel[i].name;i++) if (!strcmp(kbm_sel[i].kbm, kbm)) { break; } if (kbm_sel[i].kbm) { unich_t tt[128]; if (mitems_state[0].name) free(mitems_state[0].name); #if UNIX sprintf(tt, "注音換 %s %s", kbm_sel[i].name, p); mitems_state[0].name = strdup(tt); #else swprintf(tt, L"注音換 %s %S", kbm_sel[i].name, p); mitems_state[0].name = wcsdup(tt); #endif } } // dbg("hhhhhhhhhhhh %x\n", tray_menu_state); if (tray_menu_state) { gtk_widget_destroy(tray_menu_state); tray_menu_state = NULL; } } if (!tray_menu_state) tray_menu_state = create_tray_menu(mitems_state); gtk_menu_popup(GTK_MENU(tray_menu_state), NULL, NULL, NULL, NULL, button, activate_time); break; } } // dbg("zzzzzzzzzzzzz\n"); }
static void _on_got_location_data (const gchar *cLocationData, GldiModuleInstance *myApplet) { GError *erreur = NULL; cd_weather_free_location_list (); GtkWidget *pCodeEntry = myData.pCodeEntry; if (!pCodeEntry) { cd_debug ("request took too long, discard results"); gldi_task_discard (myData.pGetLocationTask); myData.pGetLocationTask = NULL; return; } cairo_dock_set_status_message (NULL, ""); s_pLocationsList = cd_weather_parse_location_data (cLocationData, &erreur); if (erreur != NULL) { gchar *cIconPath = g_strdup_printf ("%s/broken.png", MY_APPLET_SHARE_DATA_DIR); gldi_dialog_show_temporary_with_icon (D_("I couldn't get the info\n Is connexion alive ?"), myIcon, myContainer, 0, cIconPath); g_free (cIconPath); cairo_dock_set_status_message (NULL, D_("Couldn't get the location code (is connection alive?)")); g_error_free (erreur); erreur = NULL; // on ne garde pas trace de l'erreur, c'est deja fait au (re)chargement. } else if (s_pLocationsList == NULL) { gchar *cIconPath = g_strdup_printf ("%s/broken.png", MY_APPLET_SHARE_DATA_DIR); gldi_dialog_show_temporary_with_icon (D_("I couldn't find this location"), myIcon, myContainer, 0, cIconPath); g_free (cIconPath); cairo_dock_set_status_message (NULL, "Location not available"); } else { GtkWidget *pMenu = gtk_menu_new (); // inside the config window => use a normal GTK menu GString *sOneLocation = g_string_new (""); GtkWidget *pMenuItem; gchar *cLocationName, *cLocationCode; GList *list; for (list = s_pLocationsList; list != NULL; list = list->next) { cLocationCode = list->data; list = list->next; cLocationName = list->data; g_string_printf (sOneLocation, "%s : %s", cLocationName, cLocationCode); pMenuItem = gtk_menu_item_new_with_label (sOneLocation->str); gtk_menu_shell_append (GTK_MENU_SHELL (pMenu), pMenuItem); g_object_set_data (G_OBJECT (pMenuItem), "cd-applet", myApplet); g_signal_connect (G_OBJECT (pMenuItem), "activate", G_CALLBACK(_cd_weather_location_choosed), cLocationCode); } g_string_free (sOneLocation, TRUE); gtk_widget_show_all (pMenu); gtk_menu_popup (GTK_MENU (pMenu), NULL, NULL, NULL, NULL, 1, gtk_get_current_event_time ()); } gldi_task_discard (myData.pGetLocationTask); myData.pGetLocationTask = NULL; }
static void layers_popup ( VikLayersPanel *vlp, GtkTreeIter *iter, gint mouse_button ) { GtkMenu *menu = NULL; if ( iter ) { if ( vik_treeview_item_get_type ( vlp->vt, iter ) == VIK_TREEVIEW_TYPE_LAYER ) { VikLayer *layer = VIK_LAYER(vik_treeview_item_get_pointer ( vlp->vt, iter )); if ( layer->type == VIK_LAYER_AGGREGATE ) menu = GTK_MENU(gtk_item_factory_get_widget ( vlp->popup_factory, "<main>" )); else { GtkWidget *del, *prop; VikStdLayerMenuItem menu_selection = vik_layer_get_menu_items_selection(layer); menu = GTK_MENU ( gtk_menu_new () ); if (menu_selection & VIK_MENU_ITEM_PROPERTY) { prop = gtk_image_menu_item_new_from_stock ( GTK_STOCK_PROPERTIES, NULL ); g_signal_connect_swapped ( G_OBJECT(prop), "activate", G_CALLBACK(vik_layers_panel_properties), vlp ); gtk_menu_shell_append (GTK_MENU_SHELL (menu), prop); gtk_widget_show ( prop ); } if (menu_selection & VIK_MENU_ITEM_CUT) { del = gtk_image_menu_item_new_from_stock ( GTK_STOCK_CUT, NULL ); g_signal_connect_swapped ( G_OBJECT(del), "activate", G_CALLBACK(vik_layers_panel_cut_selected), vlp ); gtk_menu_shell_append (GTK_MENU_SHELL (menu), del); gtk_widget_show ( del ); } if (menu_selection & VIK_MENU_ITEM_COPY) { del = gtk_image_menu_item_new_from_stock ( GTK_STOCK_COPY, NULL ); g_signal_connect_swapped ( G_OBJECT(del), "activate", G_CALLBACK(vik_layers_panel_copy_selected), vlp ); gtk_menu_shell_append (GTK_MENU_SHELL (menu), del); gtk_widget_show ( del ); } if (menu_selection & VIK_MENU_ITEM_PASTE) { del = gtk_image_menu_item_new_from_stock ( GTK_STOCK_PASTE, NULL ); g_signal_connect_swapped ( G_OBJECT(del), "activate", G_CALLBACK(vik_layers_panel_paste_selected), vlp ); gtk_menu_shell_append (GTK_MENU_SHELL (menu), del); gtk_widget_show ( del ); } if (menu_selection & VIK_MENU_ITEM_DELETE) { del = gtk_image_menu_item_new_from_stock ( GTK_STOCK_DELETE, NULL ); g_signal_connect_swapped ( G_OBJECT(del), "activate", G_CALLBACK(vik_layers_panel_delete_selected), vlp ); gtk_menu_shell_append (GTK_MENU_SHELL (menu), del); gtk_widget_show ( del ); } vik_layer_add_menu_items ( layer, menu, vlp ); } } else { menu = GTK_MENU ( gtk_menu_new () ); if ( ! vik_layer_sublayer_add_menu_items ( vik_treeview_item_get_parent ( vlp->vt, iter ), menu, vlp, vik_treeview_item_get_data ( vlp->vt, iter ), vik_treeview_item_get_pointer ( vlp->vt, iter ), iter, vlp->vvp ) ) { gtk_widget_destroy ( GTK_WIDGET(menu) ); return; } /* TODO: specific things for different types */ } } else menu = GTK_MENU(gtk_item_factory_get_widget ( vlp->popup_factory, base_entries[NUM_BASE_ENTRIES-1].path )); gtk_menu_popup ( menu, NULL, NULL, NULL, NULL, mouse_button, gtk_get_current_event_time() ); }
static void gnomenu_menu_real_destroy (GtkObject* base) { GnomenuMenu * self; self = (GnomenuMenu*) base; gtk_menu_shell_remove_all (self); GTK_OBJECT_CLASS (gnomenu_menu_parent_class)->destroy ((GtkObject*) GTK_MENU (self)); }