static char * select_file (bool_t save, const char * default_filename) { GtkWidget * dialog = gtk_file_chooser_dialog_new (save ? _("Export Playlist") : _("Import Playlist"), NULL, save ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN, NULL, NULL); if (default_filename) gtk_file_chooser_set_uri ((GtkFileChooser *) dialog, default_filename); gtk_dialog_add_button ((GtkDialog *) dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT); gtk_dialog_add_button ((GtkDialog *) dialog, save ? GTK_STOCK_SAVE : GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT); gtk_dialog_set_default_response ((GtkDialog *) dialog, GTK_RESPONSE_ACCEPT); char * path = aud_get_string ("audgui", "playlist_path"); if (path[0]) gtk_file_chooser_set_current_folder_uri ((GtkFileChooser *) dialog, path); g_free (path); char * filename = NULL; if (gtk_dialog_run ((GtkDialog *) dialog) == GTK_RESPONSE_ACCEPT) filename = gtk_file_chooser_get_uri ((GtkFileChooser *) dialog); path = gtk_file_chooser_get_current_folder_uri ((GtkFileChooser *) dialog); aud_set_string ("audgui", "playlist_path", path); g_free (path); gtk_widget_destroy (dialog); return filename; }
void on_prop_browse_file (GtkButton *button, gpointer user_data) { GtkWidget *dlg = gtk_file_chooser_dialog_new (_("Open file..."), GTK_WINDOW (mainwin), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dlg), FALSE); // restore folder deadbeef->conf_lock (); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (dlg), deadbeef->conf_get_str_fast ("filechooser.lastdir", "")); deadbeef->conf_unlock (); int response = gtk_dialog_run (GTK_DIALOG (dlg)); // store folder gchar *folder = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (dlg)); if (folder) { deadbeef->conf_set_str ("filechooser.lastdir", folder); g_free (folder); deadbeef->sendmessage (DB_EV_CONFIGCHANGED, 0, 0, 0); } if (response == GTK_RESPONSE_OK) { gchar *file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dlg)); gtk_widget_destroy (dlg); if (file) { GtkWidget *entry = GTK_WIDGET (user_data); gtk_entry_set_text (GTK_ENTRY (entry), file); g_free (file); } } else { gtk_widget_destroy (dlg); } }
static void file_export_dialog_response (GtkWidget *dialog, gint response_id, gpointer data) { if (response_id == FILE_SAVE_RESPONSE_OTHER_DIALOG) { GimpFileDialog *file_dialog = GIMP_FILE_DIALOG (dialog); GtkWindow *parent; GtkWidget *other; gchar *folder; gchar *uri; gchar *name; parent = gtk_window_get_transient_for (GTK_WINDOW (dialog)); folder = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (dialog)); uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog)); name = file_utils_uri_display_basename (uri); g_free (uri); other = file_save_dialog_show (file_dialog->image->gimp, file_dialog->image, GTK_WIDGET (parent), _("Save Image"), FALSE, FALSE, NULL); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (other), folder); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (other), name); g_free (folder); g_free (name); } }
JNIEXPORT jstring JNICALL Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1get_1current_1folder_1uri ( JNIEnv* env, jclass cls, jlong _self ) { gchar* result; jstring _result; GtkFileChooser* self; // convert parameter self self = (GtkFileChooser*) _self; // call function result = gtk_file_chooser_get_current_folder_uri(self); // cleanup parameter self // translate return value to JNI type _result = (jstring) bindings_java_newString(env, result); // cleanup return value if (result != NULL) { g_free(result); } // and finally return _result; }
/* See VikDataSourceInterface */ static void datasource_file_get_cmd_string ( datasource_file_widgets_t *widgets, gchar **cmd, gchar **input_file ) { gchar *filename, *type; /* Retrieve the file selected */ filename = gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER(widgets->file) ); /* Memorize the directory for later use */ g_free (last_folder_uri); last_folder_uri = gtk_file_chooser_get_current_folder_uri ( GTK_FILE_CHOOSER(widgets->file) ); last_folder_uri = g_strdup (last_folder_uri); /* Memorize the file filter for later use */ GtkFileFilter *filter = gtk_file_chooser_get_filter ( GTK_FILE_CHOOSER(widgets->file) ); last_file_filter = g_object_get_data ( G_OBJECT(filter), "Babel" ); /* Retrieve and memorize file format selected */ last_type = gtk_combo_box_get_active ( GTK_COMBO_BOX (widgets->type) ); type = ((BabelFile*)g_list_nth_data (a_babel_file_list, last_type))->name; /* Build the string */ *cmd = g_strdup_printf( "-i %s", type); *input_file = g_strdup(filename); /* Free memory */ g_free (filename); g_debug(_("using babel args '%s' and file '%s'"), *cmd, *input_file); }
static void baseuri_changed_cb (GSettings *settings, const gchar *key, gpointer user_data) { /* * The conflict between separation of the prefs and the main window, * and the problem of duplication, is very clear here. This code is * identical to the code in the main key listener, but modifying the * prefs window from the main is ugly. Maybe put the validation code * into sj-utils? */ const char* base_uri, *current_uri; g_return_if_fail (strcmp (key, SJ_SETTINGS_BASEURI) == 0); base_uri = g_settings_get_string (settings, key); if (base_uri == NULL || base_uri[0] == '\0') { GFile *dir; char *dir_uri; dir = sj_get_default_music_directory (); dir_uri = g_file_get_uri (dir); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (basepath_fcb), dir_uri); g_free (dir_uri); g_object_unref (dir); } else { current_uri = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (basepath_fcb)); if (current_uri == NULL || strcmp (current_uri, base_uri) != 0) gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (basepath_fcb), base_uri); } }
static void get_options_from_widgets (DialogData *data, char **base_dir, char **filename, const char **include_files, const char **exclude_files, const char **exclude_folders, gboolean *update, gboolean *recursive, gboolean *no_symlinks) { *base_dir = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (data->dialog)); *filename = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (data->dialog)); *update = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->add_if_newer_checkbutton)); *recursive = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->include_subfold_checkbutton)); *no_symlinks = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->exclude_symlinks)); *include_files = gtk_entry_get_text (GTK_ENTRY (data->include_files_entry)); if (utf8_only_spaces (*include_files)) *include_files = ""; *exclude_files = gtk_entry_get_text (GTK_ENTRY (data->exclude_files_entry)); if (utf8_only_spaces (*exclude_files)) *exclude_files = ""; *exclude_folders = gtk_entry_get_text (GTK_ENTRY (data->exclude_folders_entry)); if (utf8_only_spaces (*exclude_folders)) *exclude_folders = ""; }
/* See VikDataSourceInterface */ static void datasource_file_get_process_options ( datasource_file_widgets_t *widgets, ProcessOptions *po, gpointer not_used, const gchar *not_used2, const gchar *not_used3 ) { /* Retrieve the file selected */ gchar *filename = gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER(widgets->file) ); /* Memorize the directory for later use */ g_free (last_folder_uri); last_folder_uri = gtk_file_chooser_get_current_folder_uri ( GTK_FILE_CHOOSER(widgets->file) ); /* Memorize the file filter for later use */ GtkFileFilter *filter = gtk_file_chooser_get_filter ( GTK_FILE_CHOOSER(widgets->file) ); last_file_filter = g_object_get_data ( G_OBJECT(filter), "Babel" ); /* Retrieve and memorize file format selected */ gchar *type = NULL; last_type = gtk_combo_box_get_active ( GTK_COMBO_BOX (widgets->type) ); type = (a_babel_ui_file_type_selector_get ( widgets->type ))->name; /* Generate the process options */ po->babelargs = g_strdup_printf( "-i %s", type); po->filename = g_strdup(filename); /* Free memory */ g_free (filename); g_debug(_("using babel args '%s' and file '%s'"), po->babelargs, po->filename); }
static void print_current_folder (GtkFileChooser *chooser) { gchar *uri; uri = gtk_file_chooser_get_current_folder_uri (chooser); g_print ("Current folder changed :\n %s\n", uri); g_free (uri); }
static void chooser_file_activated_cb (GtkFileChooser *chooser, gpointer user_data) { gchar *folder, *filename; folder = gtk_file_chooser_get_current_folder_uri (chooser); filename = gtk_file_chooser_get_uri (chooser); g_message ("%s::file-activated\n\tFolder: `%s'\n\tFilename: `%s'\nDone.\n", G_OBJECT_TYPE_NAME (chooser), folder, filename); g_free (folder); g_free (filename); }
GFile * gtkhtml_editor_run_open_dialog (GtkhtmlEditor *editor, const gchar *title, GtkCallback customize_func, gpointer customize_data) { GtkFileChooser *file_chooser; GFile *chosen_file = NULL; GtkWidget *dialog; gchar *uri; g_return_val_if_fail (GTKHTML_IS_EDITOR (editor), NULL); dialog = gtk_file_chooser_dialog_new ( title, GTK_WINDOW (editor), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); file_chooser = GTK_FILE_CHOOSER (dialog); gtk_dialog_set_default_response ( GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); gtk_file_chooser_set_local_only (file_chooser, FALSE); /* Restore the current folder from the previous file chooser. */ uri = (gchar *) gtkhtml_editor_get_current_folder (editor); if (uri != NULL) gtk_file_chooser_set_current_folder_uri (file_chooser, uri); /* Allow further customizations before running the dialog. */ if (customize_func != NULL) customize_func (dialog, customize_data); if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_ACCEPT) goto exit; chosen_file = gtk_file_chooser_get_file (file_chooser); /* Save the current folder for subsequent file choosers. */ uri = gtk_file_chooser_get_current_folder_uri (file_chooser); gtkhtml_editor_set_current_folder (editor, uri); g_free (uri); exit: gtk_widget_destroy (dialog); return chosen_file; }
static void clear_options_cb (GtkWidget *w, DialogData *data) { sync_widgets_with_options (data, gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (data->dialog)), gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (data->dialog)), "", "", "", FALSE, TRUE, FALSE); }
/* "destroy" callback; do not call directly */ static void cleanup_job (void * data) { ImportExportJob * job = data; char * folder = gtk_file_chooser_get_current_folder_uri ((GtkFileChooser *) job->selector); aud_set_str ("audgui", "playlist_path", folder); g_free (folder); if (job->confirm) gtk_widget_destroy (job->confirm); g_free (job->filename); g_slice_free (ImportExportJob, job); }
static void datasource_geojson_get_cmd_string ( datasource_geojson_user_data_t *userdata, gchar **cmd, gchar **input_file_type, DownloadMapOptions *options ) { // Retrieve the files selected userdata->filelist = gtk_file_chooser_get_filenames ( GTK_FILE_CHOOSER(userdata->files) ); // Not reusable !! // Memorize the directory for later reuse g_free ( last_folder_uri ); last_folder_uri = gtk_file_chooser_get_current_folder_uri ( GTK_FILE_CHOOSER(userdata->files) ); last_folder_uri = g_strdup ( last_folder_uri ); // TODO Memorize the file filter for later reuse? //GtkFileFilter *filter = gtk_file_chooser_get_filter ( GTK_FILE_CHOOSER(userdata->files) ); // return some value so *thread* processing will continue *cmd = g_strdup ("fake command"); // Not really used, thus no translations }
static void datasource_geotag_get_process_options ( gpointer user_data, ProcessOptions *po, gpointer not_used, const gchar *not_used2, const gchar *not_used3 ) { datasource_geotag_user_data_t *userdata = (datasource_geotag_user_data_t *)user_data; /* Retrieve the files selected */ userdata->filelist = gtk_file_chooser_get_filenames ( GTK_FILE_CHOOSER(userdata->files) ); // Not reusable !! /* Memorize the directory for later use */ g_free ( last_folder_uri ); last_folder_uri = gtk_file_chooser_get_current_folder_uri ( GTK_FILE_CHOOSER(userdata->files) ); last_folder_uri = g_strdup ( last_folder_uri ); /* TODO Memorize the file filter for later use... */ //GtkFileFilter *filter = gtk_file_chooser_get_filter ( GTK_FILE_CHOOSER(userdata->files) ); // return some value so *thread* processing will continue po->babelargs = g_strdup ("fake command"); // Not really used, thus no translations }
int clip_GTK_FILECHOOSERGETCURRENTFOLDERURI(ClipMachine * ClipMachineMemory) { C_object *cchooser = _fetch_co_arg(ClipMachineMemory); gchar *uri; CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object)); uri = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(cchooser->object)); LOCALE_FROM_UTF(uri); _clip_retc(ClipMachineMemory, uri); FREE_TEXT(uri); return 0; err: return 1; }
static void file_selection_cb (GtkFileChooser *chooser, CustomData *data) { gchar *fileURI = gtk_file_chooser_get_uri (chooser); gchar *fileName = gtk_file_chooser_get_filename (chooser); if (NULL == fileURI) { return; } data->last_folder_uri = gtk_file_chooser_get_current_folder_uri (chooser); if (g_file_test(fileName, G_FILE_TEST_IS_DIR)) { return; } if (g_str_has_suffix (fileName, ".m3u")) { gchar *content; g_printf ("m3u selected\n"); if (!g_file_get_contents (fileName, &content, NULL, NULL)) { /* error reading m3u, just do nothing */ return; } fileURI = g_strstrip(g_strdup (content)); g_free (content); } if (audio_is_playing(data)) { /* Don't load the file, only store its filename in * data->nextfile_uri, so it is loaded when the pipe finishes */ g_print ("Next file URI: %s\n", fileURI); data->nextfile_uri = fileURI; return; } audio_stop_player (data); g_print ("File URI: %s\n", fileURI); update_taglabel(data, g_filename_display_basename(fileName)); audio_set_uri (data, fileURI); /* load new file by putting the player into pause state */ audio_pause_player (data); }
GFile * ImageOpenDlg::show(GtkWindow * win, Settings * settings, bool localOnly, bool * attach) { GtkWidget * dialog = gtk_file_chooser_dialog_new(_("Open Image"), win, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), localOnly); GtkFileFilter * filterSupported = gtk_file_filter_new(); gtk_file_filter_set_name(filterSupported, _("Images")); gtk_file_filter_add_pixbuf_formats(filterSupported); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterSupported); if (!settings->getLastImagePath().isEmpty()) { gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(dialog), settings->getLastImagePath().c_str()); } GtkWidget * cbAttach = NULL; if (attach) { cbAttach = gtk_check_button_new_with_label(_("Attach file to the journal")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbAttach), false); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), cbAttach); } GtkWidget * image = gtk_image_new(); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), image); g_signal_connect(dialog, "update-preview", G_CALLBACK(updatePreviewCallback), NULL); gtk_window_set_transient_for(GTK_WINDOW(dialog), win); if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) { gtk_widget_destroy(dialog); return NULL; } GFile * file = gtk_file_chooser_get_file(GTK_FILE_CHOOSER(dialog)); if (attach) { *attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cbAttach)); } char * folder = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog)); settings->setLastImagePath(folder); g_free(folder); gtk_widget_destroy(dialog); return file; }
bool ChooseFiles( bool inLocalOnly, std::vector<MFile>& outFiles) { GtkWidget* dialog = nil; try { dialog = gtk_file_chooser_dialog_new(_("Open"), nil, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); THROW_IF_NIL(dialog); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), true); gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), inLocalOnly); if (gApp->GetCurrentFolder().length() > 0) { gtk_file_chooser_set_current_folder_uri( GTK_FILE_CHOOSER(dialog), gApp->GetCurrentFolder().c_str()); } if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { GSList* uris = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(dialog)); GSList* file = uris; while (file != nil) { MFile url(reinterpret_cast<char*>(file->data), true); g_free(file->data); file->data = nil; outFiles.push_back(url); file = file->next; } g_slist_free(uris); } char* cwd = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog)); if (cwd != nil) { gApp->SetCurrentFolder(cwd); g_free(cwd); } } catch (exception& e) { if (dialog) gtk_widget_destroy(dialog); throw; } gtk_widget_destroy(dialog); return outFiles.size() > 0; }
bool PdfExportJob::showFilechooser() { XOJ_CHECK_TYPE(PdfExportJob); Settings* settings = control->getSettings(); Document* doc = control->getDocument(); GtkWidget* dialog = gtk_file_chooser_dialog_new(_("Export PDF"), (GtkWindow*) *control->getWindow(), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), false); GtkFileFilter* filterPdf = gtk_file_filter_new(); gtk_file_filter_set_name(filterPdf, _("PDF files")); gtk_file_filter_add_pattern(filterPdf, "*.pdf"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterPdf); if (!settings->getLastSavePath().isEmpty()) { gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(dialog), settings->getLastSavePath().c_str()); } String saveFilename = ""; doc->lock(); if (!doc->getFilename().isEmpty()) { saveFilename = control->getFilename(doc->getFilename()); } else if (!doc->getPdfFilename().isEmpty()) { saveFilename = control->getFilename(doc->getPdfFilename()); saveFilename += ".xoj"; } else { time_t curtime = time(NULL); char stime[128]; strftime(stime, sizeof(stime), settings->getDefaultSaveName().c_str(), localtime(&curtime)); saveFilename = stime; if (saveFilename.substring(-4) == ".xoj") { saveFilename = saveFilename.substring(0, -4); } } doc->unlock(); saveFilename += ".pdf"; gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), saveFilename.c_str()); gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), true); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(this->control->getWindow()->getWindow())); if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) { gtk_widget_destroy(dialog); return false; } char* name = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog)); this->filename = name; char* folder = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER( dialog)); settings->setLastSavePath(folder); g_free(folder); g_free(name); gtk_widget_destroy(dialog); return true; }
static void open_dialog_response_handler( GtkDialog *dialog, gint response_id, gpointer data ) { GPtrArray *args = data; GmpvApplication *app = g_ptr_array_index(args, 0); gboolean *append = g_ptr_array_index(args, 1); if(response_id == GTK_RESPONSE_ACCEPT) { GtkFileChooser *file_chooser; GSList *uri_slist; GSList *uri; GSettings *main_config; GSettings *win_config; gboolean last_folder_enable; gsize uri_list_size; const gchar **uri_list; gint i; file_chooser = GTK_FILE_CHOOSER(dialog); uri_slist = gtk_file_chooser_get_filenames(file_chooser); uri = uri_slist; main_config = g_settings_new(CONFIG_ROOT); win_config = g_settings_new(CONFIG_WIN_STATE); last_folder_enable = g_settings_get_boolean (main_config, "last-folder-enable"); uri_list_size = sizeof(gchar **)*(g_slist_length(uri_slist)+1); uri_list = g_malloc(uri_list_size); for(i = 0; uri; i++) { uri_list[i] = uri->data; uri = g_slist_next(uri); } uri_list[i] = NULL; if(uri_slist) { GmpvMpv *mpv = gmpv_application_get_mpv(app); gmpv_mpv_load_list(mpv, uri_list, *append, TRUE); } if(last_folder_enable) { gchar *last_folder_uri = gtk_file_chooser_get_current_folder_uri (file_chooser); g_settings_set_string( win_config, "last-folder-uri", last_folder_uri?:"" ); g_free(last_folder_uri); } g_free(uri_list); g_slist_free_full(uri_slist, g_free); g_object_unref(main_config); g_object_unref(win_config); }
String XojOpenDlg::showOpenDialog(GtkWindow * win, Settings * settings, bool pdf, bool & attachPdf) { GtkWidget * dialog = gtk_file_chooser_dialog_new(_("Open file"), win, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), true); GtkFileFilter *filterAll = gtk_file_filter_new(); gtk_file_filter_set_name(filterAll, _("All files")); gtk_file_filter_add_pattern(filterAll, "*"); GtkFileFilter *filterXoj = gtk_file_filter_new(); gtk_file_filter_set_name(filterXoj, _("Xournal files")); gtk_file_filter_add_pattern(filterXoj, "*.xoj"); GtkFileFilter *filterPdf = gtk_file_filter_new(); gtk_file_filter_set_name(filterPdf, _("PDF files")); gtk_file_filter_add_pattern(filterPdf, "*.pdf"); gtk_file_filter_add_pattern(filterPdf, "*.PDF"); GtkFileFilter *filterSupported = gtk_file_filter_new(); gtk_file_filter_set_name(filterSupported, _("Supported files")); gtk_file_filter_add_pattern(filterSupported, "*.xoj"); gtk_file_filter_add_pattern(filterSupported, "*.pdf"); gtk_file_filter_add_pattern(filterSupported, "*.PDF"); if (!pdf) { gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterSupported); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterXoj); } gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterPdf); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterAll); if (!settings->getLastSavePath().isEmpty()) { gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(dialog), settings->getLastSavePath().c_str()); } GtkWidget * attachOpt = NULL; if (pdf) { attachOpt = gtk_check_button_new_with_label(_("Attach file to the journal")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(attachOpt), FALSE); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), attachOpt); } GtkWidget * image = gtk_image_new(); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), image); g_signal_connect(dialog, "update-preview", G_CALLBACK(updatePreviewCallback), NULL); gtk_window_set_transient_for(GTK_WINDOW(dialog), win); if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) { gtk_widget_destroy(dialog); return NULL; } char * name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); if (attachOpt) { attachPdf = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(attachOpt)); } String filename = name; char * folder = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog)); settings->setLastSavePath(folder); g_free(folder); g_free(name); gtk_widget_destroy(dialog); return filename; }
Php::Value GtkFileChooserDialog_::get_current_folder_uri() { std::string s_uri = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER(instance)); return s_uri.c_str(); }
GSList * show_file_chooser (const gchar *title, enum GtkuiFileChooserType type, gboolean select_multiple) { GtkFileChooserAction action; switch (type) { case GTKUI_FILECHOOSER_OPENFOLDER: action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER; break; case GTKUI_FILECHOOSER_OPENFILE: case GTKUI_FILECHOOSER_LOADPLAYLIST: action = GTK_FILE_CHOOSER_ACTION_OPEN; break; case GTKUI_FILECHOOSER_SAVEPLAYLIST: action = GTK_FILE_CHOOSER_ACTION_SAVE; break; } GtkFileChooser *dlg = get_file_chooser(title, action, select_multiple); switch (type) { case GTKUI_FILECHOOSER_OPENFILE: set_file_filter (dlg, NULL); break; case GTKUI_FILECHOOSER_LOADPLAYLIST: set_file_filter_loadplaylist(dlg); break; case GTKUI_FILECHOOSER_SAVEPLAYLIST: gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dlg), TRUE); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dlg), "untitled.dbpl"); set_file_filter_saveplaylist(dlg); break; } const char *conf_lastdir; switch (type) { case GTKUI_FILECHOOSER_OPENFOLDER: case GTKUI_FILECHOOSER_OPENFILE: conf_lastdir = "filechooser.lastdir"; break; case GTKUI_FILECHOOSER_LOADPLAYLIST: case GTKUI_FILECHOOSER_SAVEPLAYLIST: conf_lastdir = "filechooser.playlist.lastdir"; break; } // restore folder /* Windows: setting current folder for native filechooser here breaks restoring dirs, without it it still works fine? deadbeef->conf_lock (); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (dlg), deadbeef->conf_get_str_fast (conf_lastdir, "")); deadbeef->conf_unlock (); */ int response = run_file_chooser(dlg); // store folder gchar *folder = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (dlg)); if (folder) { deadbeef->conf_set_str (conf_lastdir, folder); g_free (folder); } GSList *lst = NULL; if (response == GTK_RESPONSE_ACCEPT) { lst = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (dlg)); #if defined USE_GTK_NATIVE_FILE_CHOOSER && defined __MINGW32__ // workaround: Gtk's win32 file chooser uses g_slist_prepend internally and forgets to reverse it before returning lst = g_slist_reverse (lst); #endif } destroy_file_chooser (dlg); return lst; }
void on_import_fb2k_preset_clicked (GtkButton *button, gpointer user_data) { GtkWidget *dlg = gtk_file_chooser_dialog_new (_("Import Foobar2000 EQ Preset..."), GTK_WINDOW (mainwin), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); GtkFileFilter* flt; flt = gtk_file_filter_new (); gtk_file_filter_set_name (flt, _("Foobar2000 EQ presets (*.feq)")); gtk_file_filter_add_pattern (flt, "*.feq"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dlg), FALSE); // restore folder deadbeef->conf_lock (); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (dlg), deadbeef->conf_get_str_fast ("filechooser.lastdir", "")); deadbeef->conf_unlock (); int response = gtk_dialog_run (GTK_DIALOG (dlg)); // store folder gchar *folder = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (dlg)); if (folder) { deadbeef->conf_set_str ("filechooser.lastdir", folder); g_free (folder); } if (response == GTK_RESPONSE_OK) { gchar *fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dlg)); if (fname) { FILE *fp = fopen (fname, "rt"); if (fp) { int vals[18]; // integer dBs int i = 0; while (i < 18) { char tmp[20]; char *out = fgets (tmp, sizeof (tmp), fp); if (!out) { break; } vals[i] = atoi (tmp); i++; } fclose (fp); if (i == 18) { // apply and save config ddb_dsp_context_t *eq = get_supereq (); if (eq) { set_param (eq, 0, 0); ddb_equalizer_set_preamp (DDB_EQUALIZER (eqwin), 0); for (int i = 0; i < 18; i++) { ddb_equalizer_set_band (DDB_EQUALIZER (eqwin), i, vals[i]); set_param (eq, i+1, vals[i]); } gtk_widget_queue_draw (eqwin); deadbeef->streamer_dsp_chain_save (); } } else { fprintf (stderr, "[eq] corrupted Foobar2000 preset file, discarded\n"); } } g_free (fname); } } gtk_widget_destroy (dlg); }
static int file_sel_response_cb (GtkWidget *widget, int response, DialogData *data) { GtkFileChooser *file_sel = GTK_FILE_CHOOSER (widget); FrWindow *window = data->window; char *current_folder; char *uri; gboolean update; GSList *selections, *iter; GList *item_list = NULL; current_folder = gtk_file_chooser_get_current_folder_uri (file_sel); uri = gtk_file_chooser_get_uri (file_sel); if (current_folder != NULL) { g_settings_set_string (data->settings, PREF_ADD_CURRENT_FOLDER, current_folder); fr_window_set_add_default_dir (window, current_folder); } if (uri != NULL) { g_settings_set_string (data->settings, PREF_ADD_FILENAME, uri); g_free (uri); } if ((response == GTK_RESPONSE_CANCEL) || (response == GTK_RESPONSE_DELETE_EVENT)) { gtk_widget_destroy (data->dialog); g_free (current_folder); return TRUE; } if (response == GTK_RESPONSE_HELP) { show_help_dialog (GTK_WINDOW (data->dialog), "archive-edit"); g_free (current_folder); return TRUE; } /* check folder permissions. */ if (uri_is_dir (current_folder) && ! check_permissions (current_folder, R_OK)) { GtkWidget *d; char *utf8_path; utf8_path = g_filename_display_name (current_folder); d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_MODAL, NULL, _("Could not add the files to the archive"), _("You don't have the right permissions to read files from folder \"%s\""), utf8_path); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (utf8_path); g_free (current_folder); return FALSE; } update = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->add_if_newer_checkbutton)); /**/ selections = gtk_file_chooser_get_uris (file_sel); for (iter = selections; iter != NULL; iter = iter->next) { char *uri = iter->data; item_list = g_list_prepend (item_list, g_file_new_for_uri (uri)); } if (item_list != NULL) fr_window_archive_add_files (window, item_list, update); gio_file_list_free (item_list); g_slist_foreach (selections, (GFunc) g_free, NULL); g_slist_free (selections); g_free (current_folder); gtk_widget_destroy (data->dialog); return TRUE; }
static void show_open_dialog_handler( GSimpleAction *action, GVariant *param, gpointer data ) { const gchar *pl_exts[] = PLAYLIST_EXTS; GmpvApplication *app = data; GmpvMainWindow *wnd = NULL; GSettings *main_config = NULL; GSettings *win_config = NULL; GtkFileChooser *file_chooser = NULL; GtkFileFilter *filter = NULL; GmpvFileChooser *open_dialog = NULL; gboolean last_folder_enable = FALSE; gboolean append = FALSE; g_variant_get(param, "b", &append); wnd = gmpv_application_get_main_window(app); open_dialog = gmpv_file_chooser_new( append? _("Add File to Playlist"): _("Open File"), GTK_WINDOW(wnd), GTK_FILE_CHOOSER_ACTION_OPEN, _("_Open"), _("_Cancel")); main_config = g_settings_new(CONFIG_ROOT); file_chooser = GTK_FILE_CHOOSER(open_dialog); last_folder_enable = g_settings_get_boolean (main_config, "last-folder-enable"); filter = gtk_file_filter_new(); gtk_file_filter_add_mime_type(filter, "video/*"); gtk_file_filter_add_mime_type(filter, "audio/*"); gtk_file_filter_add_mime_type(filter, "image/*"); for(gint i = 0; pl_exts[i]; i++) { gchar *pattern = g_strdup_printf("*.%s", pl_exts[i]); gtk_file_filter_add_pattern(filter, pattern); g_free(pattern); } gtk_file_chooser_set_filter(file_chooser, filter); if(last_folder_enable) { gchar *last_folder_uri; win_config = g_settings_new(CONFIG_WIN_STATE); last_folder_uri = g_settings_get_string (win_config, "last-folder-uri"); if(last_folder_uri && strlen(last_folder_uri) > 0) { gtk_file_chooser_set_current_folder_uri (file_chooser, last_folder_uri); } g_free(last_folder_uri); } gtk_file_chooser_set_select_multiple(file_chooser, TRUE); if(gmpv_file_chooser_run(open_dialog) == GTK_RESPONSE_ACCEPT) { GSList *uri_slist = gtk_file_chooser_get_filenames(file_chooser); GSList *uri = uri_slist; gsize uri_list_size = sizeof(gchar **)* (g_slist_length(uri_slist)+1); const gchar **uri_list = g_malloc(uri_list_size); gint i; for(i = 0; uri; i++) { uri_list[i] = uri->data; uri = g_slist_next(uri); } uri_list[i] = NULL; if(uri_slist) { GmpvMpvObj *mpv = gmpv_application_get_mpv_obj(app); gmpv_mpv_obj_load_list(mpv, uri_list, append, TRUE); } if(last_folder_enable) { gchar *last_folder_uri = gtk_file_chooser_get_current_folder_uri (file_chooser); g_settings_set_string( win_config, "last-folder-uri", last_folder_uri?:"" ); g_free(last_folder_uri); } g_free(uri_list); g_slist_free_full(uri_slist, g_free); }
bool ChooseOneFile( MFile& ioFile) { GtkWidget* dialog = nil; bool result = false; try { dialog = gtk_file_chooser_dialog_new(_("Select File"), nil, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); THROW_IF_NIL(dialog); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), false); gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), false); if (ioFile.IsValid()) { gtk_file_chooser_select_uri(GTK_FILE_CHOOSER(dialog), ioFile.GetURI().c_str()); } else if (gApp->GetCurrentFolder().length() > 0) { gtk_file_chooser_set_current_folder_uri( GTK_FILE_CHOOSER(dialog), gApp->GetCurrentFolder().c_str()); } if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char* uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog)); if (uri != nil) { ioFile = MFile(uri, true); g_free(uri); gApp->SetCurrentFolder( gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog))); result = true; } } } catch (exception& e) { if (dialog) gtk_widget_destroy(dialog); throw; } gtk_widget_destroy(dialog); return result; }