/** \brief Update TLE from local files. * \param widget The menu item (unused). * \param data User data (unused). * * This function is called when the user selects * Edit -> Update TLE -> From local files * in the menubar. * * First the function creates the GUI status indicator infrastructure * with the possibility to select a directory, then it calls the * tle_update_from_files with the corresponding parameters. * * Finally, the programs signals the module manager to reload the * satellites in each module. * * FIXME: fork as a thread? */ static void menubar_tle_local_cb(GtkWidget * widget, gpointer data) { gchar *dir; /* selected directory */ GtkWidget *dir_chooser; /* directory chooser button */ GtkWidget *dialog; /* dialog window */ GtkWidget *label; /* misc labels */ GtkWidget *progress; /* progress indicator */ GtkWidget *label1, *label2; /* activitity and stats labels */ GtkWidget *box; gint response; /* dialog response */ gboolean doupdate = FALSE; (void)widget; /* avoid unused parameter compiler warning */ (void)data; /* avoid unused parameter compiler warning */ /* get last used directory */ dir = sat_cfg_get_str(SAT_CFG_STR_TLE_FILE_DIR); /* if there is no last used dir fall back to $HOME */ if (dir == NULL) { dir = g_strdup(g_get_home_dir()); } /* create file chooser */ dir_chooser = gtk_file_chooser_button_new(_("Select directory"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dir_chooser), dir); g_free(dir); /* create label */ label = gtk_label_new(_("Select TLE directory:")); /* pack label and chooser into a hbox */ box = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 5); gtk_box_pack_start(GTK_BOX(box), dir_chooser, TRUE, TRUE, 5); gtk_widget_show_all(box); /* create the dalog */ dialog = gtk_dialog_new_with_buttons(_("Update TLE from files"), GTK_WINDOW(app), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), box, TRUE, TRUE, 30); response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_ACCEPT: /* set flag to indicate that we should do an update */ doupdate = TRUE; break; default: doupdate = FALSE; break; } /* get directory before we destroy the dialog */ dir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dir_chooser)); /* nuke the dialog */ gtk_widget_destroy(dialog); if (doupdate) { sat_log_log(SAT_LOG_LEVEL_INFO, _("%s: Running TLE update from %s"), __FUNCTION__, dir); /* store last used TLE dir */ sat_cfg_set_str(SAT_CFG_STR_TLE_FILE_DIR, dir); /* create new dialog with progress indicator */ dialog = gtk_dialog_new_with_buttons(_("TLE Update"), GTK_WINDOW(app), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL); //gtk_window_set_default_size (GTK_WINDOW (dialog), 400,250); gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT, FALSE); /* create a vbox */ box = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(box), 20); /* add static label */ label = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5); gtk_label_set_markup(GTK_LABEL(label), _("<b>Updating TLE files from files</b>")); gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0); /* activity label */ label1 = gtk_label_new("..."); gtk_misc_set_alignment(GTK_MISC(label1), 0.5, 0.5); gtk_box_pack_start(GTK_BOX(box), label1, FALSE, FALSE, 0); /* add progress bar */ progress = gtk_progress_bar_new(); gtk_box_pack_start(GTK_BOX(box), progress, FALSE, FALSE, 10); /* statistics */ label2 = gtk_label_new(_("Satellites updated:\t 0\n" "Satellites skipped:\t 0\n" "Missing Satellites:\t 0\n")); gtk_box_pack_start(GTK_BOX(box), label2, TRUE, TRUE, 0); /* finalise dialog */ gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), box); g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog); gtk_widget_show_all(dialog); /* Force the drawing queue to be processed otherwise the dialog may not appear before we enter the TLE updating func - see Gtk+ FAQ http://www.gtk.org/faq/#AEN602 */ while (g_main_context_iteration(NULL, FALSE)); /* update TLE */ tle_update_from_files(dir, NULL, FALSE, progress, label1, label2); /* set progress bar to 100% */ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress), 1.0); gtk_label_set_text(GTK_LABEL(label1), _("Finished")); /* enable close button */ gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT, TRUE); } if (dir) g_free(dir); /* reload satellites */ mod_mgr_reload_sats(); }
bool wxFileDialog::Create(wxWindow *parent, const wxString& message, const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard, long style, const wxPoint& pos, const wxSize& sz, const wxString& name) { parent = GetParentForModalDialog(parent, style); if (!wxFileDialogBase::Create(parent, message, defaultDir, defaultFileName, wildCard, style, pos, sz, name)) { return false; } if (!PreCreation(parent, pos, wxDefaultSize) || !CreateBase(parent, wxID_ANY, pos, wxDefaultSize, style, wxDefaultValidator, wxT("filedialog"))) { wxFAIL_MSG( wxT("wxFileDialog creation failed") ); return false; } GtkFileChooserAction gtk_action; GtkWindow* gtk_parent = NULL; if (parent) gtk_parent = GTK_WINDOW( gtk_widget_get_toplevel(parent->m_widget) ); const gchar* ok_btn_stock; if ( style & wxFD_SAVE ) { gtk_action = GTK_FILE_CHOOSER_ACTION_SAVE; ok_btn_stock = GTK_STOCK_SAVE; } else { gtk_action = GTK_FILE_CHOOSER_ACTION_OPEN; ok_btn_stock = GTK_STOCK_OPEN; } m_widget = gtk_file_chooser_dialog_new( wxGTK_CONV(m_message), gtk_parent, gtk_action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, ok_btn_stock, GTK_RESPONSE_ACCEPT, NULL); g_object_ref(m_widget); GtkFileChooser* file_chooser = GTK_FILE_CHOOSER(m_widget); m_fc.SetWidget(file_chooser); gtk_dialog_set_default_response(GTK_DIALOG(m_widget), GTK_RESPONSE_ACCEPT); if ( style & wxFD_MULTIPLE ) gtk_file_chooser_set_select_multiple(file_chooser, true); // gtk_widget_hide_on_delete is used here to avoid that Gtk automatically // destroys the dialog when the user press ESC on the dialog: in that case // a second call to ShowModal() would result in a bunch of Gtk-CRITICAL // errors... g_signal_connect(m_widget, "delete_event", G_CALLBACK (gtk_widget_hide_on_delete), this); // local-only property could be set to false to allow non-local files to be // loaded. In that case get/set_uri(s) should be used instead of // get/set_filename(s) everywhere and the GtkFileChooserDialog should // probably also be created with a backend, e.g. "gnome-vfs", "default", ... // (gtk_file_chooser_dialog_new_with_backend). Currently local-only is kept // as the default - true: // gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(m_widget), true); g_signal_connect (m_widget, "response", G_CALLBACK (gtk_filedialog_response_callback), this); // deal with extensions/filters SetWildcard(wildCard); wxString defaultFileNameWithExt = defaultFileName; if ( !wildCard.empty() && !defaultFileName.empty() && !wxFileName(defaultFileName).HasExt() ) { // append the default extension to the initial file name: GTK won't do // it for us by default (unlike e.g. MSW) const wxString defaultExt = m_fc.GetCurrentWildCard().AfterFirst('.'); if ( defaultExt.find_first_of("?*") == wxString::npos ) defaultFileNameWithExt += "." + defaultExt; } // if defaultDir is specified it should contain the directory and // defaultFileName should contain the default name of the file, however if // directory is not given, defaultFileName contains both wxFileName fn; if ( defaultDir.empty() ) fn.Assign(defaultFileNameWithExt); else if ( !defaultFileNameWithExt.empty() ) fn.Assign(defaultDir, defaultFileNameWithExt); else fn.AssignDir(defaultDir); // set the initial file name and/or directory fn.MakeAbsolute(); // GTK+ needs absolute path const wxString dir = fn.GetPath(); if ( !dir.empty() ) { gtk_file_chooser_set_current_folder(file_chooser, wxGTK_CONV_FN(dir)); } const wxString fname = fn.GetFullName(); if ( style & wxFD_SAVE ) { if ( !fname.empty() ) { gtk_file_chooser_set_current_name(file_chooser, wxGTK_CONV_FN(fname)); } #if GTK_CHECK_VERSION(2,7,3) if ((style & wxFD_OVERWRITE_PROMPT) #ifndef __WXGTK3__ && gtk_check_version(2,7,3) == NULL #endif ) { gtk_file_chooser_set_do_overwrite_confirmation(file_chooser, true); } #endif } else // wxFD_OPEN { if ( !fname.empty() ) { gtk_file_chooser_set_filename(file_chooser, wxGTK_CONV_FN(fn.GetFullPath())); } } if ( style & wxFD_PREVIEW ) { GtkWidget *previewImage = gtk_image_new(); gtk_file_chooser_set_preview_widget(file_chooser, previewImage); g_signal_connect(m_widget, "update-preview", G_CALLBACK(gtk_filedialog_update_preview_callback), previewImage); } return true; }
static void gimp_file_entry_browse_clicked (GtkWidget *widget, GimpFileEntry *entry) { GtkFileChooser *chooser; gchar *utf8; gchar *filename; utf8 = gtk_editable_get_chars (GTK_EDITABLE (entry->entry), 0, -1); filename = g_filename_from_utf8 (utf8, -1, NULL, NULL, NULL); g_free (utf8); if (! entry->file_dialog) { const gchar *title = entry->title; if (! title) { if (entry->dir_only) title = _("Select Folder"); else title = _("Select File"); } entry->file_dialog = gtk_file_chooser_dialog_new (title, NULL, entry->dir_only ? GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER : GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (entry->file_dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); chooser = GTK_FILE_CHOOSER (entry->file_dialog); gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE); gtk_window_set_role (GTK_WINDOW (chooser), "gimp-file-entry-file-dialog"); g_signal_connect (chooser, "response", G_CALLBACK (gimp_file_entry_chooser_response), entry); g_signal_connect (chooser, "delete-event", G_CALLBACK (gtk_true), NULL); g_signal_connect_swapped (entry, "unmap", G_CALLBACK (gtk_widget_hide), chooser); } else { chooser = GTK_FILE_CHOOSER (entry->file_dialog); } gtk_file_chooser_set_filename (chooser, filename); g_free (filename); gtk_window_set_screen (GTK_WINDOW (chooser), gtk_widget_get_screen (widget)); gtk_window_present (GTK_WINDOW (chooser)); }
NS_IMETHODIMP nsFilePicker::Show(PRInt16 *aReturn) { NS_ENSURE_ARG_POINTER(aReturn); nsXPIDLCString title; title.Adopt(ToNewUTF8String(mTitle)); GtkWindow *parent_widget = get_gtk_window_for_nsiwidget(mParentWidget); GtkFileChooserAction action = GetGtkFileChooserAction(mMode); const gchar *accept_button = (action == GTK_FILE_CHOOSER_ACTION_SAVE) ? GTK_STOCK_SAVE : GTK_STOCK_OPEN; #if (MOZ_PLATFORM_MAEMO == 5) GtkWidget *file_chooser = hildon_file_chooser_dialog_new_with_properties(parent_widget, "action", action, "open-button-text", accept_button, NULL); gtk_window_set_title(GTK_WINDOW(file_chooser), title); #else GtkWidget *file_chooser = gtk_file_chooser_dialog_new(title, parent_widget, action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, accept_button, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_alternative_button_order(GTK_DIALOG(file_chooser), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); if (mAllowURLs) { gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(file_chooser), FALSE); } #endif if (action == GTK_FILE_CHOOSER_ACTION_OPEN || action == GTK_FILE_CHOOSER_ACTION_SAVE) { GtkWidget *img_preview = gtk_image_new(); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(file_chooser), img_preview); g_signal_connect(file_chooser, "update-preview", G_CALLBACK(UpdateFilePreviewWidget), img_preview); } if (parent_widget && parent_widget->group) { gtk_window_group_add_window(parent_widget->group, GTK_WINDOW(file_chooser)); } NS_ConvertUTF16toUTF8 defaultName(mDefault); switch (mMode) { case nsIFilePicker::modeOpenMultiple: gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser), TRUE); break; case nsIFilePicker::modeSave: gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(file_chooser), defaultName.get()); break; } nsCOMPtr<nsIFile> defaultPath; if (mDisplayDirectory) { mDisplayDirectory->Clone(getter_AddRefs(defaultPath)); } else if (mPrevDisplayDirectory) { mPrevDisplayDirectory->Clone(getter_AddRefs(defaultPath)); } if (defaultPath) { if (!defaultName.IsEmpty() && mMode != nsIFilePicker::modeSave) { // Try to select the intended file. Even if it doesn't exist, GTK still switches // directories. defaultPath->AppendNative(defaultName); nsCAutoString path; defaultPath->GetNativePath(path); gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file_chooser), path.get()); } else { nsCAutoString directory; defaultPath->GetNativePath(directory); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), directory.get()); } } gtk_dialog_set_default_response(GTK_DIALOG(file_chooser), GTK_RESPONSE_ACCEPT); PRInt32 count = mFilters.Length(); for (PRInt32 i = 0; i < count; ++i) { // This is fun... the GTK file picker does not accept a list of filters // so we need to split out each string, and add it manually. char **patterns = g_strsplit(mFilters[i].get(), ";", -1); if (!patterns) { return NS_ERROR_OUT_OF_MEMORY; } GtkFileFilter *filter = gtk_file_filter_new(); for (int j = 0; patterns[j] != NULL; ++j) { nsCAutoString caseInsensitiveFilter = MakeCaseInsensitiveShellGlob(g_strstrip(patterns[j])); gtk_file_filter_add_pattern(filter, caseInsensitiveFilter.get()); } g_strfreev(patterns); if (!mFilterNames[i].IsEmpty()) { // If we have a name for our filter, let's use that. const char *filter_name = mFilterNames[i].get(); gtk_file_filter_set_name(filter, filter_name); } else { // If we don't have a name, let's just use the filter pattern. const char *filter_pattern = mFilters[i].get(); gtk_file_filter_set_name(filter, filter_pattern); } gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser), filter); // Set the initially selected filter if (mSelectedType == i) { gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(file_chooser), filter); } } gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser), PR_TRUE); gint response = RunDialog(GTK_DIALOG(file_chooser)); switch (response) { case GTK_RESPONSE_OK: case GTK_RESPONSE_ACCEPT: ReadValuesFromFileChooser(file_chooser); *aReturn = nsIFilePicker::returnOK; if (mMode == nsIFilePicker::modeSave) { nsCOMPtr<nsILocalFile> file; GetFile(getter_AddRefs(file)); if (file) { PRBool exists = PR_FALSE; file->Exists(&exists); if (exists) *aReturn = nsIFilePicker::returnReplace; } } break; case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_CLOSE: case GTK_RESPONSE_DELETE_EVENT: *aReturn = nsIFilePicker::returnCancel; break; default: NS_WARNING("Unexpected response"); *aReturn = nsIFilePicker::returnCancel; break; } gtk_widget_destroy(file_chooser); return NS_OK; }
bool wxGtkFileCtrl::Create( wxWindow *parent, wxWindowID id, const wxString& defaultDirectory, const wxString& defaultFileName, const wxString& wildCard, long style, const wxPoint& pos, const wxSize& size, const wxString& name ) { if ( !PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ) ) { wxFAIL_MSG( wxT( "wxGtkFileCtrl creation failed" ) ); return false; } GtkFileChooserAction gtkAction = GTK_FILE_CHOOSER_ACTION_OPEN; if ( style & wxFC_SAVE ) gtkAction = GTK_FILE_CHOOSER_ACTION_SAVE; m_widget = gtk_alignment_new ( 0, 0, 1, 1 ); g_object_ref(m_widget); m_fcWidget = GTK_FILE_CHOOSER( gtk_file_chooser_widget_new(gtkAction) ); gtk_widget_show ( GTK_WIDGET( m_fcWidget ) ); gtk_container_add ( GTK_CONTAINER ( m_widget ), GTK_WIDGET( m_fcWidget ) ); m_focusWidget = GTK_WIDGET( m_fcWidget ); g_signal_connect ( m_fcWidget, "file-activated", G_CALLBACK ( gtkfilechooserwidget_file_activated_callback ), this ); g_signal_connect ( m_fcWidget, "current-folder-changed", G_CALLBACK ( gtkfilechooserwidget_folder_changed_callback ), this ); g_signal_connect ( m_fcWidget, "selection-changed", G_CALLBACK ( gtkfilechooserwidget_selection_changed_callback ), this ); g_signal_connect ( m_fcWidget, "notify", G_CALLBACK ( gtkfilechooserwidget_notify_callback ), this ); m_fc.SetWidget( m_fcWidget ); if ( style & wxFC_MULTIPLE ) gtk_file_chooser_set_select_multiple( m_fcWidget, true ); SetWildcard( wildCard ); // if defaultDir is specified it should contain the directory and // defaultFileName should contain the default name of the file, however if // directory is not given, defaultFileName contains both wxFileName fn; if ( defaultDirectory.empty() ) fn.Assign( defaultFileName ); else if ( !defaultFileName.empty() ) fn.Assign( defaultDirectory, defaultFileName ); else fn.AssignDir( defaultDirectory ); // set the initial file name and/or directory const wxString dir = fn.GetPath(); if ( !dir.empty() ) { gtk_file_chooser_set_current_folder( m_fcWidget, dir.fn_str() ); } const wxString fname = fn.GetFullName(); if ( style & wxFC_SAVE ) { if ( !fname.empty() ) { gtk_file_chooser_set_current_name( m_fcWidget, fname.fn_str() ); } } else // wxFC_OPEN { if ( !fname.empty() ) { gtk_file_chooser_set_filename( m_fcWidget, fn.GetFullPath().fn_str() ); } } m_parent->DoAddChild( this ); PostCreation( size ); return TRUE; }
EAPMethodPEAP * eap_method_peap_new (WirelessSecurity *ws_parent, NMConnection *connection, gboolean is_editor, gboolean secrets_only) { EAPMethod *parent; EAPMethodPEAP *method; GtkWidget *widget, *widget_ca_not_required_checkbox; GtkFileFilter *filter; NMSetting8021x *s_8021x = NULL; const char *filename; parent = eap_method_init (sizeof (EAPMethodPEAP), validate, add_to_size_group, fill_connection, update_secrets, destroy, "/org/gnome/control-center/network/eap-method-peap.ui", "eap_peap_notebook", "eap_peap_anon_identity_entry", FALSE); if (!parent) return NULL; parent->password_flags_name = NM_SETTING_802_1X_PASSWORD; method = (EAPMethodPEAP *) parent; method->sec_parent = ws_parent; method->is_editor = is_editor; if (connection) s_8021x = nm_connection_get_setting_802_1x (connection); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_not_required_checkbox")); g_assert (widget); g_signal_connect (G_OBJECT (widget), "toggled", (GCallback) ca_cert_not_required_toggled, parent); g_signal_connect (G_OBJECT (widget), "toggled", (GCallback) wireless_security_changed_cb, ws_parent); widget_ca_not_required_checkbox = widget; widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_button")); g_assert (widget); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (widget), TRUE); gtk_file_chooser_button_set_title (GTK_FILE_CHOOSER_BUTTON (widget), _("Choose a Certificate Authority certificate")); g_signal_connect (G_OBJECT (widget), "selection-changed", (GCallback) wireless_security_changed_cb, ws_parent); filter = eap_method_default_file_chooser_filter_new (FALSE); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (widget), filter); if (connection && s_8021x) { filename = NULL; if (nm_setting_802_1x_get_ca_cert_scheme (s_8021x) == NM_SETTING_802_1X_CK_SCHEME_PATH) { filename = nm_setting_802_1x_get_ca_cert_path (s_8021x); if (filename) gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (widget), filename); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget_ca_not_required_checkbox), !filename && eap_method_ca_cert_ignore_get (parent, connection)); } widget = inner_auth_combo_init (method, connection, s_8021x, secrets_only); inner_auth_combo_changed_cb (widget, (gpointer) method); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_version_combo")); g_assert (widget); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0); if (s_8021x) { const char *peapver; peapver = nm_setting_802_1x_get_phase1_peapver (s_8021x); if (peapver) { /* Index 0 is "Automatic" */ if (!strcmp (peapver, "0")) gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1); else if (!strcmp (peapver, "1")) gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 2); } } g_signal_connect (G_OBJECT (widget), "changed", (GCallback) wireless_security_changed_cb, ws_parent); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_anon_identity_entry")); if (s_8021x && nm_setting_802_1x_get_anonymous_identity (s_8021x)) gtk_entry_set_text (GTK_ENTRY (widget), nm_setting_802_1x_get_anonymous_identity (s_8021x)); g_signal_connect (G_OBJECT (widget), "changed", (GCallback) wireless_security_changed_cb, ws_parent); if (secrets_only) { widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_anon_identity_label")); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_anon_identity_entry")); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_label")); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_button")); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_ca_cert_not_required_checkbox")); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_inner_auth_label")); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_inner_auth_combo")); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_version_label")); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_version_combo")); gtk_widget_hide (widget); } return method; }
static void xfburn_burn_image_dialog_init (XfburnBurnImageDialog * obj) { GtkBox *box = GTK_BOX (GTK_DIALOG (obj)->vbox); XfburnBurnImageDialogPrivate *priv = XFBURN_BURN_IMAGE_DIALOG_GET_PRIVATE (obj); GdkPixbuf *icon = NULL; GtkFileFilter *filter; GtkWidget *frame; GtkWidget *vbox; GtkWidget *button; XfburnDevice *device; gtk_window_set_title (GTK_WINDOW (obj), _("Burn image")); gtk_window_set_destroy_with_parent (GTK_WINDOW (obj), TRUE); icon = gtk_widget_render_icon (GTK_WIDGET (obj), XFBURN_STOCK_BURN_CD, GTK_ICON_SIZE_DIALOG, NULL); gtk_window_set_icon (GTK_WINDOW (obj), icon); g_object_unref (icon); /* file */ priv->chooser_image = gtk_file_chooser_button_new (_("Image to burn"), GTK_FILE_CHOOSER_ACTION_OPEN); gtk_widget_show (priv->chooser_image); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All files")); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(priv->chooser_image), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("ISO images")); gtk_file_filter_add_pattern (filter, "*.[iI][sS][oO]"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (priv->chooser_image), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (priv->chooser_image), filter); if(xfburn_main_has_initial_dir ()) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (priv->chooser_image), xfburn_main_get_initial_dir ()); } if (last_file) { gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (priv->chooser_image), last_file); } frame = xfce_gtk_frame_box_new_with_content (_("Image to burn"), priv->chooser_image); gtk_widget_show (frame); gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER); /* red label for image */ priv->image_label = gtk_label_new (""); gtk_widget_show (priv->image_label); gtk_box_pack_start (GTK_BOX (box), priv->image_label, FALSE, FALSE, 0); update_image_label (GTK_FILE_CHOOSER (priv->chooser_image), obj); g_signal_connect (G_OBJECT (priv->chooser_image), "selection-changed", G_CALLBACK (update_image_label), obj); /* devices list */ priv->device_box = xfburn_device_box_new (SHOW_CD_WRITERS | SHOW_CDRW_WRITERS | SHOW_DVD_WRITERS | SHOW_MODE_SELECTION | SHOW_SPEED_SELECTION); gtk_widget_show (priv->device_box); frame = xfce_gtk_frame_box_new_with_content (_("Burning device"), priv->device_box); gtk_widget_show (frame); gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER); /* options */ vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox); frame = xfce_gtk_frame_box_new_with_content (_("Options"), vbox); gtk_widget_show (frame); gtk_box_pack_start (box, frame, FALSE, FALSE, BORDER); priv->check_eject = gtk_check_button_new_with_mnemonic (_("E_ject disk")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_eject), TRUE); gtk_widget_show (priv->check_eject); gtk_box_pack_start (GTK_BOX (vbox), priv->check_eject, FALSE, FALSE, BORDER); priv->check_dummy = gtk_check_button_new_with_mnemonic (_("_Dummy write")); gtk_widget_show (priv->check_dummy); gtk_box_pack_start (GTK_BOX (vbox), priv->check_dummy, FALSE, FALSE, BORDER); priv->check_burnfree = gtk_check_button_new_with_mnemonic (_("Burn_Free")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_burnfree), TRUE); gtk_widget_show (priv->check_burnfree); gtk_box_pack_start (GTK_BOX (vbox), priv->check_burnfree, FALSE, FALSE, BORDER); priv->check_stream_recording = gtk_check_button_new_with_mnemonic (_("Stream _Recording")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_stream_recording), TRUE); gtk_widget_show (priv->check_stream_recording); gtk_box_pack_start (GTK_BOX (vbox), priv->check_stream_recording, FALSE, FALSE, BORDER); priv->check_quit = gtk_check_button_new_with_mnemonic (_("_Quit after success")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->check_quit), xfburn_settings_get_boolean("quit_after_success", FALSE)); gtk_widget_show (priv->check_quit); gtk_box_pack_start (GTK_BOX (vbox), priv->check_quit, FALSE, FALSE, BORDER); /* action buttons */ button = gtk_button_new_from_stock (GTK_STOCK_CANCEL); gtk_widget_show (button); gtk_dialog_add_action_widget (GTK_DIALOG (obj), button, GTK_RESPONSE_CANCEL); priv->burn_button = xfburn_gtk_button_new_mixed (XFBURN_STOCK_BURN_CD, _("_Burn image")); gtk_widget_show (priv->burn_button); g_signal_connect (G_OBJECT (priv->burn_button), "clicked", G_CALLBACK (cb_clicked_ok), obj); gtk_container_add (GTK_CONTAINER( GTK_DIALOG(obj)->action_area), priv->burn_button); //gtk_dialog_add_action_widget (GTK_DIALOG (obj), button, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (priv->burn_button, GTK_CAN_DEFAULT); gtk_widget_grab_focus (priv->burn_button); gtk_widget_grab_default (priv->burn_button); priv->devlist = xfburn_device_list_new (); priv->handler_volchange = g_signal_connect (G_OBJECT (priv->devlist), "volume-change-end", G_CALLBACK (cb_volume_change_end), obj); g_signal_connect (G_OBJECT (obj), "response", G_CALLBACK (cb_dialog_response), obj); device = xfburn_device_list_get_current_device (priv->devlist); if (device) cb_volume_change_end (priv->devlist, TRUE, device, obj); }
FileInfo *get_fileinfo_from_selector(FileInfo *fi, gint requested_mode) { FileInfo *selected_fi; GtkWidget *selector; gchar *basename, *str; gint res, len; /* init values */ mode = requested_mode; selected_fi = g_malloc(sizeof(FileInfo)); selected_fi->filename = fi->filename ? g_strdup(fi->filename) : NULL; selected_fi->charset = fi->charset ? g_strdup(fi->charset) : NULL; selected_fi->charset_flag = fi->charset_flag; selected_fi->lineend = fi->lineend; selector = create_file_selector(selected_fi); gtk_window_set_transient_for(GTK_WINDOW(selector), GTK_WINDOW(pub->mw->window)); do { res = gtk_dialog_run(GTK_DIALOG(selector)); if (res == GTK_RESPONSE_OK) { if (selected_fi->filename) g_free(selected_fi->filename); #if ENABLE_CHOOSER selected_fi->filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(selector)); #else selected_fi->filename = g_strdup( gtk_file_selection_get_filename(GTK_FILE_SELECTION(selector))); #endif if (g_file_test(selected_fi->filename, G_FILE_TEST_IS_DIR)) { len = strlen(selected_fi->filename); if (len < 1 || selected_fi->filename[len - 1] != G_DIR_SEPARATOR) str = g_strconcat(selected_fi->filename, G_DIR_SEPARATOR_S, NULL); else str = g_strdup(selected_fi->filename); #if ENABLE_CHOOSER gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(selector), str); #else gtk_file_selection_set_filename(GTK_FILE_SELECTION(selector), str); #endif g_free(str); continue; } if ((mode == SAVE) && g_file_test(selected_fi->filename, G_FILE_TEST_EXISTS)) { basename = g_path_get_basename(selected_fi->filename); str = g_strdup_printf(_("'%s' already exists. Overwrite?"), basename); g_free(basename); res = run_dialog_message_question(selector, str); g_free(str); switch (res) { case GTK_RESPONSE_NO: continue; case GTK_RESPONSE_YES: res = GTK_RESPONSE_OK; } } } gtk_widget_hide(selector); } while (GTK_WIDGET_VISIBLE(selector)); if (res != GTK_RESPONSE_OK) { if (selected_fi->charset) g_free(selected_fi->charset); selected_fi = NULL; g_free(selected_fi); } gtk_widget_destroy(selector); return selected_fi; }
GtkWidget* gtr_torrent_options_dialog_new (GtkWindow * parent, TrCore * core, tr_ctor * ctor) { const char * str; GtkWidget * w; GtkWidget * d; GtkGrid * grid; int row; GtkWidget * l; GtkWidget * source_chooser; struct OpenData * data; bool flag; GSList * list; GSList * walk; /* make the dialog */ d = gtk_dialog_new_with_buttons (_("Torrent Options"), parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT); gtk_dialog_set_alternative_button_order (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1); gtk_window_set_default_size(GTK_WINDOW(d), gtr_pref_int_get (TR_KEY_details_window_width), gtr_pref_int_get (TR_KEY_details_window_height)); if (!tr_ctorGetDownloadDir (ctor, TR_FORCE, &str)) g_assert_not_reached (); g_assert (str); data = g_new0 (struct OpenData, 1); data->core = core; data->ctor = ctor; data->filename = g_strdup (tr_ctorGetSourceFile (ctor)); data->downloadDir = g_strdup (str); data->file_list = gtr_file_list_new (core, 0); str = _("Mo_ve .torrent file to the trash"); data->trash_check = gtk_check_button_new_with_mnemonic (str); str = _("_Start when added"); data->run_check = gtk_check_button_new_with_mnemonic (str); w = data->priority_combo = gtr_priority_combo_new (); gtr_priority_combo_set_value (GTK_COMBO_BOX (w), TR_PRI_NORMAL); g_signal_connect (G_OBJECT (d), "response", G_CALLBACK (addResponseCB), data); row = 0; grid = GTK_GRID (gtk_grid_new ()); gtk_container_set_border_width (GTK_CONTAINER (grid), GUI_PAD_BIG); gtk_grid_set_row_spacing (grid, GUI_PAD); gtk_grid_set_column_spacing (grid, GUI_PAD_BIG); /* "torrent file" row */ l = gtk_label_new_with_mnemonic (_("_Torrent file:")); gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 1, 1); w = gtk_file_chooser_button_new (_("Select Source File"), GTK_FILE_CHOOSER_ACTION_OPEN); source_chooser = w; gtk_widget_set_hexpand (w, TRUE); gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (l), w); addTorrentFilters (GTK_FILE_CHOOSER (w)); g_signal_connect (w, "selection-changed", G_CALLBACK (sourceChanged), data); /* "destination folder" row */ row++; l = gtk_label_new_with_mnemonic (_("_Destination folder:")); gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 1, 1); w = gtk_file_chooser_button_new (_("Select Destination Folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); if (!gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w), data->downloadDir)) g_warning ("couldn't select '%s'", data->downloadDir); list = get_recent_destinations (); for (walk = list; walk; walk = walk->next) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (w), walk->data, NULL); g_slist_free (list); gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (l), w); g_signal_connect (w, "selection-changed", G_CALLBACK (downloadDirChanged), data); row++; l = data->freespace_label = gtr_freespace_label_new (core, data->downloadDir); gtk_widget_set_margin_bottom (l, GUI_PAD_BIG); gtk_misc_set_alignment (GTK_MISC (l), 1.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 2, 1); /* file list row */ row++; w = data->file_list; gtk_widget_set_vexpand (w, TRUE); gtk_widget_set_size_request (w, 466u, 300u); gtk_grid_attach (grid, w, 0, row, 2, 1); /* torrent priority row */ row++; l = gtk_label_new_with_mnemonic (_("Torrent _priority:")); gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f); gtk_grid_attach (grid, l, 0, row, 1, 1); w = data->priority_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (l), w); gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1); /* torrent priority row */ row++; w = data->run_check; if (!tr_ctorGetPaused (ctor, TR_FORCE, &flag)) g_assert_not_reached (); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), !flag); gtk_grid_attach (grid, w, 0, row, 2, 1); /* "trash .torrent file" row */ row++; w = data->trash_check; if (!tr_ctorGetDeleteSource (ctor, &flag)) g_assert_not_reached (); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), flag); gtk_grid_attach (grid, w, 0, row, 2, 1); /* trigger sourceChanged, either directly or indirectly, * so that it creates the tor/gtor objects */ w = source_chooser; if (data->filename) gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (w), data->filename); else sourceChanged (GTK_FILE_CHOOSER_BUTTON (w), data); gtr_dialog_set_content (GTK_DIALOG (d), GTK_WIDGET (grid)); w = gtk_dialog_get_widget_for_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT); gtk_widget_grab_focus (w); return d; }
/* http://bugzilla.gnome.org/show_bug.cgi?id=347883 */ static gboolean test_confirm_overwrite_for_path (const char *path, gboolean append_extension) { gboolean passed; struct confirm_overwrite_closure closure; char *filename; passed = TRUE; closure.extension = NULL; closure.confirm_overwrite_signal_emitted = 0; closure.chooser = gtk_file_chooser_dialog_new ("hello", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); closure.accept_button = gtk_dialog_add_button (GTK_DIALOG (closure.chooser), GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT); gtk_dialog_set_default_response (GTK_DIALOG (closure.chooser), GTK_RESPONSE_ACCEPT); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (closure.chooser), TRUE); g_signal_connect (closure.chooser, "confirm-overwrite", G_CALLBACK (confirm_overwrite_cb), &closure); if (append_extension) { char *extension; filename = g_path_get_dirname (path); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (closure.chooser), filename); g_free (filename); filename = g_path_get_basename (path); extension = strchr (filename, '.'); if (extension) { closure.extension = g_strdup (extension); *extension = '\0'; } gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (closure.chooser), filename); g_free (filename); g_signal_connect (closure.chooser, "response", G_CALLBACK (overwrite_response_cb), &closure); } else { gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (closure.chooser), path); } gdk_threads_add_timeout_full (G_MAXINT, SLEEP_DURATION, confirm_overwrite_timeout_cb, &closure, NULL); gtk_dialog_run (GTK_DIALOG (closure.chooser)); filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (closure.chooser)); passed = passed && filename && (strcmp (filename, path) == 0); g_free (filename); gtk_widget_destroy (closure.chooser); passed = passed && (1 == closure.confirm_overwrite_signal_emitted); log_test (passed, "Confirm overwrite for %s", path); return passed; }
static void * search_get_widget (void) { GtkWidget * vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); entry = gtk_entry_new (); gtk_entry_set_icon_from_icon_name ((GtkEntry *) entry, GTK_ENTRY_ICON_PRIMARY, "edit-find"); gtk_entry_set_placeholder_text ((GtkEntry *) entry, _("Search library")); g_signal_connect (entry, "destroy", (GCallback) gtk_widget_destroyed, & entry); gtk_box_pack_start ((GtkBox *) vbox, entry, FALSE, FALSE, 0); help_label = gtk_label_new (_("To import your music library into " "Audacious, choose a folder and then click the \"refresh\" icon.")); gtk_widget_set_size_request (help_label, 194, -1); gtk_label_set_line_wrap ((GtkLabel *) help_label, TRUE); g_signal_connect (help_label, "destroy", (GCallback) gtk_widget_destroyed, & help_label); gtk_widget_set_no_show_all (help_label, TRUE); gtk_box_pack_start ((GtkBox *) vbox, help_label, TRUE, FALSE, 0); wait_label = gtk_label_new (_("Please wait ...")); g_signal_connect (wait_label, "destroy", (GCallback) gtk_widget_destroyed, & wait_label); gtk_widget_set_no_show_all (wait_label, TRUE); gtk_box_pack_start ((GtkBox *) vbox, wait_label, TRUE, FALSE, 0); scrolled = gtk_scrolled_window_new (NULL, NULL); g_signal_connect (scrolled, "destroy", (GCallback) gtk_widget_destroyed, & scrolled); gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled, GTK_SHADOW_IN); gtk_scrolled_window_set_policy ((GtkScrolledWindow *) scrolled, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_widget_set_no_show_all (scrolled, TRUE); gtk_box_pack_start ((GtkBox *) vbox, scrolled, TRUE, TRUE, 0); results_list = audgui_list_new (& list_callbacks, NULL, items ? index_count (items) : 0); g_signal_connect (results_list, "destroy", (GCallback) gtk_widget_destroyed, & results_list); gtk_tree_view_set_headers_visible ((GtkTreeView *) results_list, FALSE); audgui_list_add_column (results_list, NULL, 0, G_TYPE_STRING, -1); gtk_container_add ((GtkContainer *) scrolled, results_list); GtkWidget * hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_end ((GtkBox *) vbox, hbox, FALSE, FALSE, 0); GtkWidget * chooser = gtk_file_chooser_button_new (_("Choose Folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_box_pack_start ((GtkBox *) hbox, chooser, TRUE, TRUE, 0); char * path = get_path (); gtk_file_chooser_set_filename ((GtkFileChooser *) chooser, path); str_unref (path); GtkWidget * button = gtk_button_new (); gtk_container_add ((GtkContainer *) button, gtk_image_new_from_icon_name ("view-refresh", GTK_ICON_SIZE_BUTTON)); gtk_button_set_relief ((GtkButton *) button, GTK_RELIEF_NONE); gtk_box_pack_start ((GtkBox *) hbox, button, FALSE, FALSE, 0); g_signal_connect (entry, "changed", (GCallback) entry_cb, NULL); g_signal_connect (entry, "activate", (GCallback) action_play, NULL); g_signal_connect (button, "clicked", (GCallback) refresh_cb, chooser); gtk_widget_show_all (vbox); gtk_widget_show (results_list); show_hide_widgets (); return vbox; }
/** Select a file Target is the string allocated by caller that will receive the resule, maxlen byte Source is a optionnal last file to replace the selector at the last dir used @Title@ is the title of the dialog window Returns : 0 if error, 1 on success */ uint8_t FileSel_SelectRead(const char *title,char *target,uint32_t max, const char *source) { GtkWidget *dialog; uint8_t ret=0; gchar *selected_filename; gchar last; char *dupe=NULL,*tmpname=NULL; DIR *dir=NULL; dialog = gtk_file_chooser_dialog_new ("Open File", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_title (GTK_WINDOW (dialog),title); initFileSelector(); setFilter(dialog); gtk_register_dialog(dialog); // gtk_transient(dialog); if(source) { dupe=PathCanonize(source); PathStripName(dupe); if( (dir=opendir(dupe)) ) { closedir(dir); gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),(gchar *)source); } delete [] dupe; } else //use pref { if( prefs->get(LASTDIR_READ,&tmpname)) { dupe=PathCanonize(tmpname); PathStripName(dupe); if( (dir=opendir(dupe)) ) { closedir(dir); gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),(gchar *)dupe); } delete [] dupe; } } if(gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_ACCEPT) { selected_filename= (gchar *) gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); if(strlen(selected_filename)) { last=selected_filename[strlen(selected_filename) - 1]; if (last == '/' || last =='\\' ) { GUI_Error_HIG("Cannot open directory as a file", NULL); return 0; } else { // Check we can read it .. FILE *fd; fd=fopen(selected_filename,"rb"); if(fd) { fclose(fd); strncpy(target,(char *)selected_filename,max); // Finally we accept it :) ret=1; } } } } gtk_unregister_dialog(dialog); gtk_widget_destroy(dialog); return ret; }