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;
}
