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