static void
dlg_extract__common (FrWindow *window,
GList *selected_files,
char *base_dir_for_selection)
{
DialogData *data;
data = g_new0 (DialogData, 1);
data->settings = g_settings_new (FILE_ROLLER_SCHEMA_EXTRACT);
data->window = window;
data->selected_files = selected_files;
data->base_dir_for_selection = base_dir_for_selection;
data->extract_clicked = FALSE;
data->dialog = gtk_file_chooser_dialog_new (C_("Window title", "Extract"),
GTK_WINDOW (data->window),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
_GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL,
_GTK_LABEL_EXTRACT, GTK_RESPONSE_OK,
NULL);
gtk_window_set_default_size (GTK_WINDOW (data->dialog), 530, 510);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (data->dialog), FALSE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->dialog), FALSE);
gtk_file_chooser_set_create_folders (GTK_FILE_CHOOSER (data->dialog), TRUE);
gtk_dialog_set_default_response (GTK_DIALOG (data->dialog), GTK_RESPONSE_OK);
data->builder = _gtk_builder_new_from_resource ("extract-dialog-options.ui");
if (data->builder == NULL)
return;
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (data->dialog), GET_WIDGET ("extra_widget"));
/* Set widgets data. */
gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (data->dialog), fr_window_get_extract_default_dir (window), NULL);
if (data->selected_files != NULL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("selected_files_radiobutton")), TRUE);
else {
gtk_widget_set_sensitive (GET_WIDGET ("selected_files_radiobutton"), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("all_files_radiobutton")), TRUE);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_newer_checkbutton")), g_settings_get_boolean (data->settings, PREF_EXTRACT_SKIP_NEWER));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_structure_checkbutton")), g_settings_get_boolean (data->settings, PREF_EXTRACT_RECREATE_FOLDERS));
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"destroy",
G_CALLBACK (file_selector_destroy_cb),
data);
g_signal_connect (G_OBJECT (data->dialog),
"response",
G_CALLBACK (file_selector_response_cb),
data);
g_signal_connect (G_OBJECT (GET_WIDGET ("file_pattern_entry")),
"changed",
G_CALLBACK (files_entry_changed_cb),
data);
/* Run dialog. */
gtk_window_set_modal (GTK_WINDOW (data->dialog),TRUE);
gtk_widget_show (data->dialog);
}
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);
g_signal_connect (m_widget, "selection-changed",
G_CALLBACK (gtk_filedialog_selchanged_callback), this);
// deal with extensions/filters
SetWildcard(wildCard);
wxString defaultFileNameWithExt = defaultFileName;
if ( !wildCard.empty() && !defaultFileName.empty() &&
!wxFileName(defaultFileName).HasExt() )
{
// append the default extension, if any, to the initial file name: GTK
// won't do it for us by default (unlike e.g. MSW)
const wxFileName fnWC(m_fc.GetCurrentWildCard());
if ( fnWC.HasExt() )
{
// Notice that we shouldn't append the extension if it's a wildcard
// because this is not useful: the user would need to change it to use
// some fixed extension anyhow.
const wxString& ext = fnWC.GetExt();
if ( ext.find_first_of("?*") == wxString::npos )
defaultFileNameWithExt << "." << ext;
}
}
// 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 _lib_import_single_image_callback(GtkWidget *widget,gpointer user_data)
{
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import image"),
GTK_WINDOW (win),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
(char *)NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE);
char *last_directory = dt_conf_get_string("ui_last/import_last_directory");
if(last_directory != NULL)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory);
char *cp, **extensions, ext[1024];
GtkFileFilter *filter;
filter = GTK_FILE_FILTER(gtk_file_filter_new());
extensions = g_strsplit(dt_supported_extensions, ",", 100);
for(char **i=extensions; *i!=NULL; i++)
{
snprintf(ext, 1024, "*.%s", *i);
gtk_file_filter_add_pattern(filter, ext);
gtk_file_filter_add_pattern(filter, cp=g_ascii_strup(ext, -1));
g_free(cp);
}
g_strfreev(extensions);
gtk_file_filter_set_name(filter, _("supported images"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_pattern(filter, "*");
gtk_file_filter_set_name(filter, _("all files"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
GtkWidget *preview = gtk_image_new();
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(filechooser), preview);
g_signal_connect(filechooser, "update-preview", G_CALLBACK (_lib_import_update_preview), preview);
dt_lib_import_metadata_t metadata;
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), _lib_import_get_extra_widget(&metadata, FALSE));
if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)
{
dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser)));
_lib_import_evaluate_extra_widget(&metadata, FALSE);
char *filename = NULL;
dt_film_t film;
GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser));
GSList *it = list;
int id = 0;
int filmid = 0;
/* reset filter to display all images, otherwise view may remain empty */
dt_view_filter_reset_to_show_all(darktable.view_manager);
while(it)
{
filename = (char *)it->data;
gchar *directory = g_path_get_dirname((const gchar *)filename);
filmid = dt_film_new(&film, directory);
id = dt_image_import(filmid, filename, TRUE);
if(!id) dt_control_log(_("error loading file `%s'"), filename);
g_free (filename);
g_free (directory);
it = g_slist_next(it);
}
if(id)
{
dt_film_open(filmid);
// make sure buffers are loaded (load full for testing)
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
if(!buf.buf)
{
dt_control_log(_("file has unknown format!"));
}
else
{
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
DT_CTL_SET_GLOBAL(lib_image_mouse_over_id, id);
dt_ctl_switch_mode_to(DT_DEVELOP);
}
}
}
gtk_widget_destroy(metadata.frame);
gtk_widget_destroy (filechooser);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
}
static int
FileSelectionDialog(GtkWidget *parent, int type, char *stock)
{
struct nGetOpenFileData *data;
GtkWidget *dlg, *rc;
GtkFileFilter *filter;
char *fname;
data = &FileSelection;
data->parent = (parent) ? parent : TopLevel;
dlg = gtk_file_chooser_dialog_new(data->title,
GTK_WINDOW(data->parent),
type,
_("_Cancel"), GTK_RESPONSE_CANCEL,
stock, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dlg), TRUE);
rc = gtk_check_button_new_with_mnemonic(_("_Change current directory"));
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dlg))), rc, FALSE, FALSE, 5);
data->chdir_cb = rc;
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dlg), data->multi);
data->widget = dlg;
if (data->ext) {
char *filter_str, *filter_name, *ext_name;
filter_str = g_strdup_printf("*.%s", data->ext);
ext_name = g_ascii_strup(data->ext, -1);
filter_name = g_strdup_printf(_("%s file (*.%s)"), ext_name, data->ext);
g_free(ext_name);
filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter, filter_str);
gtk_file_filter_set_name(filter, filter_name);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dlg), filter);
g_free(filter_str);
g_free(filter_name);
filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter, "*");
gtk_file_filter_set_name(filter, _("All"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dlg), filter);
}
if (data->init_dir && *(data->init_dir)) {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dlg), *(data->init_dir));
}
gtk_widget_show_all(dlg);
if (data->changedir && data->init_dir) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->chdir_cb), data->chdir);
} else {
gtk_widget_hide(data->chdir_cb);
}
fname = get_filename_with_ext(data->init_file, data->ext);
if (fname) {
if (type == GTK_FILE_CHOOSER_ACTION_SAVE) {
#ifdef WINDOWS
char *tmp;
tmp = g_locale_from_utf8(fname, -1, NULL, NULL, NULL);
if (tmp) {
file_dialog_set_current_neme(dlg, tmp);
g_free(tmp);
}
#else /* WINDOWS */
file_dialog_set_current_neme(dlg, fname);
#endif /* WINDOWS */
} else {
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dlg), fname);
}
g_free(fname);
}
data->ret = IDCANCEL;
while (1) {
if (ndialog_run(dlg) != GTK_RESPONSE_ACCEPT)
break;
fsok(dlg);
if (data->ret == IDOK && type == GTK_FILE_CHOOSER_ACTION_SAVE) {
file_dialog_set_current_neme(dlg, FileSelection.file[0]);
if (! data->overwrite && check_overwrite(dlg, FileSelection.file[0])) {
data->ret = IDCANCEL;
continue;
}
}
break;
}
gtk_widget_destroy(dlg);
reset_event();
data->widget = NULL;
return data->ret;
}
static void _lib_import_folder_callback(GtkWidget *widget, gpointer user_data)
{
dt_lib_module_t* self= (dt_lib_module_t*) user_data;
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new(
_("import film"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, _("_cancel"),
GTK_RESPONSE_CANCEL, _("_open"), GTK_RESPONSE_ACCEPT, (char *)NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE);
char *last_directory = dt_conf_get_string("ui_last/import_last_directory");
if(last_directory != NULL)
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_directory);
g_free(last_directory);
}
dt_lib_import_metadata_t metadata;
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser),
_lib_import_get_extra_widget(self,&metadata, TRUE));
// run the dialog
if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
{
gchar *folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(filechooser));
dt_conf_set_string("ui_last/import_last_directory", folder);
g_free(folder);
_lib_import_evaluate_extra_widget(&metadata, TRUE);
char *filename = NULL, *first_filename = NULL;
GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(filechooser));
GSList *it = list;
/* reset filter so that view isn't empty */
dt_view_filter_reset(darktable.view_manager, TRUE);
/* for each selected folder add import job */
while(it)
{
filename = (char *)it->data;
dt_film_import(filename);
if(!first_filename)
{
first_filename = g_strdup(filename);
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(metadata.recursive)))
first_filename = dt_util_dstrcat(first_filename, "%%");
}
g_free(filename);
it = g_slist_next(it);
}
/* update collection to view import */
if(first_filename)
{
dt_conf_set_int("plugins/lighttable/collect/num_rules", 1);
dt_conf_set_int("plugins/lighttable/collect/item0", 0);
dt_conf_set_string("plugins/lighttable/collect/string0", first_filename);
dt_collection_update_query(darktable.collection);
g_free(first_filename);
}
g_slist_free(list);
}
#ifdef USE_LUA
dt_lib_import_t *d = (dt_lib_import_t *)self->data;
// remove the extra portion from the filechooser before destroying it
GtkWidget * parent =gtk_widget_get_parent(d->extra_lua_widgets);
gtk_container_remove(GTK_CONTAINER(parent),d->extra_lua_widgets);
#endif
gtk_widget_destroy(metadata.frame);
gtk_widget_destroy(filechooser);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
}
static int gtkFileDlgPopup(Ihandle* ih, int x, int y)
{
InativeHandle* parent = iupDialogGetNativeParent(ih);
GtkWidget* dialog;
GtkWidget* preview_canvas = NULL;
GtkFileChooserAction action;
IFnss file_cb;
char* value;
int response, filter_count = 0;
iupAttribSetInt(ih, "_IUPDLG_X", x); /* used in iupDialogUpdatePosition */
iupAttribSetInt(ih, "_IUPDLG_Y", y);
value = iupAttribGetStr(ih, "DIALOGTYPE");
if (iupStrEqualNoCase(value, "SAVE"))
action = GTK_FILE_CHOOSER_ACTION_SAVE;
else if (iupStrEqualNoCase(value, "DIR"))
action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
else
action = GTK_FILE_CHOOSER_ACTION_OPEN;
value = iupAttribGet(ih, "TITLE");
if (!value)
{
GtkStockItem item;
if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
value = GTK_STOCK_SAVE_AS;
else
value = GTK_STOCK_OPEN;
gtk_stock_lookup(value, &item);
value = item.label;
iupAttribStoreStr(ih, "TITLE", iupgtkStrConvertFromUTF8(value));
value = iupAttribGet(ih, "TITLE");
iupStrRemoveChar(value, '_');
}
dialog = gtk_file_chooser_dialog_new(iupgtkStrConvertToUTF8(value), (GtkWindow*)parent, action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
if (!dialog)
return IUP_ERROR;
if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_SAVE, GTK_RESPONSE_OK);
else if (action == GTK_FILE_CHOOSER_ACTION_OPEN)
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OPEN, GTK_RESPONSE_OK);
else
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK);
if (IupGetCallback(ih, "HELP_CB"))
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP);
#if GTK_CHECK_VERSION(2, 6, 0)
if (iupAttribGetBoolean(ih, "SHOWHIDDEN"))
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
#endif
if (iupAttribGetBoolean(ih, "MULTIPLEFILES") && action == GTK_FILE_CHOOSER_ACTION_OPEN)
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
#if GTK_CHECK_VERSION(2, 8, 0)
if (!iupAttribGetBoolean(ih, "NOOVERWRITEPROMPT") && action == GTK_FILE_CHOOSER_ACTION_SAVE)
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
#endif
/* just check for the path inside FILE */
value = iupAttribGet(ih, "FILE");
if (value && (value[0] == '/' || value[1] == ':'))
{
char* dir = iupStrFileGetPath(value);
int len = strlen(dir);
iupAttribStoreStr(ih, "DIRECTORY", dir);
free(dir);
iupAttribStoreStr(ih, "FILE", value+len);
}
value = iupAttribGet(ih, "DIRECTORY");
if (value)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value));
value = iupAttribGet(ih, "FILE");
if (value)
{
if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value));
else
{
if (iupdrvIsFile(value)) /* check if file exists */
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), iupgtkStrConvertToFilename(value));
}
}
value = iupAttribGet(ih, "EXTFILTER");
if (value)
{
char *name, *pattern, *filters = iupStrDup(value), *p;
char atrib[30];
int i;
int filter_index = iupAttribGetInt(ih, "FILTERUSED");
if (!filter_index)
filter_index = 1;
filter_count = iupStrReplace(filters, '|', 0) / 2;
p = filters;
for (i=0; i<filter_count; i++)
{
GtkFileFilter *filter = gtk_file_filter_new();
gtkFileDlgGetNextFilter(&p, &name, &pattern);
gtk_file_filter_set_name(filter, iupgtkStrConvertToUTF8(name));
gtk_file_filter_add_pattern(filter, pattern);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
sprintf(atrib, "_IUPDLG_FILTER%d", i+1);
iupAttribSetStr(ih, atrib, (char*)filter);
if (i+1 == filter_index)
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
}
free(filters);
}
else
{
value = iupAttribGet(ih, "FILTER");
if (value)
{
GtkFileFilter *filter = gtk_file_filter_new();
char* info = iupAttribGet(ih, "FILTERINFO");
if (!info)
info = value;
gtk_file_filter_set_name(filter, iupgtkStrConvertToUTF8(info));
gtk_file_filter_add_pattern(filter, value);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
}
}
file_cb = (IFnss)IupGetCallback(ih, "FILE_CB");
if (file_cb && action != GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
{
g_signal_connect(GTK_FILE_CHOOSER(dialog), "update-preview", G_CALLBACK(gtkFileDlgUpdatePreview), ih);
g_signal_connect(dialog, "realize", G_CALLBACK(gtkFileDlgRealize), ih);
if (iupAttribGetBoolean(ih, "SHOWPREVIEW"))
{
GtkWidget* frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_widget_set_size_request(frame, 180, 150);
preview_canvas = gtk_drawing_area_new();
gtk_widget_set_double_buffered(preview_canvas, FALSE);
gtk_container_add(GTK_CONTAINER(frame), preview_canvas);
gtk_widget_show(preview_canvas);
g_signal_connect(preview_canvas, "configure-event", G_CALLBACK(gtkFileDlgPreviewConfigureEvent), ih);
g_signal_connect(preview_canvas, "expose-event", G_CALLBACK(gtkFileDlgPreviewExposeEvent), ih);
g_signal_connect(preview_canvas, "realize", G_CALLBACK(gtkFileDlgPreviewRealize), ih);
iupAttribSetStr(ih, "_IUPDLG_FILE_CHOOSER", (char*)dialog);
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), frame);
}
}
/* initialize the widget */
gtk_widget_realize(GTK_WIDGET(dialog));
ih->handle = GTK_WIDGET(dialog);
iupDialogUpdatePosition(ih);
ih->handle = NULL; /* reset handle */
do
{
response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_HELP)
{
Icallback cb = IupGetCallback(ih, "HELP_CB");
if (cb && cb(ih) == IUP_CLOSE)
response = GTK_RESPONSE_CANCEL;
}
else if (response == GTK_RESPONSE_OK)
{
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
int file_exist = iupdrvIsFile(filename);
int dir_exist = iupdrvIsDirectory(filename);
g_free(filename);
if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER)
{
if (!dir_exist)
{
iupStrMessageShowError(ih, "IUP_INVALIDDIR");
response = GTK_RESPONSE_HELP; /* to leave the dialog open */
continue;
}
}
else if (!iupAttribGetBoolean(ih, "MULTIPLEFILES"))
{
if (dir_exist)
{
iupStrMessageShowError(ih, "IUP_FILEISDIR");
response = GTK_RESPONSE_HELP; /* to leave the dialog open */
continue;
}
if (!file_exist) /* if do not exist check ALLOWNEW */
{
value = iupAttribGet(ih, "ALLOWNEW");
if (!value)
{
if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
value = "YES";
else
value = "NO";
}
if (!iupStrBoolean(value))
{
iupStrMessageShowError(ih, "IUP_FILENOTEXIST");
response = GTK_RESPONSE_HELP; /* to leave the dialog open */
continue;
}
}
if (file_cb)
{
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
int ret = file_cb(ih, iupgtkStrConvertFromFilename(filename), "OK");
g_free(filename);
if (ret == IUP_IGNORE)
{
response = GTK_RESPONSE_HELP; /* to leave the dialog open */
continue;
}
}
}
}
} while (response == GTK_RESPONSE_HELP);
if (file_cb)
{
if (iupAttribGetBoolean(ih, "SHOWPREVIEW"))
iupgtkReleaseNativeGraphicsContext(preview_canvas, (void*)iupAttribGet(ih, "PREVIEWDC"));
file_cb(ih, NULL, "FINISH");
}
if (response == GTK_RESPONSE_OK)
{
int file_exist, dir_exist;
if (filter_count)
{
int i;
char atrib[30];
GtkFileFilter* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog));
for (i=0; i<filter_count; i++)
{
sprintf(atrib, "_IUPDLG_FILTER%d", i+1);
if (filter == (GtkFileFilter*)iupAttribGet(ih, atrib))
iupAttribSetInt(ih, "FILTERUSED", i+1);
}
}
if (iupAttribGetBoolean(ih, "MULTIPLEFILES"))
{
GSList* file_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
if (file_list->next) /* if more than one file */
gtkFileDlgGetMultipleFiles(ih, file_list);
else
{
char* filename = (char*)file_list->data;
iupAttribStoreStr(ih, "VALUE", iupgtkStrConvertFromFilename(filename));
g_free(filename);
}
g_slist_free(file_list);
file_exist = 1;
dir_exist = 0;
}
else
{
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
iupAttribStoreStr(ih, "VALUE", iupgtkStrConvertFromFilename(filename));
file_exist = iupdrvIsFile(filename);
dir_exist = iupdrvIsDirectory(filename);
g_free(filename);
}
if (dir_exist)
{
iupAttribSetStr(ih, "FILEEXIST", NULL);
iupAttribSetStr(ih, "STATUS", "0");
}
else
{
if (file_exist) /* check if file exists */
{
iupAttribSetStr(ih, "FILEEXIST", "YES");
iupAttribSetStr(ih, "STATUS", "0");
}
else
{
iupAttribSetStr(ih, "FILEEXIST", "NO");
iupAttribSetStr(ih, "STATUS", "1");
}
}
if (action != GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER && !iupAttribGetBoolean(ih, "NOCHANGEDIR")) /* do change the current directory */
{
/* GtkFileChooser does not change the current directory */
char* dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
if (dir) iupdrvSetCurrentDirectory(dir);
g_free(dir);
}
}
else
{
iupAttribSetStr(ih, "FILTERUSED", NULL);
iupAttribSetStr(ih, "VALUE", NULL);
iupAttribSetStr(ih, "FILEEXIST", NULL);
iupAttribSetStr(ih, "STATUS", "-1");
}
gtk_widget_destroy(GTK_WIDGET(dialog));
return IUP_NOERROR;
}
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);
}
void crypt_dock_create_new_stash ()
{
gboolean disgardStash = FALSE;
CryptItem *pStashItem;
cd_message ("%s enter to the function", __func__);
pStashItem = g_new0 (CryptItem, 1);
disgardStash = FALSE;
for (int i=0; i < 4; i++) {
switch (i) {
case PHASE_ENTER_NEW_FOLDER:
{
GtkWidget* pFileChooserDialog = gtk_file_chooser_dialog_new (
_("(1/4) Select an new clean and/or empty folder (eg ~/.crypt)"),
GTK_WINDOW (myContainer->pWidget),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
NULL);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (pFileChooserDialog), g_get_home_dir());
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (pFileChooserDialog), FALSE);
gtk_widget_show (pFileChooserDialog);
int answer = gtk_dialog_run (GTK_DIALOG (pFileChooserDialog));
gboolean valid = FALSE;
if (answer == GTK_RESPONSE_OK) {
pStashItem->cCryptFolder = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (pFileChooserDialog));
valid = _cryptdock_stash_check_encfs_validity(pStashItem->cCryptFolder);
}
else {
disgardStash = TRUE;
}
gtk_widget_destroy (pFileChooserDialog);
if (valid == FALSE ) {
cairo_dock_show_dialog_and_wait ( D_("The selected folder is not an EncFS encrypted folder"),
myIcon,
myContainer,
NULL,
NULL);
disgardStash = TRUE;
}
}
break;
case PHASE_SELECT_MOUNT_FOLDER:
{
char *blah=NULL;
char *last_slash;
// Choose the name and location at which you want the EncFS folder to be mounted
GtkWidget* pFileChooserDialog = gtk_file_chooser_dialog_new (
_("(2/4) Choose the name and location at which you want the EncFS folder to be mounted"),
GTK_WINDOW (myContainer->pWidget),
GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
NULL);
blah = g_strdup(pStashItem->cCryptFolder);
last_slash = strrchr (blah, '/');
if (last_slash)
*last_slash = '\0';
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (pFileChooserDialog), blah);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (pFileChooserDialog), FALSE);
gtk_widget_show (pFileChooserDialog);
int answer = gtk_dialog_run (GTK_DIALOG (pFileChooserDialog));
if (answer == GTK_RESPONSE_OK) {
pStashItem->cMountFolder = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (pFileChooserDialog));
} else {
disgardStash = TRUE;
cairo_dock_show_dialog_and_wait ( D_("You must enter a name"),
myIcon,
myContainer,
NULL,
NULL);
}
gtk_widget_destroy (pFileChooserDialog);
}
break;
case PHASE_ENTER_NAME:
{
GtkWidget *editbox = gtk_entry_new();
int selection = cairo_dock_show_dialog_and_wait ( D_("(3/4) Enter name of stash (visible in list)"),
myIcon,
myContainer,
NULL,
editbox);
if (selection == STASH_NAME_BUTTON_OK) { // user select Ok or check mark
pStashItem->cVisibleName = g_strdup(gtk_entry_get_text(GTK_ENTRY(editbox)));
}
else {
disgardStash = TRUE;
}
gtk_widget_destroy (editbox);
}
break;
case PHASE_ENTER_PASSWORD:
{
GtkWidget *editbox = gtk_entry_new();
gtk_entry_set_visibility (GTK_ENTRY(editbox), FALSE);
int selection = cairo_dock_show_dialog_and_wait ( D_("(4/4) Enter name of stash (visible in list)"),
myIcon,
myContainer,
NULL,
editbox);
gchar * password=NULL;
if (selection == STASH_NAME_BUTTON_OK) { // user select Ok or check mark
password = g_strdup(gtk_entry_get_text(GTK_ENTRY(editbox)));
if (password) {
int done = encfs_stash_new (pStashItem->cCryptFolder, pStashItem->cMountFolder, password);
g_free (password);
if (done==0) {
crypt_save_stash_to_settings(pStashItem);
g_ptr_array_add (myData.pStashArray, pStashItem);
crypt_show_notification_dialog (D_("New encfs mountpoint created."));
// passed
} else {
crypt_show_notification_dialog (D_("Unable to create new encfs mount."));
crypt_free_stashitem (pStashItem);
// not passed ...
}
}
}
else {
crypt_show_notification_dialog (D_("Unable to create new encfs mount."));
}
gtk_widget_destroy (editbox);
}
break;
}
}
return;
}
/* [nd_gtk thread] */
static gboolean create_gtk_file_dialog(gpointer data)
{
GTK_FILE_DIALOG_MESSAGE *msg = data;
ALLEGRO_DISPLAY *display = msg->display;
ALLEGRO_NATIVE_DIALOG *fd = msg->dialog;
bool save = fd->flags & ALLEGRO_FILECHOOSER_SAVE;
gint result;
GtkWidget *window;
window =
gtk_file_chooser_dialog_new(al_cstr(fd->title),
NULL,
save ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
save ? GTK_STOCK_SAVE : GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
_al_gtk_make_transient(display, window);
if (fd->fc_initial_path) {
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(window),
al_path_cstr(fd->fc_initial_path, ALLEGRO_NATIVE_PATH_SEP));
}
if (fd->flags & ALLEGRO_FILECHOOSER_MULTIPLE)
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(window), true);
/* FIXME: Move all this filter parsing stuff into a common file. */
if (al_ustr_size(fd->fc_patterns) > 0) {
GtkFileFilter* filter = gtk_file_filter_new();
int start = 0;
int end = 0;
bool is_mime_type = false;
while (true) {
int32_t c = al_ustr_get(fd->fc_patterns, end);
if (c < 0 || c == ';') {
if (end - start > 0) {
ALLEGRO_USTR* pattern = al_ustr_dup_substr(fd->fc_patterns, start, end);
if (is_mime_type) {
gtk_file_filter_add_mime_type(filter, al_cstr(pattern));
}
else {
gtk_file_filter_add_pattern(filter, al_cstr(pattern));
}
al_ustr_free(pattern);
}
start = end + 1;
is_mime_type = false;
}
if (c == '/')
is_mime_type = true;
if (c < 0)
break;
end += al_utf8_width(c);
}
gtk_file_filter_set_name(filter, "All supported files");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(window), filter);
}
result = gtk_dialog_run(GTK_DIALOG(window));
if (result == GTK_RESPONSE_ACCEPT) {
GSList* filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(window));
int i;
GSList* iter;
fd->fc_path_count = g_slist_length(filenames);
fd->fc_paths = al_malloc(fd->fc_path_count * sizeof(void *));
for (i = 0, iter = filenames; i < (int)fd->fc_path_count; i++, iter = g_slist_next(iter)) {
fd->fc_paths[i] = al_create_path((const char*)iter->data);
g_free(iter->data);
}
g_slist_free(filenames);
}
gtk_widget_destroy(window);
ASSERT(fd->async_queue);
g_async_queue_push(fd->async_queue, ACK_CLOSED);
return FALSE;
}
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);
}
/*****************************************************************************
* create_session_load_dialog()
*****************************************************************************/
void
create_session_load_dialog(void)
{
GError *error = NULL;
GtkWidget *hbox;
GtkWidget *label;
int new_adj = (session_io_start_adj == NULL);
/* this should only need to happen once */
if (session_load_dialog == NULL) {
/* create dialog */
session_load_dialog = gtk_file_chooser_dialog_new("PHASEX - Load Session",
GTK_WINDOW(main_window),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN,
GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_wmclass(GTK_WINDOW(session_load_dialog), "phasex", "phasex-load");
gtk_window_set_role(GTK_WINDOW(session_load_dialog), "session-load");
gtk_file_chooser_set_preview_widget_active
(GTK_FILE_CHOOSER(session_load_dialog), FALSE);
/* create spinbutton control for starting program number */
hbox = gtk_hbox_new(FALSE, 8);
label = gtk_label_new("Load multiple sessions staring at session #:");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 8);
if (new_adj) {
session_io_start_adj = gtk_adjustment_new(0, 1, PATCH_BANK_SIZE, 1, 8, 0);
}
session_load_start_spin = gtk_spin_button_new(GTK_ADJUSTMENT(session_io_start_adj), 0, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(session_load_start_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(session_load_start_spin),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(session_load_start_spin), TRUE);
gtk_adjustment_set_value(GTK_ADJUSTMENT(session_io_start_adj), (visible_sess_num + 1));
gtk_box_pack_start(GTK_BOX(hbox), session_load_start_spin, FALSE, FALSE, 8);
if (new_adj) {
g_signal_connect(GTK_OBJECT(session_load_start_spin), "value_changed",
GTK_SIGNAL_FUNC(set_session_io_start),
(gpointer) session_io_start_adj);
}
gtk_widget_show_all(hbox);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(session_load_dialog), hbox);
/* realize the file chooser before telling it about files */
gtk_widget_realize(session_load_dialog);
/* start in user session dir (usually ~/.phasex/user-sessions) */
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_load_dialog),
user_session_dir);
/* allow selection of multiple sessions */
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(session_load_dialog), TRUE);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(session_load_dialog), TRUE);
#endif
/* add user session dirs as shortcut folder */
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_load_dialog),
user_session_dir, &error);
if (error != NULL) {
PHASEX_ERROR("Error %d: %s\n", error->code, error->message);
g_error_free(error);
}
}
}
GSList *
totem_add_files (GtkWindow *parent, const char *path)
{
GtkWidget *fs;
int response;
GSList *filenames;
char *mrl, *new_path;
GSettings *settings;
gboolean set_folder;
fs = gtk_file_chooser_dialog_new (_("Select Movies or Playlists"),
parent,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Add Directory"), OPEN_DIRECTORY_RESPONSE,
GTK_STOCK_ADD, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_all);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_supported);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_audio);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_video);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (fs), filter_supported);
gtk_dialog_set_default_response (GTK_DIALOG (fs), GTK_RESPONSE_ACCEPT);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (fs), TRUE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fs), FALSE);
settings = g_settings_new (TOTEM_GSETTINGS_SCHEMA);
set_folder = TRUE;
if (path != NULL) {
set_folder = gtk_file_chooser_set_current_folder_uri
(GTK_FILE_CHOOSER (fs), path);
} else {
new_path = g_settings_get_string (settings, "open-uri");
if (*new_path != '\0') {
set_folder = gtk_file_chooser_set_current_folder_uri
(GTK_FILE_CHOOSER (fs), new_path);
}
g_free (new_path);
}
/* We didn't manage to change the directory */
if (set_folder == FALSE) {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fs),
g_get_home_dir ());
}
totem_add_default_dirs (GTK_FILE_CHOOSER (fs));
response = gtk_dialog_run (GTK_DIALOG (fs));
filenames = NULL;
if (response == OPEN_DIRECTORY_RESPONSE ||
response == GTK_RESPONSE_ACCEPT) {
filenames = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (fs));
}
if (filenames == NULL) {
gtk_widget_destroy (fs);
g_object_unref (settings);
return NULL;
}
gtk_widget_destroy (fs);
mrl = filenames->data;
if (mrl != NULL) {
new_path = g_path_get_dirname (mrl);
g_settings_set_string (settings, "open-uri", new_path);
g_free (new_path);
}
g_object_unref (settings);
return filenames;
}
/* This creates all the GTK+ widgets that compose our application, and registers the callbacks */
static GtkWidget* create_player_ui (CustomData *data, guint decknumber) {
GtkWidget *stop_button; /* Buttons */
GtkWidget *title;
GtkWidget *myGrid;
myGrid = gtk_grid_new();
data->playPauseButton = _create_media_button (GTK_STOCK_MEDIA_PAUSE);
g_signal_connect (G_OBJECT (data->playPauseButton), "clicked", G_CALLBACK (playpause_cb), data);
stop_button = _create_media_button (GTK_STOCK_MEDIA_STOP);
g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), data);
data->slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1);
gtk_scale_set_draw_value (GTK_SCALE (data->slider), 0);
data->slider_update_signal_id = g_signal_connect (G_OBJECT (data->slider), "value-changed", G_CALLBACK (slider_cb), data);
g_signal_connect (G_OBJECT (data->slider), "move-slider", G_CALLBACK (slider_cb), data);
data->timelabel = gtk_label_new ("");
update_timelabel(data, "Time remaining");
data->taglabel = gtk_label_new ("Selected filename");
{
data->filechooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (data->filechooser), TRUE);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (data->filechooser), FALSE);
gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (data->filechooser), FALSE);
if (NULL != data->last_folder_uri) {
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (data->filechooser),
data->last_folder_uri);
} else {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (data->filechooser),
g_get_home_dir());
}
GtkFileFilter *filter = gtk_file_filter_new();
gtk_file_filter_add_mime_type (filter, "audio/*");
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (data->filechooser), filter);
data->file_selection_signal_id =
g_signal_connect (G_OBJECT (data->filechooser), "selection-changed", G_CALLBACK (file_selection_cb), data);
/* block signal to prevent false selection on startup*/
g_signal_handler_block (data->filechooser, data->file_selection_signal_id);
}
{
gchar *titlename = g_strdup_printf ("Deck %u\n", decknumber + 1);
title = gtk_label_new (titlename);
g_free (titlename);
}
/* arrange all elements into myGrid */
gtk_grid_attach (GTK_GRID (myGrid), data->filechooser, 0, 0, 1, 3);
gtk_grid_attach_next_to (GTK_GRID (myGrid), title, data->filechooser, GTK_POS_TOP, 1, 3);
gtk_grid_attach_next_to (GTK_GRID (myGrid), data->playPauseButton, data->filechooser, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to (GTK_GRID (myGrid), stop_button, data->playPauseButton, GTK_POS_BOTTOM, 1, 1);
gtk_grid_attach_next_to (GTK_GRID (myGrid), data->taglabel, data->filechooser, GTK_POS_BOTTOM, 2, 1);
gtk_grid_attach_next_to (GTK_GRID (myGrid), data->timelabel, data->taglabel, GTK_POS_BOTTOM, 2, 1);
gtk_grid_attach_next_to (GTK_GRID (myGrid), data->slider, data->timelabel, GTK_POS_BOTTOM, 2, 1);
/* allow at least one expanding child, so all uppper widgets will resize
* when maximising the window
*/
gtk_widget_set_hexpand (data->filechooser, TRUE);
gtk_widget_set_vexpand (data->filechooser, TRUE);
gtk_label_set_line_wrap(GTK_LABEL (data->taglabel), TRUE);
return myGrid;
}
void get_files_to_play(GtkWidget *widget, gpointer user_data) {
/** User single file selection. **/
#ifdef DEBUG
DEBUG_FUNC_MARK
#endif
GtkWidget *file_chooser_dialog = gtk_file_chooser_dialog_new("Choose music files to listen.", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, "Cancel", GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser_dialog), current_folder.c_str() ) ;
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(file_chooser_dialog), FALSE) ;
gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(file_chooser_dialog), FALSE) ;
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser_dialog), TRUE) ;
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(file_chooser_dialog), TRUE) ;
GtkFileFilter *file_filter = gtk_file_filter_new() ;
for (int c=0 ; c < static_cast<int>(extension_list.size()) ; c++) {
gtk_file_filter_add_pattern(GTK_FILE_FILTER(file_filter), extension_list.at(c).c_str()) ;
}
gtk_file_filter_set_name(GTK_FILE_FILTER(file_filter), "Supported music filetypes") ;
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser_dialog), GTK_FILE_FILTER(file_filter)) ;
gtk_window_set_position(GTK_WINDOW(file_chooser_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
gtk_widget_set_size_request(file_chooser_dialog,-1,-1) ;
gtk_window_set_modal(GTK_WINDOW(file_chooser_dialog), TRUE) ;
gtk_window_set_destroy_with_parent(GTK_WINDOW(file_chooser_dialog), TRUE) ;
gtk_window_set_type_hint(GTK_WINDOW(file_chooser_dialog), GDK_WINDOW_TYPE_HINT_DIALOG) ;
gtk_window_set_transient_for(GTK_WINDOW(file_chooser_dialog), GTK_WINDOW(gui->window)) ;
GSList *filepath_list = NULL ;
gint result = gtk_dialog_run (GTK_DIALOG (file_chooser_dialog));
switch (result) {
case GTK_RESPONSE_CANCEL :
gtk_widget_destroy(file_chooser_dialog);
return ;
case GTK_RESPONSE_ACCEPT :
filepath_list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser_dialog)) ;
gtk_widget_destroy(file_chooser_dialog) ;
break ;
}
if (filepath_list != NULL) {
gchar *file_dirname = g_path_get_dirname((const gchar *) g_slist_nth_data(filepath_list, 0)) ;
check_files(filepath_list) ;
current_folder = file_dirname ;
g_free(file_dirname) ;
#ifdef DEBUG
fprintf(stdout,"%s current_folder: %s\n", __func__, current_folder.c_str() ) ;
#endif
g_slist_free(filepath_list) ;
}
}
GtkWidget*
_gwy_app_file_chooser_get(GtkFileChooserAction action)
{
GtkDialog *dialog;
GwyAppFileChooser *chooser;
GtkWidget **instance;
const gchar *title;
switch (action) {
case GTK_FILE_CHOOSER_ACTION_OPEN:
instance = &instance_open;
title = _("Open File");
break;
case GTK_FILE_CHOOSER_ACTION_SAVE:
instance = &instance_save;
title = _("Save File");
break;
default:
g_return_val_if_reached(NULL);
break;
}
if (*instance)
return *instance;
ensure_gtk_recently_used();
chooser = g_object_new(GWY_TYPE_APP_FILE_CHOOSER,
"title", title,
"action", action,
NULL);
*instance = GTK_WIDGET(chooser);
dialog = GTK_DIALOG(chooser);
g_object_add_weak_pointer(G_OBJECT(chooser), (gpointer*)instance);
gtk_dialog_add_button(dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
switch (action) {
case GTK_FILE_CHOOSER_ACTION_OPEN:
chooser->prefix = "/app/file/load";
gtk_dialog_add_button(dialog, GTK_STOCK_OPEN, GTK_RESPONSE_OK);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), TRUE);
break;
case GTK_FILE_CHOOSER_ACTION_SAVE:
chooser->prefix = "/app/file/save";
gtk_dialog_add_button(dialog, GTK_STOCK_SAVE, GTK_RESPONSE_OK);
break;
default:
g_assert_not_reached();
break;
}
gwy_help_add_to_window(GTK_WINDOW(dialog), "managing-files", NULL,
GWY_HELP_DEFAULT);
gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), TRUE);
gwy_app_file_chooser_setup_filter(chooser);
gwy_app_file_chooser_add_type_list(chooser);
gwy_app_file_chooser_add_preview(chooser);
g_signal_connect(chooser, "response",
G_CALLBACK(gwy_app_file_chooser_save_position), NULL);
gwy_app_restore_window_position(GTK_WINDOW(chooser), chooser->prefix, TRUE);
return *instance;
}
void
ags_menu_action_save_as_callback(GtkWidget *menu_item, gpointer data)
{
AgsApplicationContext *application_context;
AgsWindow *window;
GtkFileChooserDialog *file_chooser;
gint response;
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
file_chooser = (GtkFileChooserDialog *) gtk_file_chooser_dialog_new("save file as",
(GtkWindow *) window,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(file_chooser), FALSE);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(file_chooser), TRUE);
gtk_widget_show_all((GtkWidget *) file_chooser);
response = gtk_dialog_run(GTK_DIALOG(file_chooser));
if(response == GTK_RESPONSE_ACCEPT){
gchar *filename;
gchar *str;
GError *error;
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser));
if(g_strcmp0(ags_config_get_value(AGS_APPLICATION_CONTEXT(application_context)->config,
AGS_CONFIG_GENERIC,
"simple-file"),
"false")){
AgsSimpleFile *simple_file;
simple_file = (AgsSimpleFile *) g_object_new(AGS_TYPE_SIMPLE_FILE,
"application-context", application_context,
"filename", filename,
NULL);
error = NULL;
ags_simple_file_rw_open(simple_file,
TRUE,
&error);
ags_simple_file_write(simple_file);
ags_simple_file_close(simple_file);
g_object_unref(G_OBJECT(simple_file));
}else{
AgsFile *file;
file = (AgsFile *) g_object_new(AGS_TYPE_FILE,
"application-context", application_context,
"filename", filename,
NULL);
error = NULL;
ags_file_rw_open(file,
TRUE,
&error);
ags_file_write(file);
ags_file_close(file);
g_object_unref(G_OBJECT(file));
}
if(window->name != NULL){
g_free(window->name);
}
window->name = g_strdup(filename);
str = g_strconcat("GSequencer - ", window->name, NULL);
gtk_window_set_title((GtkWindow *) window, str);
g_free(str);
}
gtk_widget_destroy((GtkWidget *) file_chooser);
}
static char *filedialog(GtkWindow *parent, GtkFileChooserAction mode, const gchar *confirm, char* filter, char* initpath)
{
GtkWidget *fcd;
GtkFileChooser *fc;
gint response;
char *filename;
fcd = gtk_file_chooser_dialog_new(NULL, parent, mode,
"_Cancel", GTK_RESPONSE_CANCEL,
confirm, GTK_RESPONSE_ACCEPT,
NULL);
fc = GTK_FILE_CHOOSER(fcd);
// filters
{
gchar _filter[256];
gchar* fp = &_filter[0]; int s = 0;
gchar* fname;
for (int i = 0; i < 255; i++)
{
if (filter[i] == '|' || filter[i] == '\0')
{
_filter[i] = '\0';
if (s & 1)
{
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, fname);
for (gchar* j = fp; ; j++)
{
if (*j == ';')
{
*j = '\0';
gtk_file_filter_add_pattern(filter, fp);
fp = j+1;
}
else if (*j == '\0')
{
gtk_file_filter_add_pattern(filter, fp);
break;
}
}
gtk_file_chooser_add_filter(fc, filter);
}
else
{
fname = fp;
}
fp = &_filter[i+1];
s++;
if (s >= 8) break;
if (filter[i] == '\0') break;
}
else
_filter[i] = filter[i];
}
}
gtk_file_chooser_set_local_only(fc, FALSE);
gtk_file_chooser_set_select_multiple(fc, FALSE);
gtk_file_chooser_set_show_hidden(fc, TRUE);
gtk_file_chooser_set_do_overwrite_confirmation(fc, TRUE);
gtk_file_chooser_set_create_folders(fc, TRUE);
if (initpath && strlen(initpath)>0)
gtk_file_chooser_set_current_folder(fc, initpath);
response = gtk_dialog_run(GTK_DIALOG(fcd));
if (response != GTK_RESPONSE_ACCEPT) {
gtk_widget_destroy(fcd);
return NULL;
}
filename = uiUnixStrdupText(gtk_file_chooser_get_filename(fc));
gtk_widget_destroy(fcd);
return filename;
}
/* create the "add" dialog. */
void
add_folder_cb (GtkWidget *widget,
void *callback_data)
{
GtkWidget *file_sel;
DialogData *data;
GtkWidget *main_box;
GtkWidget *vbox;
GtkWidget *grid;
GtkWidget *align;
data = g_new0 (DialogData, 1);
data->settings = g_settings_new (ENGRAMPA_SCHEMA_ADD);
data->window = callback_data;
data->dialog = file_sel =
gtk_file_chooser_dialog_new (_("Add a Folder"),
GTK_WINDOW (data->window),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
FR_STOCK_ADD_FOLDER, GTK_RESPONSE_OK,
GTK_STOCK_HELP, GTK_RESPONSE_HELP,
NULL);
gtk_window_set_default_size (GTK_WINDOW (data->dialog), 530, 510);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK);
data->add_if_newer_checkbutton = gtk_check_button_new_with_mnemonic (_("Add only if _newer"));
data->include_subfold_checkbutton = gtk_check_button_new_with_mnemonic (_("_Include subfolders"));
data->exclude_symlinks = gtk_check_button_new_with_mnemonic (_("Exclude folders that are symbolic lin_ks"));
data->include_files_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (data->include_files_entry, _("example: *.o; *.bak"));
data->include_files_label = gtk_label_new_with_mnemonic (_("Include _files:"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (data->include_files_label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (data->include_files_label), 0.0, 0.5);
#endif
gtk_label_set_mnemonic_widget (GTK_LABEL (data->include_files_label), data->include_files_entry);
data->exclude_files_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (data->exclude_files_entry, _("example: *.o; *.bak"));
data->exclude_files_label = gtk_label_new_with_mnemonic (_("E_xclude files:"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (data->exclude_files_label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (data->exclude_files_label), 0.0, 0.5);
#endif
gtk_label_set_mnemonic_widget (GTK_LABEL (data->exclude_files_label), data->exclude_files_entry);
data->exclude_folders_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (data->exclude_folders_entry, _("example: *.o; *.bak"));
data->exclude_folders_label = gtk_label_new_with_mnemonic (_("_Exclude folders:"));
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (data->exclude_folders_label), 0.0);
#else
gtk_misc_set_alignment (GTK_MISC (data->exclude_folders_label), 0.0, 0.5);
#endif
gtk_label_set_mnemonic_widget (GTK_LABEL (data->exclude_folders_label), data->exclude_folders_entry);
data->load_button = gtk_button_new_with_mnemonic (_("_Load Options"));
data->save_button = gtk_button_new_with_mnemonic (_("Sa_ve Options"));
data->clear_button = gtk_button_new_with_mnemonic (_("_Reset Options"));
main_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20);
gtk_container_set_border_width (GTK_CONTAINER (main_box), 0);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_sel), main_box);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_box_pack_start (GTK_BOX (main_box), vbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->include_subfold_checkbutton,
TRUE, TRUE, 0);
align = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 12, 0);
gtk_container_add (GTK_CONTAINER (align), data->exclude_symlinks);
gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->add_if_newer_checkbutton,
TRUE, TRUE, 0);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_box_pack_start (GTK_BOX (vbox), grid,
TRUE, TRUE, 0);
gtk_grid_attach (GTK_GRID (grid),
data->include_files_label,
0, 0,
1, 1);
gtk_grid_attach (GTK_GRID (grid),
data->include_files_entry,
1, 0,
3, 1);
gtk_grid_attach (GTK_GRID (grid),
data->exclude_files_label,
0, 1,
1, 1);
gtk_grid_attach (GTK_GRID (grid),
data->exclude_files_entry,
1, 1,
1, 1);
gtk_grid_attach (GTK_GRID (grid),
data->exclude_folders_label,
2, 1,
1, 1);
gtk_grid_attach (GTK_GRID (grid),
data->exclude_folders_entry,
3, 1,
1, 1);
/**/
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_box_pack_start (GTK_BOX (main_box), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->load_button,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->save_button,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->clear_button,
FALSE, FALSE, 0);
gtk_widget_show_all (main_box);
/* set data */
dlg_add_folder_load_last_options (data);
/* signals */
g_signal_connect (G_OBJECT (file_sel),
"destroy",
G_CALLBACK (open_file_destroy_cb),
data);
g_signal_connect (G_OBJECT (file_sel),
"response",
G_CALLBACK (file_sel_response_cb),
data);
g_signal_connect (G_OBJECT (data->include_subfold_checkbutton),
"toggled",
G_CALLBACK (include_subfold_toggled_cb),
data);
g_signal_connect (G_OBJECT (data->load_button),
"clicked",
G_CALLBACK (load_options_cb),
data);
g_signal_connect (G_OBJECT (data->save_button),
"clicked",
G_CALLBACK (save_options_cb),
data);
g_signal_connect (G_OBJECT (data->clear_button),
"clicked",
G_CALLBACK (clear_options_cb),
data);
gtk_window_set_modal (GTK_WINDOW (file_sel),TRUE);
gtk_widget_show (file_sel);
}
void project_open(void)
{
const gchar *dir = local_prefs.project_file_path;
#ifdef G_OS_WIN32
gchar *file;
#else
GtkWidget *dialog;
GtkFileFilter *filter;
gchar *locale_path;
#endif
if (! project_ask_close()) return;
#ifdef G_OS_WIN32
file = win32_show_project_open_dialog(main_widgets.window, _("Open Project"), dir, FALSE, TRUE);
if (file != NULL)
{
/* try to load the config */
if (! project_load_file_with_session(file))
{
SHOW_ERR1(_("Project file \"%s\" could not be loaded."), file);
}
g_free(file);
}
#else
dialog = gtk_file_chooser_dialog_new(_("Open Project"), GTK_WINDOW(main_widgets.window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
gtk_widget_set_name(dialog, "GeanyDialogProject");
/* set default Open, so pressing enter can open multiple files */
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(dialog), TRUE);
gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
/* add FileFilters */
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(dialog), filter);
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, _("Project files"));
gtk_file_filter_add_pattern(filter, "*." GEANY_PROJECT_EXT);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter);
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
locale_path = utils_get_locale_from_utf8(dir);
if (g_file_test(locale_path, G_FILE_TEST_EXISTS) &&
g_file_test(locale_path, G_FILE_TEST_IS_DIR))
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), locale_path);
}
g_free(locale_path);
gtk_widget_show_all(dialog);
run_open_dialog(GTK_DIALOG(dialog));
gtk_widget_destroy(GTK_WIDGET(dialog));
#endif
}
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 );
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;
}
static void remmina_ftp_client_action_upload(GObject *object, RemminaFTPClient *client)
{
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
GtkListStore *store = GTK_LIST_STORE(priv->task_list_model);
GtkTreeIter iter;
GtkWidget *dialog;
GtkWidget *upload_folder_check;
gint type;
GSList *files = NULL;
GSList *element;
gchar *path;
gchar *dir, *name;
struct stat st;
dialog = gtk_file_chooser_dialog_new(_("Choose a file to upload"),
GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(client))), GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel",
GTK_RESPONSE_CANCEL, "_OK", GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
if (priv->working_directory)
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), priv->working_directory);
}
upload_folder_check = gtk_check_button_new_with_label(_("Upload folder"));
gtk_widget_show(upload_folder_check);
g_signal_connect(G_OBJECT(upload_folder_check), "toggled", G_CALLBACK(remmina_ftp_client_upload_folder_on_toggled),
dialog);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), upload_folder_check);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
g_free(priv->working_directory);
priv->working_directory = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
files = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
}
type = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(upload_folder_check)) ?
REMMINA_FTP_FILE_TYPE_DIR : REMMINA_FTP_FILE_TYPE_FILE;
gtk_widget_destroy(dialog);
if (!files)
return;
for (element = files; element; element = element->next)
{
path = (gchar*) element->data;
if (g_stat(path, &st) < 0)
continue;
name = g_strrstr(path, "/");
if (name)
{
*name++ = '\0';
dir = path;
}
else
{
name = path;
dir = NULL;
}
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, REMMINA_FTP_TASK_COLUMN_TYPE, type, REMMINA_FTP_TASK_COLUMN_NAME, name,
REMMINA_FTP_TASK_COLUMN_SIZE, (gfloat) st.st_size, REMMINA_FTP_TASK_COLUMN_TASKID,
remmina_ftp_client_taskid++, REMMINA_FTP_TASK_COLUMN_TASKTYPE, REMMINA_FTP_TASK_TYPE_UPLOAD,
REMMINA_FTP_TASK_COLUMN_REMOTEDIR, priv->current_directory, REMMINA_FTP_TASK_COLUMN_LOCALDIR,
dir, REMMINA_FTP_TASK_COLUMN_STATUS, REMMINA_FTP_TASK_STATUS_WAIT,
REMMINA_FTP_TASK_COLUMN_DONESIZE, 0.0, REMMINA_FTP_TASK_COLUMN_TOOLTIP, NULL, -1);
g_free(path);
}
g_slist_free(files);
g_signal_emit(G_OBJECT(client), remmina_ftp_client_signals[NEW_TASK_SIGNAL], 0);
}
static void
dlg_extract__common (FrWindow *window,
GList *selected_files,
char *base_dir_for_selection)
{
DialogData *data;
GtkWidget *file_sel;
data = g_new0 (DialogData, 1);
data->settings = g_settings_new (EXRED_SCHEMA_EXTRACT);
data->window = window;
data->selected_files = selected_files;
data->base_dir_for_selection = base_dir_for_selection;
data->extract_clicked = FALSE;
data->dialog = file_sel =
gtk_file_chooser_dialog_new (_("Extract"),
GTK_WINDOW (data->window),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
FR_STOCK_EXTRACT, GTK_RESPONSE_OK,
GTK_STOCK_HELP, GTK_RESPONSE_HELP,
NULL);
gtk_window_set_default_size (GTK_WINDOW (file_sel), 530, 510);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_sel), create_extra_widget (data));
/* Set widgets data. */
gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (file_sel), fr_window_get_extract_default_dir (window));
if (data->selected_files != NULL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_selected_radiobutton), TRUE);
else {
gtk_widget_set_sensitive (data->e_selected_radiobutton, FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_all_radiobutton), TRUE);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_overwrite_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_OVERWRITE));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_SKIP_NEWER));
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_overwrite_checkbutton))) {
gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton), TRUE);
gtk_widget_set_sensitive (data->e_not_newer_checkbutton, FALSE);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (data->e_recreate_dir_checkbutton), g_settings_get_boolean (data->settings, PREF_EXTRACT_RECREATE_FOLDERS));
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"destroy",
G_CALLBACK (destroy_cb),
data);
g_signal_connect (G_OBJECT (file_sel),
"response",
G_CALLBACK (file_sel_response_cb),
data);
g_signal_connect (G_OBJECT (data->e_overwrite_checkbutton),
"toggled",
G_CALLBACK (overwrite_toggled_cb),
data);
g_signal_connect (G_OBJECT (data->e_files_entry),
"changed",
G_CALLBACK (files_entry_changed_cb),
data);
/* Run dialog. */
gtk_window_set_modal (GTK_WINDOW (file_sel),TRUE);
gtk_widget_show (file_sel);
}
void
gtkutil_file_req (const char *title, void *callback, void *userdata, char *filter, char *extensions,
int flags)
{
struct file_req *freq;
GtkWidget *dialog;
GtkFileFilter *filefilter;
extern char *get_xdir_fs (void);
char *token;
char *tokenbuffer;
#if 0 /* native file dialogs */
#ifdef WIN32
if (!(flags & FRF_WRITE))
{
freq = malloc (sizeof (struct file_req));
freq->th = thread_new ();
freq->flags = 0;
freq->multiple = (flags & FRF_MULTIPLE);
freq->callback = callback;
freq->userdata = userdata;
freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0);
if (!filter)
{
freq->filter = "All files\0*.*\0"
"Executables\0*.exe\0"
"ZIP files\0*.zip\0\0";
}
else
{
freq->filter = filter;
}
thread_start (freq->th, win32_thread, freq);
fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq);
return;
}
else {
freq = malloc (sizeof (struct file_req));
freq->th = thread_new ();
freq->flags = 0;
freq->multiple = (flags & FRF_MULTIPLE);
freq->callback = callback;
freq->userdata = userdata;
freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0);
if (!filter)
{
freq->filter = "All files\0*.*\0\0";
}
else
{
freq->filter = filter;
}
thread_start (freq->th, win32_thread2, freq);
fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq);
return;
}
#endif
#endif
if (flags & FRF_WRITE)
{
dialog = gtk_file_chooser_dialog_new (title, NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
if (filter && filter[0]) /* filter becomes initial name when saving */
{
char temp[1024];
path_part (filter, temp, sizeof (temp));
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), temp);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), file_part (filter));
}
if (!(flags & FRF_NOASKOVERWRITE))
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
}
else
dialog = gtk_file_chooser_dialog_new (title, NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
if (flags & FRF_MULTIPLE)
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
if (last_dir[0])
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), last_dir);
if (flags & FRF_ADDFOLDER)
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
get_xdir (), NULL);
if (flags & FRF_CHOOSEFOLDER)
{
gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter);
}
else
{
if (filter && (flags & FRF_FILTERISINITIAL))
{
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter);
}
/* With DCC, we can't rely on filter as initial folder since filter already contains
* the filename upon DCC RECV. Thus we have no better option than to check for the message
* which will be the title of the window. For DCC it always contains the "offering" word.
* This method is really ugly but it works so we'll stick with it for now.
*/
else if (strstr (title, "offering") != NULL)
{
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), prefs.hex_dcc_dir);
}
/* by default, open the config folder */
else
{
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), get_xdir ());
}
}
if (flags & FRF_EXTENSIONS && extensions != NULL)
{
filefilter = gtk_file_filter_new ();
tokenbuffer = g_strdup (extensions);
token = strtok (tokenbuffer, ";");
while (token != NULL)
{
gtk_file_filter_add_pattern (filefilter, token);
token = strtok (NULL, ";");
}
g_free (tokenbuffer);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filefilter);
}
freq = malloc (sizeof (struct file_req));
freq->dialog = dialog;
freq->flags = flags;
freq->callback = callback;
freq->userdata = userdata;
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (gtkutil_file_req_response), freq);
g_signal_connect (G_OBJECT (dialog), "destroy",
G_CALLBACK (gtkutil_file_req_destroy), (gpointer) freq);
gtk_widget_show (dialog);
}
// Обработчик нажатия кнопки Открыть файл.
void cMainWin::OnOpenFile(GtkWidget *widget, cMainWin *aMainWin)
{
GtkWidget *dialog; // Объявим новый виджет диалога выбора файла.
// Теперь создадим его, как отдельное окно с заголовком Выберите файл и двумя кнопками Отмена и Открыть.
// Нажатие на кнопку Отмена вызовет сигнал GTK_RESPONSE_CANCEL.
// Нажатие на кнопку Открыть вызовет сигнал GTK_RESPONSE_ACCEPT.
dialog = gtk_file_chooser_dialog_new ("Выберите файл",
GTK_WINDOW(aMainWin->mwWindow),
GTK_FILE_CHOOSER_ACTION_OPEN,
("_Cancel"), GTK_RESPONSE_CANCEL,
("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
GtkFileFilter *filter = gtk_file_filter_new (); // Создадим новый фильтр для расширений файлов.
gtk_file_filter_add_pattern (filter, "*.mp3"); // Добавим в фильтр шаблон файлов с расширением .mp3,
gtk_file_filter_add_pattern (filter, "*.MP3"); // .MP3,
gtk_file_filter_add_pattern (filter, "*.wav"); // .wav,
gtk_file_filter_add_pattern (filter, "*.WAV"); // .WAV,
gtk_file_filter_add_pattern (filter, "*.ogg"); // .ogg,
gtk_file_filter_add_pattern (filter, "*.OGG"); // .OGG
gtk_file_filter_set_name (filter, ".mp3, .wav, .ogg"); // и установим имя этого фильтра.
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter); // Добавим фильтр в диалог выбора файла.
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); // Установим фильтр для диалога.
//Нельзя выбирать несколько записей одновременно - приведёт к непредсказемой работе последующих методов.
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER(dialog), FALSE);
// Запустим поток диалогового окна. Тут же вызовется функция отображения всех виджетов окна.
// Поток будет выполняться до получения сигнала ответа или уничтожения диалогового окна.
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
// Извлекаем нужные URI из полученного.
unsigned int slash;
std::string source = (const char *)gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (dialog)); // Получаем абсолютный путь до файла.
slash = source.rfind("/"); // Находим последний слэш.
if(slash==std::string::npos) // Если слэш - последний символ в источнике, то нужно оповестить об ошибке, т.к. файл не выбран.
{
g_print("Ошибка при добавлении файла\n");
gtk_widget_destroy (dialog);
aMainWin->PrintNotification("Ошибка при добавлении файла", eNotifTypeError); // Выводим диалоговое окно с ошибкой.
return;
}
//Извелкаем URI для базы данных
std::string asFullPatch = source;
// Используя особенную функцию отсечения текста до последнего символа и функцию замены одного символа на другой получим короткий путь до файла.
// Именно его и будем использовать в базе данных и при выводе в окне конвертера.
std::string asShortPatch = aMainWin->FindLastNCopyAfter(asFullPatch, "/");
aMainWin->FindNReplace(asShortPatch, "/", "");
// Точно также выделим тип файла.
std::string asTypeString = aMainWin->FindLastNCopyAfter(asFullPatch, ".");
aMainWin->FindNReplace(asTypeString, ".", "");
// Теперь выделим имя папки с файлом с помощью другой функции, которая копирует текст сначала и по последнее упоминание символа.
std::string asFolderName = aMainWin->FindLastNCopy(asFullPatch, "/");
// Отобразим в консоли все полученные пути для тестов.
std::cout << "Информация о файле: " << std::endl;
std::cout << "\tКороткий путь до файла: " << asShortPatch << std::endl;
std::cout << "\tТип файла: " << asTypeString << std::endl;
std::cout << "\tИмя папки с файлом: " << asFolderName << std::endl;
// Теперь создадим новый трек с полученными параметрами и добавим его в базу данных.
cTrack *aTrack = new cTrack(asFullPatch, asShortPatch, asTypeString, asFolderName);
aMainWin->AddNewTrack(aTrack);
}
gtk_widget_destroy (dialog); // После использования окна, можем его уничтожить.
}
void
vinagre_cmd_remote_open (GtkAction *action,
VinagreWindow *window)
{
GtkWidget *tab;
VinagreConnection *conn;
GtkWidget *dialog;
GtkFileFilter *filter;
GSList *files, *l;
gchar *uri;
gchar *error = NULL;
GSList *errors = NULL;
gint i = 0;
GHashTable *protocols;
GHashTableIter iter;
VinagreProtocol *protocol;
g_return_if_fail (VINAGRE_IS_WINDOW (window));
dialog = gtk_file_chooser_dialog_new (_("Choose the file"),
GTK_WINDOW (window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE);
protocols = vinagre_plugins_engine_get_plugins_by_protocol (vinagre_plugins_engine_get_default ());
g_hash_table_iter_init (&iter, protocols);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&protocol))
{
filter = vinagre_protocol_get_file_filter (protocol);
if (filter)
{
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
i++;
}
}
if (i == 0)
{
vinagre_utils_show_error_dialog (_("There are no supported files"),
_("None of the active plugins support this action. Activate some plugins and try again."),
GTK_WINDOW (window));
goto finalize;
}
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
files = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dialog));
for (l = files; l; l = l->next)
{
uri = (gchar *)l->data;
conn = vinagre_connection_new_from_file (uri, &error, FALSE);
if (conn)
{
tab = vinagre_tab_new (conn, window);
vinagre_notebook_add_tab (VINAGRE_NOTEBOOK (window->priv->notebook),
VINAGRE_TAB (tab),
-1);
g_object_unref (conn);
}
else
{
errors = g_slist_append (errors, g_strdup_printf ("<i>%s</i>: %s", uri, error?error:_("Unknown error")));
g_free (error);
}
g_free (uri);
}
g_slist_free (files);
}
if (errors)
{
vinagre_utils_show_many_errors (ngettext ("The following file could not be opened:",
"The following files could not be opened:",
g_slist_length (errors)),
errors,
GTK_WINDOW (window));
g_slist_free_full (errors, g_free);
}
finalize:
gtk_widget_destroy (dialog);
}
JNIEXPORT jobject JNICALL Java_com_sun_glass_ui_gtk_GtkCommonDialogs__1showFileChooser
(JNIEnv *env, jclass clazz, jlong parent, jstring folder, jstring name, jstring title,
jint type, jboolean multiple, jobjectArray jFilters, jint default_filter_index) {
jobjectArray jFileNames = NULL;
char* filename;
jstring jfilename;
const char* chooser_folder;
const char* chooser_filename;
const char* chooser_title;
const int chooser_type = type == 0 ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE;
if (!jstring_to_utf_get(env, folder, &chooser_folder)) {
return create_empty_result();
}
if (!jstring_to_utf_get(env, title, &chooser_title)) {
jstring_to_utf_release(env, folder, chooser_folder);
return create_empty_result();
}
if (!jstring_to_utf_get(env, name, &chooser_filename)) {
jstring_to_utf_release(env, folder, chooser_folder);
jstring_to_utf_release(env, title, chooser_title);
return create_empty_result();
}
GtkWidget* chooser = gtk_file_chooser_dialog_new(chooser_title, gdk_window_handle_to_gtk(parent),
static_cast<GtkFileChooserAction>(chooser_type),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
(chooser_type == GTK_FILE_CHOOSER_ACTION_OPEN ? GTK_STOCK_OPEN : GTK_STOCK_SAVE),
GTK_RESPONSE_ACCEPT,
NULL);
if (chooser_type == GTK_FILE_CHOOSER_ACTION_SAVE) {
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(chooser), chooser_filename);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (chooser), TRUE);
}
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), (JNI_TRUE == multiple));
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(chooser), chooser_folder);
GSList* filters = setup_GtkFileFilters(GTK_FILE_CHOOSER(chooser), env, jFilters, default_filter_index);
if (gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_ACCEPT) {
GSList* fnames_gslist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(chooser));
guint fnames_list_len = g_slist_length(fnames_gslist);
LOG1("FileChooser selected files: %d\n", fnames_list_len)
if (fnames_list_len > 0) {
jFileNames = env->NewObjectArray((jsize)fnames_list_len, jStringCls, NULL);
for (guint i = 0; i < fnames_list_len; i++) {
filename = (char*)g_slist_nth(fnames_gslist, i)->data;
LOG1("Add [%s] into returned filenames\n", filename)
jfilename = env->NewStringUTF(filename);
env->SetObjectArrayElement(jFileNames, (jsize)i, jfilename);
}
g_slist_foreach(fnames_gslist, (GFunc) free_fname, NULL);
g_slist_free(fnames_gslist);
}
}
bool show(Display* parent) override {
static std::string s_lastUsedDir;
if (s_lastUsedDir.empty())
s_lastUsedDir = g_get_user_special_dir(G_USER_DIRECTORY_DESKTOP);
const char* okLabel;
GtkFileChooserAction action;
switch (m_type) {
case Type::OpenFile:
case Type::OpenFiles:
action = GTK_FILE_CHOOSER_ACTION_OPEN;
okLabel = "_Open";
break;
case Type::OpenFolder:
action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
okLabel = "_Open Folder";
break;
case Type::SaveFile:
action = GTK_FILE_CHOOSER_ACTION_SAVE;
okLabel = "_Save";
break;
}
// GtkWindow* gtkParent = nullptr;
GtkWidget* dialog = gtk_file_chooser_dialog_new(
m_title.c_str(),
nullptr,
action,
"_Cancel", GTK_RESPONSE_CANCEL,
okLabel, GTK_RESPONSE_ACCEPT,
nullptr);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
GtkFileChooser* chooser = GTK_FILE_CHOOSER(dialog);
m_chooser = chooser;
if (m_type == Type::SaveFile)
gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE);
else if (m_type == Type::OpenFiles)
gtk_file_chooser_set_select_multiple(chooser, true);
if (m_type != Type::OpenFolder) {
setupFilters(base::get_file_extension(m_filename));
setupPreview();
}
if (m_initialDir.empty())
gtk_file_chooser_set_current_folder(chooser, s_lastUsedDir.c_str());
else
gtk_file_chooser_set_current_folder(chooser, m_initialDir.c_str());
if (!m_filename.empty()) {
std::string fn = m_filename;
// Add default extension
if (m_type == Type::SaveFile && base::get_file_extension(fn).empty()) {
fn.push_back('.');
fn += m_defExtension;
}
gtk_file_chooser_set_current_name(chooser, fn.c_str());
}
// Setup the "parent" display as the parent of the dialog (we've
// to convert a X11 Window into a GdkWindow to do this).
GdkWindow* gdkParentWindow = nullptr;
if (parent) {
GdkWindow* gdkWindow = gtk_widget_get_root_window(dialog);
gdkParentWindow =
gdk_x11_window_foreign_new_for_display(
gdk_window_get_display(gdkWindow),
(::Window)parent->nativeHandle());
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
gdk_window_set_transient_for(gdkWindow, gdkParentWindow);
}
else {
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
}
// Show the dialog
gint res = gtk_dialog_run(GTK_DIALOG(dialog));
if (res == GTK_RESPONSE_ACCEPT) {
s_lastUsedDir = gtk_file_chooser_get_current_folder(chooser);
m_filename = gtk_file_chooser_get_filename(chooser);
if (m_type == Type::OpenFiles) {
GSList* list = gtk_file_chooser_get_filenames(chooser);
g_slist_foreach(
list,
[](void* fn, void* userdata){
auto self = (FileDialogGTK*)userdata;
self->m_filenames.push_back((char*)fn);
g_free(fn);
}, this);
g_slist_free(list);
}
}
gtk_widget_destroy(dialog);
if (gdkParentWindow)
g_object_unref(gdkParentWindow);
// Pump gtk+ events to finally hide the dialog from the screen
while (gtk_events_pending())
gtk_main_iteration();
return (res == GTK_RESPONSE_ACCEPT);
}
/* Caller must g_slist_free() the returned list .*/
GSList *
ghid_dialog_file_select_multiple(gchar * title, gchar ** path, gchar * shortcuts)
{
GtkWidget *dialog;
GSList *result = NULL;
gchar *folder, *seed;
GHidPort *out = &ghid_port;
GtkFileFilter *no_filter;
dialog = gtk_file_chooser_dialog_new (title,
GTK_WINDOW (out->top_window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER (dialog), TRUE);
/* add a default filter for not filtering files */
no_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (no_filter, "all");
gtk_file_filter_add_pattern (no_filter, "*.*");
gtk_file_filter_add_pattern (no_filter, "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), no_filter);
/* in case we have a dialog for loading schematic files */
if (strcmp (title, _("Load schematics")) == 0)
{
/* add a filter for schematic files */
GtkFileFilter *sch_filter;
sch_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (sch_filter, "sch");
gtk_file_filter_add_mime_type (sch_filter, "application/x-geda-schematic");
gtk_file_filter_add_pattern (sch_filter, "*.sch");
gtk_file_filter_add_pattern (sch_filter, "*.SCH");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), sch_filter);
}
if (path && *path)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), *path);
else
{
gchar *default_path;
default_path = g_get_current_dir();
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), default_path);
g_free(default_path);
}
if (shortcuts && *shortcuts)
{
folder = g_strdup (shortcuts);
seed = folder;
while ((folder = strtok (seed, ":")) != NULL)
{
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog),
folder, NULL);
seed = NULL;
}
g_free (folder);
}
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
result = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (dialog));
folder =
gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
if (folder && path)
{
dup_string (path, folder);
g_free (folder);
}
}
gtk_widget_destroy (dialog);
return result;
}
static void _lib_import_folder_callback(GtkWidget *widget,gpointer user_data)
{
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import film"),
GTK_WINDOW (win),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
(char *)NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE);
char *last_directory = dt_conf_get_string("ui_last/import_last_directory");
if(last_directory != NULL)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory);
dt_lib_import_metadata_t metadata;
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), _lib_import_get_extra_widget(&metadata, TRUE));
// run the dialog
if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)
{
dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser)));
_lib_import_evaluate_extra_widget(&metadata, TRUE);
char *filename = NULL, *first_filename = NULL;
GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser));
GSList *it = list;
/* reset filter to display all images, otherwise view may remain empty */
dt_view_filter_reset_to_show_all(darktable.view_manager);
/* for each selected folder add import job */
while(it)
{
filename = (char *)it->data;
dt_film_import(filename);
if (!first_filename)
{
first_filename = g_strdup(filename);
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (metadata.recursive)))
first_filename = dt_util_dstrcat(first_filename, "%%");
}
g_free (filename);
it = g_slist_next(it);
}
/* update collection to view import */
if (first_filename)
{
dt_conf_set_int("plugins/lighttable/collect/num_rules", 1);
dt_conf_set_int("plugins/lighttable/collect/item0", 0);
dt_conf_set_string("plugins/lighttable/collect/string0",first_filename);
dt_collection_update_query(darktable.collection);
g_free(first_filename);
}
g_slist_free (list);
}
gtk_widget_destroy(metadata.frame);
gtk_widget_destroy (filechooser);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
}
bool ClientHandler::OnFileDialog(CefRefPtr<CefBrowser> browser,
FileDialogMode mode,
const CefString& title,
const CefString& default_file_name,
const std::vector<CefString>& accept_types,
CefRefPtr<CefFileDialogCallback> callback) {
std::vector<CefString> files;
GtkFileChooserAction action;
const gchar* accept_button;
if (mode == FILE_DIALOG_OPEN || mode == FILE_DIALOG_OPEN_MULTIPLE) {
action = GTK_FILE_CHOOSER_ACTION_OPEN;
accept_button = GTK_STOCK_OPEN;
} else if (mode == FILE_DIALOG_SAVE) {
action = GTK_FILE_CHOOSER_ACTION_SAVE;
accept_button = GTK_STOCK_SAVE;
} else {
NOTREACHED();
return false;
}
std::string base_name;
if (!default_file_name.empty()) {
base_name =
basename(const_cast<char*>(default_file_name.ToString().c_str()));
}
std::string title_str;
if (!title.empty()) {
title_str = title;
} else {
switch (mode) {
case FILE_DIALOG_OPEN:
title_str = "Open File";
break;
case FILE_DIALOG_OPEN_MULTIPLE:
title_str = "Open Files";
break;
case FILE_DIALOG_SAVE:
title_str = "Save File";
break;
default:
break;
}
}
GtkWidget* window = gtk_widget_get_ancestor(
GTK_WIDGET(GetMainWindowHandle()), GTK_TYPE_WINDOW);
GtkWidget* dialog = gtk_file_chooser_dialog_new(
title_str.c_str(),
GTK_WINDOW(window),
action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
accept_button, GTK_RESPONSE_ACCEPT,
NULL);
if (mode == FILE_DIALOG_OPEN_MULTIPLE) {
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
} else if (mode == FILE_DIALOG_SAVE) {
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog),
TRUE);
}
if (mode == FILE_DIALOG_SAVE && !base_name.empty()) {
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
base_name.c_str());
}
AddFiltersForAcceptTypes(GTK_FILE_CHOOSER(dialog), accept_types, true);
bool success = false;
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
if (mode == FILE_DIALOG_OPEN || mode == FILE_DIALOG_SAVE) {
char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
files.push_back(std::string(filename));
success = true;
} else if (mode == FILE_DIALOG_OPEN_MULTIPLE) {
GSList* filenames =
gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
if (filenames) {
for (GSList* iter = filenames; iter != NULL;
iter = g_slist_next(iter)) {
std::string path(static_cast<char*>(iter->data));
g_free(iter->data);
files.push_back(path);
}
g_slist_free(filenames);
success = true;
}
}
}
gtk_widget_destroy(dialog);
if (success)
callback->Continue(files);
else
callback->Cancel();
return true;
}
