static void search_entry_populate_popup (GtkEntry *entry, GtkMenu *menu, GeditViewFrame *frame) { GtkWidget *menu_item; frame->priv->disable_popdown = TRUE; g_signal_connect (menu, "hide", G_CALLBACK (search_enable_popdown), frame); if (frame->priv->search_mode == GOTO_LINE) return; /* separator */ menu_item = gtk_separator_menu_item_new (); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item); gtk_widget_show (menu_item); add_popup_menu_items (GTK_WIDGET (menu), frame); }
static void on_browser_populate_popup (GwhBrowser *browser, GtkMenu *menu, gpointer dummy) { GtkWidget *item; gboolean auto_reload = FALSE; item = gtk_separator_menu_item_new (); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_object_get (G_OBJECT (G_settings), "browser-auto-reload", &auto_reload, NULL); item = gtk_check_menu_item_new_with_mnemonic (_("Reload upon document saving")); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), auto_reload); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_signal_connect (item, "toggled", G_CALLBACK (on_item_auto_reload_toggled), NULL); }
/* *=========================================================================== * M E N U B A R *=========================================================================== */ GtkWidget* createMenubar() { GtkWidget* menuitem; GtkWidget* rootmenu; GtkWidget* menu; menu = gtk_menu_new(); menuitem = gtk_menu_item_new_with_mnemonic("_New"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); g_signal_connect( G_OBJECT(menuitem), "activate", G_CALLBACK(fileNew), NULL); menuitem = gtk_menu_item_new_with_mnemonic("_Open"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); menuitem = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); menuitem = gtk_menu_item_new_with_mnemonic("_Quit"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); GtkWidget* menubar = gtk_menu_bar_new(); rootmenu = gtk_menu_item_new_with_mnemonic("_File"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), rootmenu); menu = gtk_menu_new(); menuitem = gtk_menu_item_new_with_mnemonic("_About"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); rootmenu = gtk_menu_item_new_with_mnemonic("_Help"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), rootmenu); return menubar; }
static gboolean create_popup_menu_item (GeditCollaborationWindowHelper *helper, GtkMenu *menu, const gchar *id, gboolean create_separator) { GtkAction *action; GtkWidget *item; GtkActionGroup *ac; action = get_action (helper, id); g_object_get (action, "action-group", &ac, NULL); if (!gtk_action_get_sensitive (action) || !gtk_action_group_get_sensitive (ac)) { g_object_unref (ac); return FALSE; } gtk_action_set_accel_group (action, gtk_ui_manager_get_accel_group (helper->priv->uimanager)); g_object_unref (ac); if (create_separator) { item = gtk_separator_menu_item_new (); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); } item = gtk_action_create_menu_item (action); gtk_widget_show (item); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); return TRUE; }
static void xfce_constructor (XfcePanelPlugin *plugin) { MultiloadPlugin *multiload = multiload_new(); multiload->panel_data = plugin; multiload->panel_orientation = xfce_panel_plugin_get_orientation (plugin); gtk_container_add (GTK_CONTAINER (plugin), GTK_WIDGET(multiload->container)); multiload_ui_read (multiload); multiload_start(multiload); /* show the panel's right-click menu on this ebox */ xfce_panel_plugin_add_action_widget (plugin, GTK_WIDGET(multiload->container)); /* plugin signals */ g_signal_connect(G_OBJECT(plugin), "free-data", G_CALLBACK (xfce_free_cb), multiload); g_signal_connect(G_OBJECT(plugin), "save", G_CALLBACK (xfce_save_cb), multiload); g_signal_connect(G_OBJECT(plugin), "size-changed", G_CALLBACK (xfce_size_changed_cb), multiload); g_signal_connect(G_OBJECT(plugin), "orientation-changed", G_CALLBACK (xfce_orientation_changed_cb), multiload); /* menu items */ GtkMenuItem *mi_separator = GTK_MENU_ITEM(gtk_separator_menu_item_new ()); GtkMenuItem *mi_help = GTK_MENU_ITEM(gtk_menu_item_new_with_mnemonic (_("_Help"))); GtkMenuItem *mi_sysmon = GTK_MENU_ITEM(gtk_menu_item_new_with_label(_("Start task manager"))); xfce_panel_plugin_menu_show_configure (plugin); xfce_panel_plugin_menu_show_about (plugin); xfce_panel_plugin_menu_insert_item (plugin, mi_separator); xfce_panel_plugin_menu_insert_item (plugin, mi_help); xfce_panel_plugin_menu_insert_item (plugin, mi_sysmon); g_signal_connect (G_OBJECT (plugin), "configure-plugin", G_CALLBACK (xfce_configure_cb), multiload); g_signal_connect (G_OBJECT (plugin), "about", G_CALLBACK (xfce_about_cb), NULL); g_signal_connect (G_OBJECT (mi_help), "activate", G_CALLBACK (xfce_help_cb), NULL); g_signal_connect (G_OBJECT (mi_sysmon), "activate", G_CALLBACK (xfce_sysmon_cb), multiload); gtk_widget_show(GTK_WIDGET(mi_separator)); gtk_widget_show(GTK_WIDGET(mi_help)); gtk_widget_show(GTK_WIDGET(mi_sysmon)); }
static gboolean xfdesktop_special_file_icon_populate_context_menu(XfdesktopIcon *icon, GtkWidget *menu) { XfdesktopSpecialFileIcon *special_file_icon = XFDESKTOP_SPECIAL_FILE_ICON(icon); GtkWidget *mi, *img; if(XFDESKTOP_SPECIAL_FILE_ICON_TRASH != special_file_icon->priv->type) return FALSE; img = gtk_image_new_from_icon_name("document-open", GTK_ICON_SIZE_MENU); mi = xfdesktop_menu_create_menu_item_with_mnemonic(_("_Open"), img); gtk_widget_show(mi); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(xfdesktop_special_file_icon_trash_open), icon); mi = gtk_separator_menu_item_new(); gtk_widget_show(mi); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); if(special_file_icon->priv->trash_item_count == 0) { img = gtk_image_new_from_icon_name("user-trash", GTK_ICON_SIZE_MENU); } else { img = gtk_image_new_from_icon_name("user-trash-full", GTK_ICON_SIZE_MENU); } mi = xfdesktop_menu_create_menu_item_with_mnemonic(_("_Empty Trash"), img); gtk_widget_show(mi); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); if(special_file_icon->priv->trash_item_count > 0) { g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(xfdesktop_special_file_icon_trash_empty), icon); } else gtk_widget_set_sensitive(mi, FALSE); return TRUE; }
static void is_indicator_constructed(GObject *object) { IsIndicator *self = IS_INDICATOR(object); GtkActionGroup *action_group; GtkUIManager *ui_manager; GError *error = NULL; GtkWidget *menu; action_group = gtk_action_group_new("AppActions"); gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions(action_group, entries, n_entries, self); ui_manager = gtk_ui_manager_new(); gtk_ui_manager_insert_action_group(ui_manager, action_group, 0); if (!gtk_ui_manager_add_ui_from_string(ui_manager, ui_info, -1, &error)) { g_error("Failed to build menus: %s\n", error->message); } menu = gtk_ui_manager_get_widget(ui_manager, "/ui/Indicator"); /* manually add separator since specifying it in the ui description means it gets optimised out (since there is no menu item above it) but if we manually add it and show the whole menu then all is good... */ gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); gtk_widget_show_all(menu); is_indicator_set_label(self, _("No Sensors")); is_indicator_set_menu(self, GTK_MENU(menu)); #if HAVE_APPINDICATOR app_indicator_set_status(APP_INDICATOR(self), APP_INDICATOR_STATUS_ACTIVE); #endif fake_add_enable_sensors(IS_INDICATOR(object)); }
static void tray_icon_on_menu(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data) { GtkWidget *titleMenuItem = gtk_menu_item_new_with_label(menu_title); gtk_widget_set_sensitive(titleMenuItem, FALSE); openMenuItem = gtk_menu_item_new_with_label("Open"); if (!url) { gtk_widget_set_sensitive(openMenuItem, FALSE); gtk_widget_set_sensitive(copyMenuItem, FALSE); } GtkWidget *exitMenuItem = gtk_menu_item_new_with_label("Exit"); GtkWidget *menu = gtk_menu_new(); g_signal_connect(G_OBJECT(openMenuItem), "activate", G_CALLBACK(handle_open), NULL); g_signal_connect(G_OBJECT(exitMenuItem), "activate", G_CALLBACK(tray_exit), NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), openMenuItem); gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); gtk_menu_shell_append(GTK_MENU_SHELL(menu), exitMenuItem); gtk_widget_show_all(menu); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time()); }
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; }
static gboolean button_press_event_cb (GtkWidget *widget, GdkEventButton *event, WebKitWebView *view) { if (event && event->button != 3) return FALSE; // GtkMenu API is horrible for non-persistant menus. Make it persistant. static GtkWidget *menu = 0; if (menu) gtk_widget_destroy (menu); menu = gtk_menu_new(); // add a couple of items (based on GtkTextView) GtkWidget *item; item = gtk_image_menu_item_new_from_stock (GTK_STOCK_COPY, NULL); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); if (webkit_web_view_can_copy_clipboard (view)) g_signal_connect (item, "activate", G_CALLBACK (copy_activate_cb), widget); else gtk_widget_set_sensitive (item, FALSE); item = gtk_separator_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); item = gtk_image_menu_item_new_from_stock (GTK_STOCK_SELECT_ALL, NULL); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_signal_connect (item, "activate", G_CALLBACK (select_all_activate_cb), widget); int button, event_time; if (event) { button = event->button; event_time = event->time; } else { button = 0; event_time = gtk_get_current_event_time(); } gtk_menu_attach_to_widget (GTK_MENU (menu), widget, NULL); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time); gtk_widget_show_all (menu); return TRUE; }
static void populate_host_list(login_dlg *ldlg) { GtkWidget *menu, *item, *box, *icon, *label; GSList *l; JamHost *h; int i = 0, history = -1; menu = gtk_menu_new(); for (l = conf.hosts; l != NULL; l = l->next) { h = l->data; item = gtk_menu_item_new(); box = gtk_hbox_new(FALSE, 3); icon = gtk_image_new_from_stock(jam_host_get_stock_icon(h), GTK_ICON_SIZE_MENU); label = gtk_label_new(h->name); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_box_pack_start(GTK_BOX(box), icon, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(item), box); gtk_widget_show_all(item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); if (ldlg->curhost && (g_ascii_strcasecmp(h->name, ldlg->curhost->name) == 0)) history = i; i++; } item = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); item = gtk_menu_item_new_with_label(_("Add/Edit Servers...")); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(addedit_host_cb), ldlg); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); gtk_widget_show_all(menu); gtk_option_menu_set_menu(GTK_OPTION_MENU(ldlg->mhost), menu); if (history >= 0) gtk_option_menu_set_history(GTK_OPTION_MENU(ldlg->mhost), history); }
void setup_view_menu(BotViewer *viewer) { GtkWidget *view_menu = viewer->view_menu; // bookmarks gtk_menu_append(GTK_MENU(view_menu), gtk_separator_menu_item_new()); // predefined viewpoints GtkWidget *setview_y_up_item = gtk_menu_item_new_with_mnemonic("Y axis up"); gtk_menu_append(GTK_MENU(view_menu), setview_y_up_item); g_signal_connect(G_OBJECT(setview_y_up_item), "activate", G_CALLBACK(on_setview_y_up_item), viewer); // predefined viewpoints GtkWidget *setview_x_up_item = gtk_menu_item_new_with_mnemonic("X axis up"); gtk_menu_append(GTK_MENU(view_menu), setview_x_up_item); g_signal_connect(G_OBJECT(setview_x_up_item), "activate", G_CALLBACK(on_setview_x_up_item), viewer); gtk_widget_show_all(view_menu); }
GtkWidget * gtk_create_menu_bar(GtkWidget *event_box) { GtkWidget *menu_bar, *menu, *menu_items, *action_menu, *help_menu; GdkColor color; menu_bar = gtk_menu_bar_new(); menu = gtk_menu_new(); menu_items = gtk_menu_item_new_with_label("Restart Game"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items); g_signal_connect(menu_items, "activate", G_CALLBACK(restart_game_menu_event_handler), (gpointer) event_box); menu_items = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items); menu_items = gtk_menu_item_new_with_label("Quit"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items); g_signal_connect(menu_items, "activate", G_CALLBACK(quit_menu_event_handler), NULL); action_menu = gtk_menu_item_new_with_mnemonic("_Action"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(action_menu), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), action_menu); menu = gtk_menu_new(); menu_items = gtk_menu_item_new_with_label("About"); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items); g_signal_connect(menu_items, "activate", G_CALLBACK(about_menu_event_handler), (gpointer) event_box); help_menu = gtk_menu_item_new_with_mnemonic("_Help"); gtk_menu_item_set_submenu(GTK_MENU_ITEM(help_menu), menu); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help_menu); gdk_color_parse(MENU_BAR_COLOR, &color); gtk_widget_modify_bg(menu_bar, GTK_STATE_NORMAL, &color); return menu_bar; }
GtkWidget* create_menu_icon(struct _tray_icon *tray) { GtkWidget *menu = gtk_menu_new(); GtkWidget *menuitem = gtk_image_menu_item_new_with_mnemonic(_("Вкл./Выкл. Xneur")); GtkWidget *image = gtk_image_new_from_stock("gtk-refresh", GTK_ICON_SIZE_MENU); gtk_widget_set_name(image, "image"); gtk_widget_show(image); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image); gtk_widget_show(menuitem); gtk_container_add(GTK_CONTAINER(menu), menuitem); g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(xneur_start_stop), tray); menuitem = gtk_image_menu_item_new_from_stock("gtk-preferences", NULL); gtk_widget_show(menuitem); gtk_container_add(GTK_CONTAINER(menu), menuitem); g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(xneur_preference), tray); menuitem = gtk_separator_menu_item_new(); gtk_widget_show(menuitem); gtk_container_add(GTK_CONTAINER(menu), menuitem); gtk_widget_set_sensitive(menuitem, FALSE); menuitem = gtk_image_menu_item_new_from_stock("gtk-about", NULL); gtk_widget_show(menuitem); gtk_container_add(GTK_CONTAINER(menu), menuitem); g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(xneur_about), tray); menuitem = gtk_image_menu_item_new_from_stock("gtk-quit", NULL); gtk_widget_show(menuitem); gtk_container_add(GTK_CONTAINER(menu), menuitem); g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(xneur_exit), tray); return menu; }
static void indicator_fitbit_init(IndicatorFitbit *self) { GtkWidget *sep; self->priv = INDICATOR_FITBIT_GET_PRIVATE(self); /* zero-initialize everything */ memset(self->priv, 0, sizeof(IndicatorFitbitPrivate)); self->priv->accessible_desc = _("Fitbit"); self->priv->menu = GTK_MENU(gtk_menu_new()); /* create separator */ sep = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(self->priv->menu), sep); gtk_widget_show(sep); /* create the account setup menuitem */ self->priv->account_item_label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(self->priv->account_item_label), 0, 0); gtk_label_set_use_markup(GTK_LABEL(self->priv->account_item_label), TRUE); gtk_label_set_markup(GTK_LABEL(self->priv->account_item_label), _("Account Setup")); gtk_widget_show(self->priv->account_item_label); self->priv->account_item = gtk_menu_item_new(); g_signal_connect(self->priv->account_item, "activate", G_CALLBACK(account_item_activated_cb), self); gtk_container_add(GTK_CONTAINER(self->priv->account_item), self->priv->account_item_label); gtk_widget_show(self->priv->account_item); gtk_menu_shell_append(GTK_MENU_SHELL(self->priv->menu), self->priv->account_item); /* find trackers */ refresh_trackers(self); /* stay up to date */ fitbitd_watch_changes(trackers_change_cb, self); }
static void mateconf_bookmarks_update_menu (GtkWidget *menu) { GSList *list, *tmp; GtkWidget *menuitem, *window; MateConfClient *client; window = g_object_get_data (G_OBJECT (menu), "editor-window"); client = mateconf_client_get_default (); /* Get the old list and then set it */ list = mateconf_client_get_list (client, "/apps/mateconf-editor/bookmarks", MATECONF_VALUE_STRING, NULL); if (list != NULL) { menuitem = gtk_separator_menu_item_new (); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } for (tmp = list; tmp; tmp = tmp->next) { menuitem = gtk_image_menu_item_new_with_label (tmp->data); g_signal_connect (menuitem, "activate", G_CALLBACK (mateconf_bookmarks_bookmark_activated), window); g_object_set_data_full (G_OBJECT (menuitem), "mateconf-key", g_strdup (tmp->data), g_free); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), gtk_image_new_from_stock (STOCK_BOOKMARK, GTK_ICON_SIZE_MENU)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show_all (menuitem); g_free (tmp->data); } g_object_unref (client); g_slist_free (list); }
static void populate_popup_cb (G_GNUC_UNUSED GtkWidget *text_view, GtkMenu *menu, EntryProperties *eprop) { GtkTextIter iter; gtk_text_view_get_iter_at_position (eprop->priv->view, &iter, NULL, eprop->priv->bx, eprop->priv->by); GSList *tags = NULL, *tagp = NULL; tags = gtk_text_iter_get_tags (&iter); for (tagp = tags; tagp != NULL; tagp = tagp->next) { GtkTextTag *tag = tagp->data; GValue *binvalue; binvalue = g_object_get_data (G_OBJECT (tag), "binvalue"); if (binvalue) { GtkWidget *item; item = gtk_separator_menu_item_new (); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); item = gtk_menu_item_new_with_label (_("Save")); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), item); g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (data_save_cb), eprop); g_object_set_data (G_OBJECT (item), "binvalue", binvalue); gtk_widget_show (item); break; } } if (tags) g_slist_free (tags); }
static void menu_create() { int i; GtkWidget *mi, *img; ENTER; menu = gtk_menu_new(); /* flags */ for (i = 0; i < ngroups; i++) { mi = gtk_image_menu_item_new_with_label(group[i].name); g_signal_connect(G_OBJECT(mi), "activate", (GCallback)menu_activated, GINT_TO_POINTER(i)); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); gtk_widget_show(mi); img = gtk_image_new_from_pixbuf(group[i].flag); gtk_widget_show(img); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), img); } /* separator */ mi = gtk_separator_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); gtk_widget_show(mi); /* about */ mi = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL); g_signal_connect(G_OBJECT(mi), "activate", (GCallback)menu_about, NULL); gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi); gtk_widget_show (mi); /* exit */ mi = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL); g_signal_connect(G_OBJECT(mi), "activate", (GCallback)menu_exit, NULL); gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi); gtk_widget_show (mi); RET(); }
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()); }
JNIEXPORT jlong JNICALL Java_org_gnome_gtk_GtkSeparatorMenuItem_gtk_1separator_1menu_1item_1new ( JNIEnv* env, jclass cls ) { GtkWidget* result; jlong _result; // call function result = gtk_separator_menu_item_new(); // translate return value to JNI type _result = (jlong) result; // cleanup return value if (result != NULL) { bindings_java_memory_cleanup((GObject*)result, TRUE); } // and finally return _result; }
static void menu_tree_changed(GMenuTree *tree, gpointer user_data) { GMenuTreeDirectory *root = NULL; GtkWidget *menuitem = NULL; popup = gtk_menu_new(); gmenu_tree_load_sync(tree, NULL); root = gmenu_tree_get_root_directory(tree); if (root) { traverse_directory(root, NULL); gmenu_tree_item_unref(root); root = NULL; } gtk_menu_shell_append(GTK_MENU_SHELL(popup), gtk_separator_menu_item_new()); menuitem = menu_item_new_with_icon_name_text("logout", _("Logout")); gtk_menu_shell_append(GTK_MENU_SHELL(popup), menuitem); g_object_connect(G_OBJECT(menuitem), "signal::activate", G_CALLBACK(logout), NULL, NULL); }
void create_tray_menu (GtkWidget *app) { GtkWidget *menuitem; GList *node; int index; node = settings.presets; tray_menu = gtk_menu_new(); for (index = 0; node; index++, node = node->next) { preset *ps; ps = (preset *) node->data; menuitem = gtk_menu_item_new_with_label (ps->title); gtk_menu_shell_insert (GTK_MENU_SHELL (tray_menu), menuitem, index); g_signal_connect (menuitem, "activate", G_CALLBACK(preset_menuitem_activate_cb), GINT_TO_POINTER (index)); gtk_widget_show (menuitem); } gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), gtk_separator_menu_item_new ()); mute_menuitem = gtk_check_menu_item_new_with_label (_("Muted")); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mute_menuitem), mixer->get_volume() == 0); gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), mute_menuitem); mute_menuitem_toggled_cb_id = g_signal_connect (mute_menuitem, "toggled", G_CALLBACK (mute_menuitem_toggled_cb), (gpointer) app); gtk_widget_show (mute_menuitem); menuitem = gtk_menu_item_new_with_mnemonic (_("_Record")); gtk_menu_shell_append (GTK_MENU_SHELL(tray_menu), menuitem); g_signal_connect (menuitem, "activate", G_CALLBACK(record_menuitem_activate_cb), app); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), gtk_separator_menu_item_new ()); showwindow_menuitem = gtk_check_menu_item_new_with_label (_("Show Window")); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (showwindow_menuitem), TRUE); gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), showwindow_menuitem); g_signal_connect (showwindow_menuitem, "activate", G_CALLBACK (showwindow_menuitem_toggled_cb), (gpointer) app); gtk_widget_show(showwindow_menuitem); menuitem = gtk_menu_item_new_with_mnemonic (_("_Quit")); gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), menuitem); g_signal_connect (menuitem, "activate", G_CALLBACK(quit_menuitem_activate_cb), NULL); gtk_widget_show (menuitem); gtk_widget_show_all (tray_menu); }
void greeter_system_append_system_menu (GtkWidget *menu) { GtkWidget *w, *sep; gint i = 0; /* should never be allowed by the UI */ if ( ! mdm_config_get_bool (MDM_KEY_SYSTEM_MENU) || ve_string_empty (g_getenv ("MDM_IS_LOCAL"))) return; /* * Disable Configuration if using accessibility (AddGtkModules) since * using it with accessibility causes a hang. */ if (mdm_config_get_bool (MDM_KEY_CONFIG_AVAILABLE) && !mdm_config_get_bool (MDM_KEY_ADD_GTK_MODULES) && bin_exists (mdm_config_get_string (MDM_KEY_CONFIGURATOR))) { w = gtk_image_menu_item_new_with_mnemonic (_("Confi_gure Login Manager...")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w), gtk_image_new_from_icon_name ("mdmsetup", GTK_ICON_SIZE_MENU)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), w); gtk_widget_show (GTK_WIDGET (w)); g_signal_connect (G_OBJECT (w), "activate", G_CALLBACK (greeter_config_handler), NULL); } if (MdmRebootFound || MdmHaltFound || MdmSuspendFound) { sep = gtk_separator_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep); gtk_widget_show (sep); } if (MdmRebootFound && mdm_common_is_action_available ("REBOOT")) { w = gtk_image_menu_item_new_with_mnemonic (_("_Restart")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w), gtk_image_new_from_icon_name ("system-restart", GTK_ICON_SIZE_MENU)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), w); gtk_widget_show (GTK_WIDGET (w)); g_signal_connect (G_OBJECT (w), "activate", G_CALLBACK (query_greeter_restart_handler), NULL); } if (MdmHaltFound && mdm_common_is_action_available ("HALT")) { w = gtk_image_menu_item_new_with_mnemonic (_("Shut _Down")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w), gtk_image_new_from_icon_name ("system-shut-down", GTK_ICON_SIZE_MENU)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), w); gtk_widget_show (GTK_WIDGET (w)); g_signal_connect (G_OBJECT (w), "activate", G_CALLBACK (query_greeter_halt_handler), NULL); } if (MdmSuspendFound && mdm_common_is_action_available ("SUSPEND")) { w = gtk_image_menu_item_new_with_mnemonic (_("Sus_pend")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w), gtk_image_new_from_icon_name ("system-suspend", GTK_ICON_SIZE_MENU)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), w); gtk_widget_show (GTK_WIDGET (w)); g_signal_connect (G_OBJECT (w), "activate", G_CALLBACK (query_greeter_suspend_handler), NULL); } }
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()); }
/*! \brief Translate a resource tree into a menu structure * * \param [in] menu The GHidMainMenu widget to be acted on * \param [in] shall The base menu shell (a menu bar or popup menu) * \param [in] res The base of the resource tree * */ void ghid_main_menu_real_add_resource (GHidMainMenu *menu, GtkMenuShell *shell, const Resource *res) { int i, j; const Resource *tmp_res; gchar mnemonic = 0; for (i = 0; i < res->c; ++i) { const gchar *accel = NULL; char *menu_label; const char *res_val; const Resource *sub_res = res->v[i].subres; GtkAction *action = NULL; switch (resource_type (res->v[i])) { case 101: /* name, subres: passthrough */ ghid_main_menu_real_add_resource (menu, shell, sub_res); break; case 1: /* no name, subres */ tmp_res = resource_subres (sub_res, "a"); /* accelerator */ res_val = resource_value (sub_res, "m"); /* mnemonic */ if (res_val) mnemonic = res_val[0]; /* The accelerator resource will have two values, like * a={"Ctrl-Q" "Ctrl<Key>q"} * The first Gtk ignores. The second needs to be translated. */ if (tmp_res) accel = check_unique_accel (translate_accelerator (tmp_res->v[1].value)); /* Now look for the first unnamed value (not a subresource) to * figure out the name of the menu or the menuitem. */ res_val = "button"; for (j = 0; j < sub_res->c; ++j) if (resource_type (sub_res->v[j]) == 10) { res_val = _(sub_res->v[j].value); break; } /* Hack '_' in based on mnemonic value */ if (!mnemonic) menu_label = g_strdup (res_val); else { char *post_ = strchr (res_val, mnemonic); if (post_ == NULL) menu_label = g_strdup (res_val); else { GString *tmp = g_string_new (""); g_string_append_len (tmp, res_val, post_ - res_val); g_string_append_c (tmp, '_'); g_string_append (tmp, post_); menu_label = g_string_free (tmp, FALSE); } } /* If the subresource we're processing also has unnamed * subresources, it's a submenu, not a regular menuitem. */ if (sub_res->flags & FLAG_S) { /* SUBMENU */ GtkWidget *submenu = gtk_menu_new (); GtkWidget *item = gtk_menu_item_new_with_mnemonic (menu_label); GtkWidget *tearoff = gtk_tearoff_menu_item_new (); gtk_menu_shell_append (shell, item); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu); /* add tearoff to menu */ gtk_menu_shell_append (GTK_MENU_SHELL (submenu), tearoff); /* recurse on the newly-added submenu */ ghid_main_menu_real_add_resource (menu, GTK_MENU_SHELL (submenu), sub_res); } else { /* NON-SUBMENU: MENU ITEM */ const char *checked = resource_value (sub_res, "checked"); const char *label = resource_value (sub_res, "sensitive"); const char *tip = resource_value (sub_res, "tip"); if (checked) { /* TOGGLE ITEM */ gchar *name = g_strdup_printf ("MainMenuAction%d", action_counter++); action = GTK_ACTION (gtk_toggle_action_new (name, menu_label, tip, NULL)); /* checked=foo is a binary flag (checkbox) * checked=foo,bar is a flag compared to a value (radio) */ gtk_toggle_action_set_draw_as_radio (GTK_TOGGLE_ACTION (action), !!strchr (checked, ',')); } else if (label && strcmp (label, "false") == 0) { /* INSENSITIVE ITEM */ GtkWidget *item = gtk_menu_item_new_with_label (menu_label); gtk_widget_set_sensitive (item, FALSE); gtk_menu_shell_append (shell, item); } else { /* NORMAL ITEM */ gchar *name = g_strdup_printf ("MainMenuAction%d", action_counter++); action = gtk_action_new (name, menu_label, tip, NULL); } } /* Connect accelerator, if there is one */ if (action) { GtkWidget *item; gtk_action_set_accel_group (action, menu->accel_group); gtk_action_group_add_action_with_accel (menu->action_group, action, accel); gtk_action_connect_accelerator (action); g_signal_connect (G_OBJECT (action), "activate", menu->action_cb, (gpointer) sub_res); g_object_set_data (G_OBJECT (action), "resource", (gpointer) sub_res); item = gtk_action_create_menu_item (action); gtk_menu_shell_append (shell, item); menu->actions = g_list_append (menu->actions, action); menu->special_key_cb (accel, action, sub_res); } /* Scan rest of resource in case there is more work */ for (j = 0; j < sub_res->c; j++) { const char *res_name; /* named value = X resource */ if (resource_type (sub_res->v[j]) == 110) { res_name = sub_res->v[j].name; /* translate bg, fg to background, foreground */ if (strcmp (res_name, "fg") == 0) res_name = "foreground"; if (strcmp (res_name, "bg") == 0) res_name = "background"; /* ignore special named values (m, a, sensitive) */ if (strcmp (res_name, "m") == 0 || strcmp (res_name, "a") == 0 || strcmp (res_name, "sensitive") == 0 || strcmp (res_name, "tip") == 0) break; /* log checked and active special values */ if (action && strcmp (res_name, "checked") == 0) g_object_set_data (G_OBJECT (action), "checked-flag", sub_res->v[j].value); else if (action && strcmp (res_name, "active") == 0) g_object_set_data (G_OBJECT (action), "active-flag", sub_res->v[j].value); else /* if we got this far it is supposed to be an X * resource. For now ignore it and warn the user */ Message (_("The gtk gui currently ignores \"%s\"" "as part of a menuitem resource.\n" "Feel free to provide patches\n"), sub_res->v[j].value); } } break; case 10: /* no name, value */ /* If we get here, the resource is "-" or "@foo" for some foo */ if (res->v[i].value[0] == '@') { GList *children; int pos; children = gtk_container_get_children (GTK_CONTAINER (shell)); pos = g_list_length (children); g_list_free (children); if (strcmp (res->v[i].value, "@layerview") == 0) { menu->layer_view_shell = shell; menu->layer_view_pos = pos; } else if (strcmp (res->v[i].value, "@layerpick") == 0) { menu->layer_pick_shell = shell; menu->layer_pick_pos = pos; } else if (strcmp (res->v[i].value, "@routestyles") == 0) { menu->route_style_shell = shell; menu->route_style_pos = pos; } else Message (_("GTK GUI currently ignores \"%s\" in the menu\n" "resource file.\n"), res->v[i].value); } else if (strcmp (res->v[i].value, "-") == 0) { GtkWidget *item = gtk_separator_menu_item_new (); gtk_menu_shell_append (shell, item); } else if (i > 0) { /* This is an action-less menuitem. It is really only useful * when you're starting to build a new menu and you're looking * to get the layout right. */ GtkWidget *item = gtk_menu_item_new_with_label (_(res->v[i].value)); gtk_menu_shell_append (shell, item); } break; } } }
/** * @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); }
void add_separator_to_menu() { GtkWidget *separator = gtk_separator_menu_item_new(); gtk_menu_append(GTK_MENU_SHELL (menu),separator); gtk_widget_show(separator); }
static GtkWidget * panel_applet_get_menu (AppletInfo *info) { GtkWidget *menu; GList *l; gboolean added_anything = FALSE; /** * Separator to split the menu * * APPLET ITEMS * ------------- * Move * Remove From Panel */ GtkSeparatorMenuItem *separator; /** * Variables for the edit menu */ GtkWidget *menuitem; GtkWidget *image; gboolean movable; gboolean removable; if (info->menu) return info->menu; menu = panel_applet_create_bare_menu (info); /** * Moved the panel_applet_get_edit_menu code to here * to recombine the menu as seen in the traditional * Gnome 2 setup */ movable = panel_applet_can_freely_move (info); removable = panel_layout_is_writable (); // Hack. We always added something now :P added_anything = TRUE; for (l = info->user_menu; l; l = l->next) { AppletUserMenu *user_menu = l->data; if (user_menu->is_enabled_func && !user_menu->is_enabled_func ()) continue; add_to_submenus (info, "", user_menu->name, user_menu, menu, info->user_menu); added_anything = TRUE; } // Add the separator before we add the move/remove items (less confusion) separator = gtk_separator_menu_item_new (); gtk_widget_show (separator); gtk_menu_shell_append (GTK_MENU_SHELL(menu), separator); menuitem = gtk_menu_item_new_with_mnemonic (_("_Move")); g_signal_connect (menuitem, "activate", G_CALLBACK (move_applet_callback), info); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_set_sensitive (menuitem, movable); // TODO: Add a seperator menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Remove From Panel")); image = gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image); g_signal_connect (menuitem, "activate", G_CALLBACK (applet_remove_callback), info); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_set_sensitive (menuitem, removable); if ( ! added_anything) { g_signal_handlers_disconnect_by_func (menu, G_CALLBACK (applet_menu_show), info); g_signal_handlers_disconnect_by_func (menu, G_CALLBACK (applet_menu_deactivate), info); g_object_unref (menu); return NULL; } info->menu = menu; panel_lockdown_on_notify (panel_lockdown_get (), NULL, G_OBJECT (info->menu), panel_applet_menu_lockdown_changed, info); return info->menu; }
static GtkWidget *create_history_menu(GtkWidget *history_menu) { GtkWidget *menu_item, *item_label; history_menu = gtk_menu_new(); g_signal_connect((GObject*)history_menu, "key-press-event", (GCallback)menu_key_pressed, NULL); /* Items */ if ((history != NULL) && (history->data != NULL)) { /* Declare some variables */ GList* element; gint element_number = 0; gint element_number_small = 0; gchar* primary_temp = gtk_clipboard_wait_for_text(primary); gchar* clipboard_temp = gtk_clipboard_wait_for_text(clipboard); /* Reverse history if enabled */ if (prefs.reverse_history) { history = g_list_reverse(history); element_number = g_list_length(history) - 1; } /* Go through each element and adding each */ for (element = history; (element != NULL) && (element_number_small < prefs.items_menu); element = element->next) { history_item *elem_data = element->data; GString* string = g_string_new((gchar*)elem_data->content); /* Ellipsize text */ string = ellipsize_string(string); /* Remove control characters */ string = remove_newlines_string(string); /* Make new item with ellipsized text */ gchar* list_item; if (prefs.show_indexes) { list_item = g_strdup_printf("%d. %s", (element_number_small+1), string->str); } else { list_item = g_strdup(string->str); } menu_item = gtk_menu_item_new_with_label(list_item); g_signal_connect((GObject*)menu_item, "activate", (GCallback)item_selected, GINT_TO_POINTER(element_number)); /* Modify menu item label properties */ item_label = gtk_bin_get_child((GtkBin*)menu_item); gtk_label_set_single_line_mode((GtkLabel*)item_label, prefs.single_line); /* Check if item is also clipboard text and make bold */ if ((clipboard_temp) && (g_strcmp0((gchar*)elem_data->content, clipboard_temp) == 0)) { gchar* bold_text = g_markup_printf_escaped("<b>%s</b>", list_item); gtk_label_set_markup((GtkLabel*)item_label, bold_text); g_free(bold_text); } else if ((primary_temp) && (g_strcmp0((gchar*)elem_data->content, primary_temp) == 0)) { gchar* italic_text = g_markup_printf_escaped("<i>%s</i>", list_item); gtk_label_set_markup((GtkLabel*)item_label, italic_text); g_free(italic_text); } g_free(list_item); /* Append item */ gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item); /* Prepare for next item */ g_string_free(string, TRUE); if (prefs.reverse_history) element_number--; else element_number++; element_number_small++; } /* Cleanup */ g_free(primary_temp); g_free(clipboard_temp); /* Return history to normal if reversed */ if (prefs.reverse_history) history = g_list_reverse(history); } else { /* Nothing in history so adding empty */ menu_item = gtk_menu_item_new_with_label(_("Empty")); gtk_widget_set_sensitive(menu_item, FALSE); gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item); } if (prefs.statics_show) { /* -------------------- */ gtk_menu_shell_append((GtkMenuShell*)history_menu, gtk_separator_menu_item_new()); /* Items */ GList *elem = history; int elem_num = 0; int elem_num_static = 1; while (elem && (elem_num_static <= prefs.statics_items)) { history_item *hitem = elem->data; if (hitem->is_static) { GString* string = g_string_new((gchar*)hitem->content); /* Ellipsize text */ string = ellipsize_string(string); /* Remove control characters */ string = remove_newlines_string(string); gchar* list_item; if (prefs.show_indexes) { list_item = g_strdup_printf("%d. %s", (elem_num_static), string->str); } else { list_item = g_strdup(string->str); } menu_item = gtk_menu_item_new_with_label(list_item); g_signal_connect((GObject*)menu_item, "activate", (GCallback)item_selected, GINT_TO_POINTER(elem_num)); /* Modify menu item label properties */ item_label = gtk_bin_get_child((GtkBin*)menu_item); gtk_label_set_single_line_mode((GtkLabel*)item_label, prefs.single_line); g_free(list_item); g_string_free(string, TRUE); gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item); elem_num_static++; } elem_num++; elem = elem->next; } } /* Show a notice in offline mode */ if (prefs.offline_mode) { gtk_menu_shell_append((GtkMenuShell*)history_menu, gtk_separator_menu_item_new()); menu_item = gtk_menu_item_new_with_label(""); item_label = gtk_bin_get_child((GtkBin*)menu_item); gtk_label_set_markup((GtkLabel*)item_label, "<b>Offline mode is ON</b>"); gtk_label_set_single_line_mode((GtkLabel*)item_label, TRUE); gtk_widget_set_sensitive(item_label, FALSE); gtk_menu_shell_append((GtkMenuShell*)history_menu, menu_item); } return history_menu; }
/* Called when status icon is control-clicked */ static gboolean show_actions_menu(gpointer data) { /* Declare some variables */ GtkWidget *menu, *menu_item, *menu_image, *item_label; /* Create menu */ menu = gtk_menu_new(); g_signal_connect((GObject*)menu, "selection-done", (GCallback)gtk_widget_destroy, NULL); /* Actions using: */ menu_item = gtk_image_menu_item_new_with_label(_("Actions using:")); menu_image = gtk_image_new_from_stock(GTK_STOCK_EXECUTE, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image((GtkImageMenuItem*)menu_item, menu_image); g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); /* Clipboard contents */ gchar* text = gtk_clipboard_wait_for_text(clipboard); if (text != NULL) { menu_item = gtk_menu_item_new_with_label(_("None")); /* Modify menu item label properties */ item_label = gtk_bin_get_child((GtkBin*)menu_item); gtk_label_set_single_line_mode((GtkLabel*)item_label, TRUE); gtk_label_set_ellipsize((GtkLabel*)item_label, prefs.ellipsize); gtk_label_set_width_chars((GtkLabel*)item_label, 30); /* Making bold... */ gchar* bold_text = g_markup_printf_escaped("<b>%s</b>", text); gtk_label_set_markup((GtkLabel*)item_label, bold_text); g_free(bold_text); /* Append menu item */ g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); } else { /* Create menu item for empty clipboard contents */ menu_item = gtk_menu_item_new_with_label(_("None")); /* Modify menu item label properties */ item_label = gtk_bin_get_child((GtkBin*)menu_item); gtk_label_set_markup((GtkLabel*)item_label, _("<b>None</b>")); /* Append menu item */ g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); } /* -------------------- */ gtk_menu_shell_append((GtkMenuShell*)menu, gtk_separator_menu_item_new()); /* Actions */ gchar* path = g_build_filename(g_get_user_data_dir(), ACTIONS_FILE, NULL); FILE* actions_file = fopen(path, "rb"); g_free(path); /* Check that it opened and begin read */ if (actions_file) { gint size; size_t fread_return; fread_return = fread(&size, 4, 1, actions_file); /* Check if actions file is empty */ if (!size) { /* File contained no actions so adding empty */ menu_item = gtk_menu_item_new_with_label(_("Empty")); gtk_widget_set_sensitive(menu_item, FALSE); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); } /* Continue reading items until size is 0 */ while (size) { /* Read name */ gchar* name = (gchar*)g_malloc(size + 1); fread_return = fread(name, size, 1, actions_file); name[size] = '\0'; menu_item = gtk_menu_item_new_with_label(name); g_free(name); fread_return = fread(&size, 4, 1, actions_file); /* Read command */ gchar* command = (gchar*)g_malloc(size + 1); fread_return = fread(command, size, 1, actions_file); command[size] = '\0'; fread_return = fread(&size, 4, 1, actions_file); /* Append the action */ gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); g_signal_connect((GObject*)menu_item, "activate", (GCallback)action_selected, (gpointer)command); } fclose(actions_file); } else { /* File did not open so adding empty */ menu_item = gtk_menu_item_new_with_label(_("Empty")); gtk_widget_set_sensitive(menu_item, FALSE); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); } /* -------------------- */ gtk_menu_shell_append((GtkMenuShell*)menu, gtk_separator_menu_item_new()); /* Edit actions */ menu_item = gtk_image_menu_item_new_with_mnemonic(_("_Edit actions")); menu_image = gtk_image_new_from_stock(GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU); gtk_image_menu_item_set_image((GtkImageMenuItem*)menu_item, menu_image); g_signal_connect((GObject*)menu_item, "activate", (GCallback)edit_actions_selected, NULL); gtk_menu_shell_append((GtkMenuShell*)menu, menu_item); /* Popup the menu... */ gtk_widget_show_all(menu); gtk_menu_popup((GtkMenu*)menu, NULL, NULL, NULL, NULL, 1, gtk_get_current_event_time()); /* Return false so the g_timeout_add() function is called only once */ return FALSE; }