void
nsFilePicker::ReadValuesFromFileChooser(GtkWidget *file_chooser)
{
mFiles.Clear();
if (mMode == nsIFilePicker::modeOpenMultiple) {
mFileURL.Truncate();
GSList *list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser));
g_slist_foreach(list, ReadMultipleFiles, static_cast<gpointer>(&mFiles));
g_slist_free(list);
} else {
gchar *filename = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(file_chooser));
mFileURL.Assign(filename);
g_free(filename);
}
GtkFileFilter *filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(file_chooser));
GSList *filter_list = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(file_chooser));
mSelectedType = static_cast<PRInt16>(g_slist_index(filter_list, filter));
g_slist_free(filter_list);
// Remember last used directory.
nsCOMPtr<nsILocalFile> file;
GetFile(getter_AddRefs(file));
if (file) {
nsCOMPtr<nsIFile> dir;
file->GetParent(getter_AddRefs(dir));
nsCOMPtr<nsILocalFile> localDir(do_QueryInterface(dir));
if (localDir) {
localDir.swap(mPrevDisplayDirectory);
}
}
}
GtkFileFilter* GtkToolkitFileChooser::GetFilterById(int id)
{
GSList* list = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(m_dialog));
GtkFileFilter* filter = GTK_FILE_FILTER(g_slist_nth_data(list, id));
g_slist_free(list);
return filter;
}
int GtkToolkitFileChooser::GetSelectedFilter()
{
GSList* list = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(m_dialog));
GtkFileFilter* selected_filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(m_dialog));
return g_slist_index(list, selected_filter);
}
JNIEXPORT jlongArray JNICALL
Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1list_1filters
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GSList* result;
jlongArray _result;
GtkFileChooser* self;
// convert parameter self
self = (GtkFileChooser*) _self;
// call function
result = gtk_file_chooser_list_filters(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jlongArray) bindings_java_convert_gslist_to_jarray(env, result);
// cleanup return value
if (result != NULL) {
g_slist_free(result);
}
// and finally
return _result;
}
void wxGtkFileChooser::SetWildcard( const wxString& wildCard )
{
m_wildcards.Empty();
// parse filters
wxArrayString wildDescriptions, wildFilters;
if ( !wxParseCommonDialogsFilter( wildCard, wildDescriptions, wildFilters ) )
{
wxFAIL_MSG( wxT( "wxGtkFileChooser::SetWildcard - bad wildcard string" ) );
}
else
{
// Parsing went fine. Set m_wildCard to be returned by wxGtkFileChooserBase::GetWildcard
GtkFileChooser* chooser = m_widget;
// empty current filter list:
GSList* ifilters = gtk_file_chooser_list_filters( chooser );
GSList* filters = ifilters;
m_ignoreNextFilterEvent = true;
wxON_BLOCK_EXIT_SET(m_ignoreNextFilterEvent, false);
while ( ifilters )
{
gtk_file_chooser_remove_filter( chooser, GTK_FILE_FILTER( ifilters->data ) );
ifilters = ifilters->next;
}
g_slist_free( filters );
if (!wildCard.empty())
{
// add parsed to GtkChooser
for ( size_t n = 0; n < wildFilters.GetCount(); ++n )
{
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_set_name( filter, wxGTK_CONV_SYS( wildDescriptions[n] ) );
wxStringTokenizer exttok( wildFilters[n], wxT( ";" ) );
int n1 = 1;
while ( exttok.HasMoreTokens() )
{
wxString token = exttok.GetNextToken();
gtk_file_filter_add_pattern( filter, wxGTK_CONV_SYS( token ) );
if (n1 == 1)
m_wildcards.Add( token ); // Only add first pattern to list, used later when saving
n1++;
}
gtk_file_chooser_add_filter( chooser, filter );
}
// Reset the filter index
SetFilterIndex( 0 );
}
}
}
void wxFileDialog::SetFilterIndex(int filterIndex)
{
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
gpointer filter;
GtkFileChooser *chooser = GTK_FILE_CHOOSER(m_widget);
GSList *filters = gtk_file_chooser_list_filters(chooser);
filter = g_slist_nth_data(filters, filterIndex);
if (filter != NULL)
{
gtk_file_chooser_set_filter(chooser, GTK_FILE_FILTER(filter));
}
else
{
wxFAIL_MSG( wxT("wxFileDialog::SetFilterIndex - bad filter index") );
}
g_slist_free(filters);
}
else
#endif
wxGenericFileDialog::SetFilterIndex( filterIndex );
}
bool FileDialogImpl::run()
{
//Init the dialog
GtkWidget* fileDialog = gtk_file_chooser_dialog_new(
m_title.c_str(),
nullptr,
m_action == FileDialog::Open ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"),
GTK_RESPONSE_CANCEL,
m_action == FileDialog::Open ? _("_Open") : _("Save"),
GTK_RESPONSE_ACCEPT,
nullptr
);
//Init the filters
for(auto it = m_filters.cbegin(); it != m_filters.cend(); ++it)
{
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, it->name.c_str());
for(auto it2 = it->patterns.cbegin(); it2 != it->patterns.cend(); ++it2)
gtk_file_filter_add_pattern(filter, (*it2).c_str());
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileDialog), filter);
}
//Set the default filter
GSList* filtersList = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(fileDialog));
if(m_selectedFilter < g_slist_length(filtersList))
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(fileDialog), GTK_FILE_FILTER(g_slist_nth_data(filtersList, m_selectedFilter)));
g_slist_free(filtersList);
gtk_window_set_keep_above(GTK_WINDOW(fileDialog), TRUE);
//Run it
gint result = gtk_dialog_run(GTK_DIALOG(fileDialog));
if(result == GTK_RESPONSE_ACCEPT)
{
char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fileDialog));
m_selectedFileName = std::string(filename);
g_free(filename);
}
gtk_window_close(GTK_WINDOW(fileDialog));
gtk_widget_destroy(fileDialog);
while (gtk_events_pending())
gtk_main_iteration_do(false);
return result == GTK_RESPONSE_ACCEPT;
}
void wxFileDialog::SetWildcard(const wxString& wildCard)
{
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
// parse filters
wxArrayString wildDescriptions, wildFilters;
if (!wxParseCommonDialogsFilter(wildCard, wildDescriptions, wildFilters))
{
wxFAIL_MSG( wxT("wxFileDialog::SetWildCard - bad wildcard string") );
}
else
{
// Parsing went fine. Set m_wildCard to be returned by wxFileDialogBase::GetWildcard
m_wildCard = wildCard;
GtkFileChooser* chooser = GTK_FILE_CHOOSER(m_widget);
// empty current filter list:
GSList* ifilters = gtk_file_chooser_list_filters(chooser);
GSList* filters = ifilters;
while (ifilters)
{
gtk_file_chooser_remove_filter(chooser,GTK_FILE_FILTER(ifilters->data));
ifilters = ifilters->next;
}
g_slist_free(filters);
// add parsed to GtkChooser
for (size_t n = 0; n < wildFilters.GetCount(); ++n)
{
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, wxGTK_CONV(wildDescriptions[n]));
wxStringTokenizer exttok(wildFilters[n], wxT(";"));
while (exttok.HasMoreTokens())
{
wxString token = exttok.GetNextToken();
gtk_file_filter_add_pattern(filter, wxGTK_CONV(token));
}
gtk_file_chooser_add_filter(chooser, filter);
}
// Reset the filter index
SetFilterIndex(0);
}
}
else
#endif
wxGenericFileDialog::SetWildcard( wildCard );
}
int wxGtkFileChooser::GetFilterIndex() const
{
GtkFileChooser *chooser = m_widget;
GtkFileFilter *filter = gtk_file_chooser_get_filter( chooser );
GSList *filters = gtk_file_chooser_list_filters( chooser );
const gint index = g_slist_index( filters, filter );
g_slist_free( filters );
if ( index == -1 )
{
wxFAIL_MSG( wxT( "wxGtkFileChooser::GetFilterIndex - bad filter index returned by gtk+" ) );
return 0;
}
else
return index;
}
int FileDialog::GetFilterIndex() const
{
GtkFileChooser *chooser = GTK_FILE_CHOOSER(m_widget);
GtkFileFilter *filter = gtk_file_chooser_get_filter(chooser);
GSList *filters = gtk_file_chooser_list_filters(chooser);
gint index = g_slist_index(filters, filter);
g_slist_free(filters);
if (index == -1)
{
wxFAIL_MSG( wxT("FileDialog::GetFilterIndex - bad filter index returned by gtk+") );
return 0;
}
else
return index;
}
Php::Value GtkFileChooserDialog_::list_filters()
{
GSList *ret = gtk_file_chooser_list_filters (GTK_FILE_CHOOSER(instance));
Php::Value ret_arr;
for(int index=0; GSList *item=g_slist_nth(ret, index); index++) {
GtkFileFilter_ *return_parsed = new GtkFileFilter_();
return_parsed->set_instance((gpointer *)GTK_FILE_CHOOSER(item->data));
ret_arr[index] = Php::Object("GtkFileFilter", return_parsed);
}
return ret_arr;
}
static GVariant *
get_filters (GtkFileChooser *self)
{
GSList *list, *l;
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(sa(us))"));
list = gtk_file_chooser_list_filters (self);
for (l = list; l; l = l->next)
{
GtkFileFilter *filter = l->data;
g_variant_builder_add (&builder, "@(sa(us))", gtk_file_filter_to_gvariant (filter));
}
g_slist_free (list);
return g_variant_builder_end (&builder);
}
void wxGtkFileChooser::SetFilterIndex( int filterIndex )
{
gpointer filter;
GtkFileChooser *chooser = m_widget;
GSList *filters = gtk_file_chooser_list_filters( chooser );
filter = g_slist_nth_data( filters, filterIndex );
if ( filter != NULL )
{
gtk_file_chooser_set_filter( chooser, GTK_FILE_FILTER( filter ) );
}
else
{
wxFAIL_MSG( wxT( "wxGtkFileChooser::SetFilterIndex - bad filter index" ) );
}
g_slist_free( filters );
}
static HRESULT STDMETHODCALLTYPE
ifiledialogevents_OnTypeChange (IFileDialogEvents * self,
IFileDialog *pfd)
{
FileDialogEvents *events = (FileDialogEvents *) self;
UINT fileType;
HRESULT hr = IFileDialog_GetFileTypeIndex (pfd, &fileType);
if (FAILED (hr))
{
g_warning_hr ("Can't get current file type", hr);
return S_OK;
}
fileType--; // fileTypeIndex starts at 1
GSList *filters = gtk_file_chooser_list_filters (GTK_FILE_CHOOSER (events->data->self));
events->data->self->current_filter = g_slist_nth_data (filters, fileType);
g_slist_free (filters);
g_object_notify (G_OBJECT (events->data->self), "filter");
return S_OK;
}
static void
import_adapt_extension_callback(GtkWidget *widget)
{
int index = gtk_combo_box_get_active (GTK_COMBO_BOX(widget));
GtkFileFilter *former = NULL;
GSList *list, *elem;
list = gtk_file_chooser_list_filters (GTK_FILE_CHOOSER (opendlg));
for (elem = list; elem != NULL; elem = g_slist_next (elem))
if (strcmp (_("Supported Formats"), gtk_file_filter_get_name (GTK_FILE_FILTER(elem->data))) == 0)
former = GTK_FILE_FILTER(elem->data);
g_slist_free (list);
if (former) {
/* replace the previous filter */
GtkFileFilter *filter = build_gtk_file_filter_from_index (index);
gtk_file_chooser_remove_filter (GTK_FILE_CHOOSER (opendlg), former);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (opendlg), filter);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (opendlg), filter);
}
}
int wxFileDialog::GetFilterIndex() const
{
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
GtkFileChooser *chooser = GTK_FILE_CHOOSER(m_widget);
GtkFileFilter *filter = gtk_file_chooser_get_filter(chooser);
GSList *filters = gtk_file_chooser_list_filters(chooser);
gint index = g_slist_index(filters, filter);
g_slist_free(filters);
if (index == -1)
{
wxFAIL_MSG( wxT("wxFileDialog::GetFilterIndex - bad filter index returned by gtk+") );
return 0;
}
else
return index;
}
else
#endif
return wxGenericFileDialog::GetFilterIndex();
}
int
clip_GTK_FILECHOOSERLISTFILTERS(ClipMachine * ClipMachineMemory)
{
C_object *cchooser = _fetch_co_arg(ClipMachineMemory);
GSList *list;
ClipVar *cv = RETPTR(ClipMachineMemory);
long l;
CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
list = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(cchooser->object));
l = g_slist_length(list);
_clip_array(ClipMachineMemory, cv, 1, &l);
for (l = 0; list; list = g_slist_next(list), l++)
{
GtkFileFilter *filter;
C_object *cfilter;
filter = GTK_FILE_FILTER(list->data);
cfilter = _list_get_cobject(ClipMachineMemory, filter);
if (!cfilter)
cfilter = _register_object(ClipMachineMemory, filter, GTK_TYPE_FILE_FILTER, NULL, NULL);
if (cfilter)
_clip_aset(ClipMachineMemory, cv, &cfilter->obj, 1, &l);
}
g_slist_free(list);
return 0;
err:
return 1;
}
static GSList *
delegate_list_filters (GtkFileChooser *chooser)
{
return gtk_file_chooser_list_filters (get_delegate (chooser));
}
gboolean
gtk_file_chooser_native_win32_show (GtkFileChooserNative *self)
{
GThread *thread;
FilechooserWin32ThreadData *data;
GtkWindow *transient_for;
GtkFileChooserAction action;
guint update_preview_signal;
GSList *filters, *l;
int n_filters, i;
if (gtk_file_chooser_get_extra_widget (GTK_FILE_CHOOSER (self)) != NULL)
return FALSE;
update_preview_signal = g_signal_lookup ("update-preview", GTK_TYPE_FILE_CHOOSER);
if (g_signal_has_handler_pending (self, update_preview_signal, 0, TRUE))
return FALSE;
data = g_new0 (FilechooserWin32ThreadData, 1);
filters = gtk_file_chooser_list_filters (GTK_FILE_CHOOSER (self));
n_filters = g_slist_length (filters);
if (n_filters > 0)
{
data->filters = g_new0 (COMDLG_FILTERSPEC, n_filters + 1);
for (l = filters, i = 0; l != NULL; l = l->next, i++)
{
if (!file_filter_to_win32 (l->data, &data->filters[i]))
{
filechooser_win32_thread_data_free (data);
return FALSE;
}
}
self->current_filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (self));
}
else
{
self->current_filter = NULL;
}
self->mode_data = data;
data->self = g_object_ref (self);
data->shortcut_uris =
gtk_file_chooser_list_shortcut_folder_uris (GTK_FILE_CHOOSER (self->dialog));
data->accept_label = translate_mnemonics (self->accept_label);
data->cancel_label = translate_mnemonics (self->cancel_label);
action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (self->dialog));
if (action == GTK_FILE_CHOOSER_ACTION_SAVE ||
action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
data->save = TRUE;
if (action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
data->folder = TRUE;
if ((action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ||
action == GTK_FILE_CHOOSER_ACTION_OPEN) &&
gtk_file_chooser_get_select_multiple (GTK_FILE_CHOOSER (self->dialog)))
data->select_multiple = TRUE;
if (gtk_file_chooser_get_do_overwrite_confirmation (GTK_FILE_CHOOSER (self->dialog)))
data->overwrite_confirmation = TRUE;
if (gtk_file_chooser_get_show_hidden (GTK_FILE_CHOOSER (self->dialog)))
data->show_hidden = TRUE;
transient_for = gtk_native_dialog_get_transient_for (GTK_NATIVE_DIALOG (self));
if (transient_for)
{
gtk_widget_realize (GTK_WIDGET (transient_for));
data->parent = gdk_win32_surface_get_handle (gtk_widget_get_surface (GTK_WIDGET (transient_for)));
if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self)))
data->modal = TRUE;
}
data->title =
g_strdup (gtk_native_dialog_get_title (GTK_NATIVE_DIALOG (self)));
if (self->current_file)
data->current_file = g_object_ref (self->current_file);
else
{
if (self->current_folder)
data->current_folder = g_object_ref (self->current_folder);
if (action == GTK_FILE_CHOOSER_ACTION_SAVE ||
action == GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER)
data->current_name = g_strdup (self->current_name);
}
data->events = file_dialog_events_new (!data->modal, data);
thread = g_thread_new ("win32 filechooser", filechooser_win32_thread, data);
if (thread == NULL)
{
filechooser_win32_thread_data_free (data);
return FALSE;
}
return TRUE;
}
static gpointer
filechooser_win32_thread (gpointer _data)
{
FilechooserWin32ThreadData *data = _data;
HRESULT hr;
IFileDialog *pfd = NULL;
IFileDialog2 *pfd2 = NULL;
DWORD flags;
DWORD cookie;
GSList *l;
CoInitializeEx (NULL, COINIT_APARTMENTTHREADED);
if (data->save && !data->folder)
hr = CoCreateInstance (&CLSID_FileSaveDialog,
NULL, CLSCTX_INPROC_SERVER,
&IID_IFileSaveDialog, (LPVOID *) &pfd);
else
hr = CoCreateInstance (&CLSID_FileOpenDialog,
NULL, CLSCTX_INPROC_SERVER,
&IID_IFileOpenDialog, (LPVOID *) &pfd);
if (FAILED (hr))
g_error ("Can't create FileOpenDialog: %s", g_win32_error_message (hr));
hr = IFileDialog_GetOptions (pfd, &flags);
if (FAILED (hr))
g_error ("Can't get FileDialog options: %s", g_win32_error_message (hr));
flags |= FOS_FORCEFILESYSTEM;
if (data->folder)
flags |= FOS_PICKFOLDERS;
if (data->folder && data->save)
flags &= ~(FOS_FILEMUSTEXIST);
if (data->select_multiple)
flags |= FOS_ALLOWMULTISELECT;
if (data->show_hidden)
flags |= FOS_FORCESHOWHIDDEN;
if (data->overwrite_confirmation)
flags |= FOS_OVERWRITEPROMPT;
else
flags &= ~(FOS_OVERWRITEPROMPT);
hr = IFileDialog_SetOptions (pfd, flags);
if (FAILED (hr))
g_error ("Can't set FileDialog options: %s", g_win32_error_message (hr));
if (data->title)
{
gunichar2 *label = g_utf8_to_utf16 (data->title, -1,
NULL, NULL, NULL);
IFileDialog_SetTitle (pfd, label);
g_free (label);
}
if (data->accept_label)
{
gunichar2 *label = g_utf8_to_utf16 (data->accept_label, -1,
NULL, NULL, NULL);
IFileDialog_SetOkButtonLabel (pfd, label);
g_free (label);
}
if (data->cancel_label)
{
gunichar2 *label = g_utf8_to_utf16 (data->cancel_label, -1,
NULL, NULL, NULL);
hr = IFileDialog_QueryInterface (pfd, &IID_IFileDialog2, (LPVOID *) &pfd2);
if (SUCCEEDED (hr))
{
IFileDialog2_SetCancelButtonLabel (pfd2, label);
IFileDialog2_Release (pfd2);
}
g_free (label);
}
for (l = data->shortcut_uris; l != NULL; l = l->next)
{
IShellItem *item = get_shell_item_for_uri (l->data);
if (item)
{
hr = IFileDialog_AddPlace (pfd, item, FDAP_BOTTOM);
if (FAILED (hr))
g_warning_hr ("Can't add dialog shortcut", hr);
IShellItem_Release (item);
}
}
if (data->current_file)
{
IFileSaveDialog *pfsd;
hr = IFileDialog_QueryInterface (pfd, &IID_IFileSaveDialog, (LPVOID *) &pfsd);
if (SUCCEEDED (hr))
{
IShellItem *item = get_shell_item_for_file (data->current_file);
if (item)
{
hr = IFileSaveDialog_SetSaveAsItem (pfsd, item);
if (FAILED (hr))
g_warning_hr ("Can't set save as item", hr);
IShellItem_Release (item);
}
IFileSaveDialog_Release (pfsd);
}
}
if (data->current_folder)
{
IShellItem *item = get_shell_item_for_file (data->current_folder);
if (item)
{
hr = IFileDialog_SetFolder (pfd, item);
if (FAILED (hr))
g_warning_hr ("Can't set folder", hr);
IShellItem_Release (item);
}
}
if (data->current_name)
{
gunichar2 *name = g_utf8_to_utf16 (data->current_name, -1, NULL, NULL, NULL);
hr = IFileDialog_SetFileName (pfd, name);
if (FAILED (hr))
g_warning_hr ("Can't set file name", hr);
g_free (name);
}
if (data->filters)
{
int n;
for (n = 0; data->filters[n].pszName != NULL; n++)
{}
hr = IFileDialog_SetFileTypes (pfd, n, data->filters);
if (FAILED (hr))
g_warning_hr ("Can't set file types", hr);
if (data->self->current_filter)
{
GSList *filters = gtk_file_chooser_list_filters (GTK_FILE_CHOOSER (data->self));
gint current_filter_index = g_slist_index (filters, data->self->current_filter);
g_slist_free (filters);
if (current_filter_index >= 0)
hr = IFileDialog_SetFileTypeIndex (pfd, current_filter_index + 1);
else
hr = IFileDialog_SetFileTypeIndex (pfd, 1);
}
else
{
hr = IFileDialog_SetFileTypeIndex (pfd, 1);
}
if (FAILED (hr))
g_warning_hr ("Can't set current file type", hr);
}
data->response = GTK_RESPONSE_CANCEL;
hr = IFileDialog_Advise (pfd, data->events, &cookie);
if (FAILED (hr))
g_error ("Can't Advise FileDialog: %s", g_win32_error_message (hr));
hr = IFileDialog_Show (pfd, data->parent);
if (SUCCEEDED (hr))
{
IFileOpenDialog *pfod = NULL;
hr = IFileDialog_QueryInterface (pfd,&IID_IFileOpenDialog, (LPVOID *) &pfod);
if (SUCCEEDED (hr))
{
IShellItemArray *res;
DWORD i, count;
hr = IFileOpenDialog_GetResults (pfod, &res);
if (FAILED (hr))
g_error ("Can't get FileOpenDialog results: %s", g_win32_error_message (hr));
hr = IShellItemArray_GetCount (res, &count);
if (FAILED (hr))
g_error ("Can't get FileOpenDialog count: %s", g_win32_error_message (hr));
for (i = 0; i < count; i++)
{
IShellItem *item;
hr = IShellItemArray_GetItemAt (res, i, &item);
if (FAILED (hr))
g_error ("Can't get item at %lu: %s", i, g_win32_error_message (hr));
data_add_shell_item (data, item);
IShellItem_Release (item);
}
IShellItemArray_Release (res);
IFileOpenDialog_Release (pfod);
}
else
{
IShellItem *item;
hr = IFileDialog_GetResult (pfd, &item);
if (FAILED (hr))
g_error ("Can't get FileDialog result: %s", g_win32_error_message (hr));
data_add_shell_item (data, item);
IShellItem_Release (item);
}
}
hr = IFileDialog_Unadvise (pfd, cookie);
if (FAILED (hr))
g_error ("Can't Unadvise FileDialog: %s", g_win32_error_message (hr));
IFileDialog_Release ((IUnknown *)pfd);
g_main_context_invoke (NULL,
filechooser_win32_thread_done,
data);
return NULL;
}
void create_filters(GtkWidget* chooser)
{
typedef struct snd_fmt_names
{
int sf_fmt;
char* ext;
char* name;
} snd_fmt;
snd_fmt alt_exts[] = {
/* libsndfile only provides a single 'most common' extension for
* each format it is capable of reading. Here are some additional
* extensions for selected formats:
* (followed by sndfile provided extension in comments)
*/
{ SF_FORMAT_AIFF, "aif", 0}, /* aiff */
{ SF_FORMAT_CAF, "caff", 0}, /* caf */
{ SF_FORMAT_OGG, "ogg", 0}, /* oga */
{ SF_FORMAT_SD2, "sd2f", 0}, /* sd2 */
{ SF_FORMAT_NIST, "sph", 0}, /* wav */
{ 0, 0, 0 }};
/* stuff for accessing soundfile format information */
snd_fmt sound_formats[99];
SF_FORMAT_INFO sf_fmt;
int sf_fmt_count;
int n;
/* stuff for improving format information */
snd_fmt* fmt;
snd_fmt* n_fmt;
snd_fmt* alt;
char pat[10];
GtkFileFilter* filter = 0;
GSList* f_list;
GSList* f_item;
global_settings* settings = settings_get();
/* generate format information */
sf_command(0, SFC_GET_FORMAT_MAJOR_COUNT, &sf_fmt_count, sizeof(int));
for (fmt = sound_formats, n = 0; n < sf_fmt_count; ++n, ++fmt)
{
sf_fmt.format = n;
sf_command(0, SFC_GET_FORMAT_MAJOR, &sf_fmt, sizeof(sf_fmt));
snprintf(pat, 10, "*.%s", sf_fmt.extension);
pat[9] = '\0';
fmt->sf_fmt = sf_fmt.format;
fmt->name = strdup(sf_fmt.name);
fmt->ext = strdup(pat);
for (n_fmt = fmt, alt = alt_exts; alt->sf_fmt != 0; ++alt)
{
if (alt->sf_fmt == n_fmt->sf_fmt)
{
snprintf(pat, 10, "*.%s", alt->ext);
pat[9] = '\0';
++fmt;
fmt->sf_fmt = sf_fmt.format;
fmt->name = strdup(n_fmt->name);
fmt->ext = strdup(pat);
}
}
}
fmt->name = 0;
fmt->ext = 0;
/* Audio files filter (specifically: files loadable by sndfile) */
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, "All Audio files");
for (fmt = sound_formats; fmt->name != 0 && fmt->ext != 0; ++fmt)
{
#if DEBUG
printf("format ext:%s \tname:%s\n", fmt->ext, fmt->name);
#endif
gtk_file_filter_add_pattern(filter, fmt->ext);
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser), filter);
/* Individual filters for formats loadable by sndfile
* NOTE: most formats have one file extension, but some have to be
* arkward and have alternative extensions...
*/
for (fmt = sound_formats; fmt->name != 0 && fmt->ext != 0; fmt = n_fmt)
{
n_fmt = fmt;
filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, fmt->name);
while (strcmp(fmt->name, n_fmt->name) == 0)
{
gtk_file_filter_add_pattern(filter, n_fmt->ext);
++n_fmt;
if (n_fmt->name == 0)
break;
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser), filter);
}
/* All files 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(chooser), filter);
for (fmt = sound_formats; fmt->name != 0 && fmt->ext != 0; ++fmt)
{
free(fmt->name);
free(fmt->ext);
}
f_list = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(chooser));
f_item = f_list;
while(f_item)
{
filter = GTK_FILE_FILTER(f_item->data);
if (strcmp(gtk_file_filter_get_name(filter),
settings->sample_file_filter) == 0)
{
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(chooser), filter);
break;
}
f_item = f_item->next;
}
g_slist_free(f_list);
}
/*!
\brief pops up a Filechooser dialog to select a file
\param data is a pointer to a MtxFileIO structure which contains important
bits like the path to start, the filter, default filename and so on
\see MtxFileIO
\returns the path to the file or NULL if cancelled
*/
gchar * choose_file(MtxFileIO *data)
{
GtkWidget *dialog = NULL;
GtkFileFilter *filter = NULL;
GSList *filters = NULL;
gchar *path = NULL;
gchar *defdir = NULL;
gchar *filename = NULL;
gchar *tmpbuf = NULL;
gchar **vector = NULL;
const gchar *project = NULL;
gint response = 0;
gboolean res = FALSE;
guint i = 0;
ENTER();
if (!GTK_IS_WINDOW(data->parent))
data->parent = NULL;
/*
printf("choose_file\n");
printf("parent %p\n",(void *)data->parent);
printf("on_top %s\n",data->on_top? "TRUE":"FALSE");
printf("filter %s\n",data->filter);
printf("filename %s\n",data->filename);
printf("default_filename %s\n",data->default_filename);
printf("default_extension %s\n",data->default_extension);
printf("absolute_path %s\n",data->absolute_path);
printf("default_path %s\n",data->default_path);
printf("external_path %s\n",data->external_path);
printf("shortcut_folders %s\n",data->shortcut_folders);
printf("project %s\n",data->project);
printf("title %s\n",data->title);
*/
if (data->project)
project = data->project;
else
project = DEFAULT_PROJECT;
if (!data->title)
data->title = g_strdup("Open File");
if ((data->action == GTK_FILE_CHOOSER_ACTION_OPEN) ||
(data->action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER))
{
/*printf("ACTION_OPEN before gtk_file_chooser_dialog_new\n");*/
dialog = gtk_file_chooser_dialog_new(data->title,
/*GTK_WINDOW(data->parent), */
0,
data->action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
/*printf("after gtk_file_chooser_dialog_new\n");*/
if ((data->on_top) && (GTK_IS_WIDGET(data->parent)))
gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent));
if ((data->absolute_path) && (!data->default_path))
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),data->absolute_path);
else if (data->default_path)
{
/*printf("should be using system path + %s\n",data->default_path);*/
path = g_build_filename(MTXSYSDATA,data->default_path,NULL);
if (!g_file_test(path,G_FILE_TEST_IS_DIR))
{
g_free(path);
path = g_build_filename(HOME(),"mtx",data->project,data->default_path, NULL);
/*printf("System path is not found, falling back to user path %s\n",path);*/
}
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path);
g_free(path);
}
}
else if (data->action == GTK_FILE_CHOOSER_ACTION_SAVE)
{
/*printf("ACTION_SAVE calling gtk_file_chooser_dialog_new\n");*/
dialog = gtk_file_chooser_dialog_new(data->title,
/*GTK_WINDOW(data->parent), */
0,
data->action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
/*printf("after gtk_file_chooser_dialog_new\n");*/
/* if ((data->on_top) && (GTK_IS_WIDGET(data->parent)))
gtk_window_set_transient_for(GTK_WINDOW(gtk_widget_get_toplevel(dialog)),GTK_WINDOW(data->parent));
*/
if (data->default_path)
{
defdir = g_build_filename(HOME(),"mtx",data->project,data->default_path, NULL);
if (!g_file_test(defdir,G_FILE_TEST_IS_DIR))
g_mkdir(defdir,0755);
}
else
defdir = g_build_filename(HOME(),"mtx",data->project, NULL);
/* If filename passed check/adj path */
if (data->filename)
{
if (g_strrstr(data->filename,DATA_DIR) != NULL)
{
vector = g_strsplit(data->filename,PSEP,-1);
tmpbuf = g_strconcat(defdir,PSEP,vector[g_strv_length(vector)-1],NULL);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),vector[g_strv_length(vector)-1]);
g_strfreev(vector);
g_free(tmpbuf);
}
else
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),data->filename);
}
else
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),defdir);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), data->default_filename );
}
g_free(defdir);
}
else
{
EXIT();
return NULL;
}
/* Add shortcut folders... */
if (data->shortcut_folders)
{
vector = g_strsplit(data->shortcut_folders,",",-1);
for (i=0;i<g_strv_length(vector);i++)
{
path = g_build_filename(MTXSYSDATA,vector[i],NULL);
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL);
g_free(path);
path = g_build_filename(HOME(),"mtx",data->project,vector[i],NULL);
gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog),path,NULL);
g_free(path);
}
g_strfreev(vector);
}
/* If default path switch to that place */
if ((data->external_path) && (!(data->default_path)))
{
/*printf("external path with no default path\n");*/
path = g_build_filename(HOME(),"mtx",data->project,data->external_path,NULL);
if (!g_file_test(path,G_FILE_TEST_IS_DIR))
g_mkdir(path,0755);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog),path);
g_free(path);
}
/* If filters, assign them
CAUSES SEGFAULTS???
*/
/*
if (data->filter)
{
printf("data->filter is set to \"%s\"\n",data->filter);
vector = g_strsplit(data->filter,",",-1);
if (g_strv_length(vector)%2 > 0)
goto afterfilter;
for (i=0;i<g_strv_length(vector);i+=2)
{
filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter),vector[i]);
printf("Filter glob is set to \"%s\"\n",vector[i]);
gtk_file_filter_set_name(GTK_FILE_FILTER(filter),vector[i+1]);
printf("Filter name is set to \"%s\"\n",vector[i+1]);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog),filter);
}
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog),filter);
g_strfreev(vector);
}
*/
afterfilter:
/* Turn on overwriteconfirmation */
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
g_signal_connect(G_OBJECT(dialog),"confirm-overwrite",
G_CALLBACK (confirm_overwrite_callback), NULL);
if (data->action == GTK_FILE_CHOOSER_ACTION_OPEN)
{
if (data->default_filename)
{
/*printf("data->default_filename is set to \"%s\"\n",data->default_filename);*/
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog),data->default_filename);
}
}
/*printf("initiating dialog to run\n");*/
response = gtk_dialog_run (GTK_DIALOG (dialog));
/*printf("it returned \n");*/
if (response == GTK_RESPONSE_ACCEPT)
{
tmpbuf = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
if ((data->action == GTK_FILE_CHOOSER_ACTION_SAVE) && (data->default_extension))
{
if(!g_str_has_suffix (tmpbuf,data->default_extension))
filename = g_strjoin(".",tmpbuf,data->default_extension,NULL);
else
filename = g_strdup(tmpbuf);
}
else
filename = g_strdup(tmpbuf);
g_free(tmpbuf);
}
filters = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(dialog));
if (filters)
{
g_slist_foreach(filters, remove_filter ,dialog);
g_slist_free(filters);
}
gtk_widget_destroy (dialog);
EXIT();
return (filename);
}
