void
on_toggled (GtkToggleButton *togglebutton, gpointer dialog)
{
gtk_file_chooser_set_show_hidden (GTK_FILE_CHOOSER (dialog),
!gtk_file_chooser_get_show_hidden
(GTK_FILE_CHOOSER (dialog)));
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1set_1show_1hidden
(
JNIEnv* env,
jclass cls,
jlong _self,
jboolean _showHidden
)
{
GtkFileChooser* self;
gboolean showHidden;
// convert parameter self
self = (GtkFileChooser*) _self;
// convert parameter showHidden
showHidden = (gboolean) _showHidden;
// call function
gtk_file_chooser_set_show_hidden(self, showHidden);
// cleanup parameter self
// cleanup parameter showHidden
}
static char *filedialog(GtkWindow *parent, GtkFileChooserAction mode, const gchar *confirm)
{
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);
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);
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;
}
bool FileSelector::Execute(bool open, const char *title)
{
Ctrl::ReleaseCtrlCapture();
if(!title)
title = open ? t_("Open") : t_("Save as");
Ctrl *w = Ctrl::GetActiveWindow();
GtkWidget *fc = gtk_file_chooser_dialog_new(title, w ? w->gtk() : NULL,
open ? GTK_FILE_CHOOSER_ACTION_OPEN
: GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
open ? GTK_STOCK_OPEN : GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(fc), confirm);
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(fc), true);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(fc), multi);
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(fc), hidden);
if(IsFullPath(ipath)) {
FindFile ff(ipath);
if(ff)
if(ff.IsFolder())
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc), ipath);
else
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(fc), ipath);
else {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc), GetFileFolder(ipath));
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(fc), GetFileName(ipath));
}
}
else
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(fc), ipath);
ipath.Clear();
for(int i = 0; i < type.GetCount(); i++) {
GtkFileFilter *filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, type[i].a);
gtk_file_filter_add_pattern(filter, type[i].b);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fc), filter);
if(i == activetype)
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(fc), filter);
}
bool ret = false;
path.Clear();
if(gtk_dialog_run(GTK_DIALOG(fc)) == GTK_RESPONSE_OK) {
GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(fc));
if(list) {
GSList *l;
for(l = list; l; l = l->next) {
path.Add((const char *)l->data);
g_free(l->data);
}
g_slist_free (list);
}
ret = true;
}
gtk_widget_destroy(fc);
return ret;
}
static void
browse_button_cb (GtkWidget *widget, gpointer data)
{
GtkWindow *parent = GTK_WINDOW (data);
GtkFileFilter *filter;
GtkWidget *file_dialog;
file_dialog = gtk_file_chooser_dialog_new (_("Select User Image"),
parent,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_show_hidden (GTK_FILE_CHOOSER (file_dialog), FALSE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_dialog), TRUE);
gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (file_dialog), FALSE);
if (facedir && g_file_test (facedir, G_FILE_TEST_IS_DIR)) {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_dialog),
facedir);
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (file_dialog),
facedir, NULL);
} else {
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_dialog),
DATADIR "/pixmaps");
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (file_dialog),
DATADIR "/pixmaps", NULL);
}
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Images"));
gtk_file_filter_add_pixbuf_formats (filter);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_dialog), filter);
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 (file_dialog), filter);
if (imagename != NULL) {
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (file_dialog), imagename);
}
add_preview_widget (file_dialog);
g_signal_connect (G_OBJECT (file_dialog), "response",
G_CALLBACK (install_response), NULL);
gtk_widget_show (file_dialog);
}
GSList *
file_chooser(char * title, GtkWidget * parent, GtkFileChooserAction action, int filter,
gint multiple, char * destpath) {
GtkWidget * dialog;
GSList * files = NULL;
dialog = gtk_file_chooser_dialog_new(title,
GTK_WINDOW(parent),
action,
(action == GTK_FILE_CHOOSER_ACTION_SAVE) ? GTK_STOCK_SAVE : GTK_STOCK_OPEN,
GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), multiple);
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog), destpath);
if (action == GTK_FILE_CHOOSER_ACTION_SAVE) {
char * bname = g_path_get_basename(destpath);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), bname);
g_free(bname);
}
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
assign_fc_filters(GTK_FILE_CHOOSER(dialog), filter);
if (options.show_hidden) {
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
}
if (aqualung_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
strncpy(destpath,
gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)),
MAXLEN-1);
files = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
}
gtk_widget_destroy(dialog);
return files;
}
/*
* GtkFileChooser to select a directory to scan
*/
gchar *
dir_select (gboolean SEARCH, GtkWidget *parent)
{
static GtkWidget *file_chooser = NULL;
GtkWidget *toggle;
if (file_chooser == NULL) {
file_chooser = gtk_file_chooser_dialog_new (_("Select Folder"),
GTK_WINDOW (parent),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN,
GTK_RESPONSE_OK, NULL);
gtk_file_chooser_set_show_hidden (GTK_FILE_CHOOSER (file_chooser), FALSE);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (file_chooser),
g_get_home_dir ());
/* add extra widget */
toggle = gtk_check_button_new_with_mnemonic (_("_Show hidden folders"));
gtk_widget_show (toggle);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), FALSE);
g_signal_connect ((gpointer) toggle, "toggled",
G_CALLBACK (on_toggled), file_chooser);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_chooser),
toggle);
g_signal_connect (file_chooser, "response",
G_CALLBACK (filechooser_cb), NULL);
g_signal_connect (file_chooser, "destroy",
G_CALLBACK (gtk_widget_destroyed), &file_chooser);
gtk_window_set_modal (GTK_WINDOW (file_chooser), TRUE);
gtk_window_set_position (GTK_WINDOW (file_chooser), GTK_WIN_POS_CENTER_ON_PARENT);
}
gtk_widget_show (GTK_WIDGET (file_chooser));
return NULL;
}
void
directory_chooser(char * title, GtkWidget * parent, char * directory) {
GtkWidget * dialog;
const gchar * selected_directory;
dialog = gtk_file_chooser_dialog_new(title,
GTK_WINDOW(parent),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog), directory);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
if (options.show_hidden) {
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), TRUE);
}
if (aqualung_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char * utf8;
selected_directory = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
utf8 = g_filename_to_utf8(selected_directory, -1, NULL, NULL, NULL);
if (utf8 == NULL) {
gtk_widget_destroy(dialog);
}
strncpy(directory, selected_directory, MAXLEN-1);
g_free(utf8);
}
gtk_widget_destroy(dialog);
}
void GtkFileChooserDialog_::set_show_hidden(Php::Parameters ¶meters)
{
gboolean show_hidden = (gboolean)parameters[0];
gtk_file_chooser_set_show_hidden (GTK_FILE_CHOOSER(instance), show_hidden);
}
static char *
gtk_openfile( Bool open)
{
char *result = NULL;
struct MsgDlg message_dlg, **storage;
if ( gtk_dialog) return NULL; /* we're not reentrant */
gtk_dialog = gtk_file_chooser_dialog_new (
gtk_dialog_title_ptr ?
gtk_dialog_title_ptr :
( open ? "Open File" : "Save File"),
NULL,
open ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_local_only( GTK_FILE_CHOOSER (gtk_dialog), TRUE);
if (open)
gtk_file_chooser_set_select_multiple( GTK_FILE_CHOOSER (gtk_dialog), gtk_select_multiple);
#if GTK_MAJOR_VERSION >= 2 && GTK_MINOR_VERSION >= 8
gtk_file_chooser_set_do_overwrite_confirmation( GTK_FILE_CHOOSER (gtk_dialog), gtk_overwrite_prompt);
gtk_file_chooser_set_show_hidden( GTK_FILE_CHOOSER (gtk_dialog), gtk_show_hidden_files);
#endif
if ( gtk_current_folder_ptr)
gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER (gtk_dialog), gtk_current_folder_ptr);
if ( gtk_filters) {
int i;
for ( i = 0; i < gtk_filters-> count; i++) {
gtk_file_chooser_add_filter(
GTK_FILE_CHOOSER (gtk_dialog),
GTK_FILE_FILTER (gtk_filters-> items[i])
);
if ( i == gtk_filter_index)
gtk_file_chooser_set_filter(
GTK_FILE_CHOOSER (gtk_dialog),
GTK_FILE_FILTER (gtk_filters-> items[i])
);
}
}
/* lock prima interactions */
bzero( &message_dlg, sizeof(message_dlg));
storage = &guts. message_boxes;
while ( *storage) storage = &((*storage)-> next);
*storage = &message_dlg;
g_idle_add( do_events, NULL);
if (gtk_dialog_run (GTK_DIALOG (gtk_dialog)) == GTK_RESPONSE_ACCEPT) {
/* files */
if ( gtk_select_multiple) {
int size;
char * ptr;
GSList *names, *iter;
names = gtk_file_chooser_get_filenames ( GTK_FILE_CHOOSER (gtk_dialog));
/* count total length with escaped spaces and backslashes */
size = 1;
iter = names;
while ( iter) {
char * c = (char*) iter-> data;
while ( *c) {
if ( *c == ' ' || *c == '\\')
size++;
size++;
c++;
}
size++;
iter = iter-> next;
}
if (( result = ptr = malloc( size))) {
/* copy and encode */
iter = names;
while ( iter) {
char * c = (char*) iter-> data;
while ( *c) {
if ( *c == ' ' || *c == '\\')
*(ptr++) = '\\';
*(ptr++) = *c;
c++;
}
iter = iter-> next;
*(ptr++) = ' ';
}
*(ptr - 1) = 0;
} else {
warn("gtk_openfile: cannot allocate %d bytes of memory", size);
}
/* free */
iter = names;
while ( iter) {
g_free( iter-> data);
iter = iter-> next;
}
g_slist_free( names);
} else {
char * filename = gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER (gtk_dialog));
result = duplicate_string( filename);
g_free (filename);
}
/* directory */
{
char * d = gtk_file_chooser_get_current_folder( GTK_FILE_CHOOSER (gtk_dialog));
if ( d) {
strncpy( gtk_current_folder, d, MAXPATHLEN);
gtk_current_folder_ptr = gtk_current_folder;
g_free( d);
} else {
gtk_current_folder_ptr = NULL;
}
}
/* filter index */
gtk_filter_index = 0;
if ( gtk_filters) {
int i;
Handle f = ( Handle) gtk_file_chooser_get_filter( GTK_FILE_CHOOSER (gtk_dialog));
for ( i = 0; i < gtk_filters-> count; i++)
if ( gtk_filters-> items[i] == f) {
gtk_filter_index = i;
break;
}
}
}
if ( gtk_filters) {
plist_destroy( gtk_filters);
gtk_filters = NULL;
}
*storage = message_dlg. next; /* unlock */
gtk_widget_destroy (gtk_dialog);
gtk_dialog = NULL;
while ( gtk_events_pending()) gtk_main_iteration();
return result;
}
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;
}
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_session_save_dialog()
*****************************************************************************/
void
create_session_save_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_save_dialog == NULL) {
/* create dialog */
session_save_dialog = gtk_file_chooser_dialog_new("PHASEX - Save Session",
GTK_WINDOW(main_window),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE,
GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_wmclass(GTK_WINDOW(session_save_dialog), "phasex", "phasex-save");
gtk_window_set_role(GTK_WINDOW(session_save_dialog), "session-save");
gtk_file_chooser_set_preview_widget_active
(GTK_FILE_CHOOSER(session_save_dialog), FALSE);
/* create spinbutton control of session number */
hbox = gtk_hbox_new(FALSE, 8);
label = gtk_label_new("Save into 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_save_start_spin = gtk_spin_button_new(GTK_ADJUSTMENT(session_io_start_adj), 0, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(session_save_start_spin), TRUE);
gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(session_save_start_spin),
GTK_UPDATE_IF_VALID);
gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(session_save_start_spin), TRUE);
gtk_adjustment_set_value(GTK_ADJUSTMENT(session_io_start_adj), (session_io_start + 1));
gtk_box_pack_start(GTK_BOX(hbox), session_save_start_spin, FALSE, FALSE, 8);
if (new_adj) {
g_signal_connect(GTK_OBJECT(session_save_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_save_dialog), hbox);
/* realize the file chooser before telling it about files */
gtk_widget_realize(session_save_dialog);
#if GTK_CHECK_VERSION(2, 8, 0)
/* this can go away once manual overwrite checks are proven to work properly */
gtk_file_chooser_set_do_overwrite_confirmation
(GTK_FILE_CHOOSER(session_save_dialog), TRUE);
#endif
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(session_save_dialog), TRUE);
#endif
/* add user session dir as shortcut folder (user cannot write to sys) */
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(session_save_dialog),
user_session_dir, &error);
if (error != NULL) {
PHASEX_ERROR("Error %d: %s\n", error->code, error->message);
g_error_free(error);
}
/* start in user session dir (usually ~/.phasex/user-sessions) */
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(session_save_dialog),
user_session_dir);
}
}
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) ;
}
}
void get_folder_to_play(GtkWidget *widget, gpointer user_data) {
/** User folder selection. **/
#ifdef DEBUG
DEBUG_FUNC_MARK
#endif
GtkWidget *folder_chooser_dialog = gtk_file_chooser_dialog_new("Choose a folder contains music files to listen.", NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "Cancel", GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(folder_chooser_dialog), current_folder.c_str() ) ;
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(folder_chooser_dialog), FALSE) ;
gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(folder_chooser_dialog), FALSE) ;
gtk_file_chooser_set_use_preview_label(GTK_FILE_CHOOSER(folder_chooser_dialog), TRUE) ;
gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(folder_chooser_dialog), TRUE) ;
gtk_window_set_position(GTK_WINDOW(folder_chooser_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
gtk_widget_set_size_request(folder_chooser_dialog,-1,-1) ;
gtk_window_set_modal(GTK_WINDOW(folder_chooser_dialog), TRUE) ;
gtk_window_set_destroy_with_parent(GTK_WINDOW(folder_chooser_dialog), TRUE) ;
gtk_window_set_type_hint(GTK_WINDOW(folder_chooser_dialog), GDK_WINDOW_TYPE_HINT_DIALOG) ;
gtk_window_set_transient_for(GTK_WINDOW(folder_chooser_dialog), GTK_WINDOW(gui->window)) ;
gchar *folderpath = NULL ; // Selected folder.
gint result = gtk_dialog_run (GTK_DIALOG (folder_chooser_dialog));
switch (result) {
case GTK_RESPONSE_CANCEL :
if (! is_playing) {
gtk_button_set_label(GTK_BUTTON(gui->folder_chooser_button), "Select a folder to play content") ;
}
gtk_widget_destroy(folder_chooser_dialog);
return ;
case GTK_RESPONSE_ACCEPT :
folderpath = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(folder_chooser_dialog));
gtk_widget_destroy(folder_chooser_dialog);
break ;
}
parse_folder(folderpath) ;
gchar *dirname = g_path_get_dirname(folderpath) ;
current_folder = dirname ;
g_free(dirname) ;
#ifdef DEBUG
fprintf(stdout,"%s current_folder: %s\n", __func__, current_folder.c_str() ) ;
#endif
g_free(folderpath) ;
}
void
file_chooser_with_entry(char * title, GtkWidget * parent, GtkFileChooserAction action, int filter,
GtkWidget * entry, char * destpath) {
GtkWidget * dialog;
const gchar * selected_filename = gtk_entry_get_text(GTK_ENTRY(entry));
char path[MAXLEN];
path[0] = '\0';
dialog = gtk_file_chooser_dialog_new(title,
GTK_WINDOW(parent),
action,
GTK_STOCK_APPLY, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
if (options.show_hidden) {
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog), options.show_hidden);
}
if (strlen(selected_filename)) {
char * filename = g_filename_from_utf8(selected_filename, -1, NULL, NULL, NULL);
if (filename == NULL) {
gtk_widget_destroy(dialog);
return;
}
normalize_filename(filename, path);
g_free(filename);
} else {
strncpy(path, destpath, MAXLEN-1);
}
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), path);
if (action == GTK_FILE_CHOOSER_ACTION_SAVE) {
char * bname = g_path_get_basename(path);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), bname);
g_free(bname);
}
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
assign_fc_filters(GTK_FILE_CHOOSER(dialog), filter);
if (aqualung_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char * utf8;
selected_filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
utf8 = g_filename_to_utf8(selected_filename, -1, NULL, NULL, NULL);
if (utf8 == NULL) {
gtk_widget_destroy(dialog);
}
gtk_entry_set_text(GTK_ENTRY(entry), utf8);
strncpy(destpath, selected_filename, MAXLEN-1);
g_free(utf8);
}
gtk_widget_destroy(dialog);
}
void GtkToolkitFileChooser::ShowHiddenFiles(bool show_hidden)
{
gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(m_dialog), show_hidden);
}
