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; 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 ); } } }
static std::string add_simple_mime_filter_to_gtkchooser(GtkWindow *picker, std::string mime, std::string filtername) { GtkFileFilter *gfilter = gtk_file_filter_new(); gtk_file_filter_add_mime_type(gfilter, mime.c_str()); add_common_filters_to_gtkchooser(gfilter, picker, filtername); return filtername; }
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 std::string add_anim_filter_to_gtkchooser(GtkWindow *picker) { GtkFileFilter *gfilter = gtk_file_filter_new(); gtk_file_filter_add_pattern(gfilter, "*.bvh"); gtk_file_filter_add_pattern(gfilter, "*.anim"); std::string filtername = LLTrans::getString("animation_files") + " (*.bvh; *.anim)"; add_common_filters_to_gtkchooser(gfilter, picker, filtername); return filtername; }
void seahorse_util_chooser_show_key_files (GtkWidget *dialog) { GtkFileFilter* filter = gtk_file_filter_new (); /* Filter for PGP keys. We also include *.asc, as in many cases that extension is associated with text/plain */ gtk_file_filter_set_name (filter, _("All key files")); gtk_file_filter_add_mime_type (filter, "application/pgp-keys"); gtk_file_filter_add_pattern (filter, "*.asc"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (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 (dialog), filter); }
static std::string add_simple_pattern_filter_to_gtkchooser(GtkWindow *picker, std::string pattern, std::string filtername) { GtkFileFilter *gfilter = gtk_file_filter_new(); gtk_file_filter_add_pattern(gfilter, pattern.c_str()); add_common_filters_to_gtkchooser(gfilter, picker, filtername); return filtername; }
void activate_action_open (GtkAction *action, gpointer data) { GtkWidget *file_sel; FrWindow *window = data; GtkFileFilter *filter; int i; file_sel = gtk_file_chooser_dialog_new (_("Open"), GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE); gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (file_sel), fr_window_get_open_default_dir (window), NULL); _gtk_dialog_add_to_window_group (GTK_DIALOG (file_sel)); gtk_window_set_modal (GTK_WINDOW (file_sel), TRUE); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All archives")); for (i = 0; open_type[i] != -1; i++) gtk_file_filter_add_mime_type (filter, mime_type_desc[open_type[i]].mime_type); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_sel), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (file_sel), 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_sel), filter); /**/ g_object_set_data (G_OBJECT (file_sel), "fr_window", window); g_signal_connect (G_OBJECT (file_sel), "response", G_CALLBACK (open_file_response_cb), file_sel); gtk_widget_show (file_sel); }
/* EDITOR: COLORMAP VIEWER * ======================= * Colormaps differ from lump files in the way that they don't start with a width | height header * Otherwise they are identical in how they refer to palette indexes for their color */ gint VID_EditorViewColormap(gpointer data) { int i; GtkWidget *dialog; GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN; gint res; loadedfile_t *pic; dialog = gtk_file_chooser_dialog_new ("NGUNIXEd - Open Colormap (.lmp) File", NULL, action, ("_Cancel"), GTK_RESPONSE_CANCEL, ("_Open"), GTK_RESPONSE_ACCEPT, NULL); // Set the dialog and the default path (current directory) GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog); char path[MAX_OSPATH]; sprintf(path, "file://%s", get_current_dir_name()); gtk_file_chooser_set_current_folder_uri(chooser, path); // Add the filter for .lmp files GtkFileFilter *filter = gtk_file_filter_new (); gtk_file_filter_add_pattern (filter, "*.lmp"); gtk_file_chooser_set_filter (chooser, filter); res = gtk_dialog_run (GTK_DIALOG (dialog)); if (res == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (chooser); pic = COM_LoadFile (filename, 2); if(pic) { Con_Printf("[EDITOR] Previewing Colormap %s\n", filename); ed_file = malloc(16385 + (sizeof(int) * 2)); ed_file->width = 256; ed_file->height = 64; for(i = 0; i < 256 * 64; i++) ed_file->data[i] = pic->data[i]; gtk_window_resize(ed_window, ed_file->width + ed_palfile->width, ed_file->height + ed_menubar->allocation.height); } g_free (filename); } gtk_widget_destroy (dialog); return 0; }
// <FS:CR> GTK Import/Export filters static std::string add_import_filter_to_gtkchooser(GtkWindow *picker) { GtkFileFilter *gfilter = gtk_file_filter_new(); gtk_file_filter_add_pattern(gfilter, "*.oxp"); std::string filtername = LLTrans::getString("backup_files") + " (*.oxp)"; //gtk_file_filter_add_pattern(gfilter, "*.hpa"); //std::string filtername = LLTrans::getString("backup_files") + " (*.oxp; *.hpa)"; add_common_filters_to_gtkchooser(gfilter, picker, filtername); return filtername; }
GtkFileFilter * tls_file_chooser_filter_new (void) { GtkFileFilter *filter; filter = gtk_file_filter_new (); gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_FILENAME, tls_default_filter, NULL, NULL); gtk_file_filter_set_name (filter, _("PEM certificates (*.pem, *.crt, *.key)")); return filter; }
static std::string add_wav_filter_to_gtkchooser(GtkWindow *picker) { GtkFileFilter *gfilter = gtk_file_filter_new(); gtk_file_filter_add_pattern(gfilter, "*.wav"); gtk_file_filter_add_mime_type(gfilter,"audio/x-wav");//not working std::string filtername = LLTrans::getString("sound_files") + " (*.wav)"; add_common_filters_to_gtkchooser(gfilter, picker, filtername); return filtername; }
static GtkFileFilter * set_file_filter (GtkFileChooser *dlg, const char *name) { if (!name) { name = _("Supported sound formats"); } GtkFileFilter* flt; flt = gtk_file_filter_new (); gtk_file_filter_set_name (flt, name); gtk_file_filter_add_custom (flt, GTK_FILE_FILTER_FILENAME, file_filter_func, NULL, NULL); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dlg), flt); flt = gtk_file_filter_new (); gtk_file_filter_set_name (flt, _("All files (*)")); gtk_file_filter_add_pattern (flt, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt); return flt; }
/* See VikDataSourceInterface */ static void datasource_geotag_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data ) { datasource_geotag_user_data_t *userdata = (datasource_geotag_user_data_t *)user_data; /* The files selector */ userdata->files = gtk_file_chooser_widget_new ( GTK_FILE_CHOOSER_ACTION_OPEN ); // try to make it a nice size - otherwise seems to default to something impractically small gtk_window_set_default_size ( GTK_WINDOW (dialog) , 600, 300 ); if ( last_folder_uri ) gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(userdata->files), last_folder_uri ); GtkFileChooser *chooser = GTK_FILE_CHOOSER ( userdata->files ); /* Add filters */ GtkFileFilter *filter; filter = gtk_file_filter_new (); gtk_file_filter_set_name ( filter, _("All") ); gtk_file_filter_add_pattern ( filter, "*" ); gtk_file_chooser_add_filter ( chooser, filter ); filter = gtk_file_filter_new (); gtk_file_filter_set_name ( filter, _("JPG") ); gtk_file_filter_add_mime_type ( filter, "image/jpeg"); gtk_file_chooser_add_filter ( chooser, filter ); // Default to jpgs gtk_file_chooser_set_filter ( chooser, filter ); // Allow selecting more than one gtk_file_chooser_set_select_multiple ( chooser, TRUE ); // Could add code to setup a default symbol (see dialog.c for symbol usage) // Store in user_data type and then apply when creating the waypoints // However not much point since these will have images associated with them! /* Packing all widgets */ GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))); gtk_box_pack_start ( box, userdata->files, TRUE, TRUE, 0 ); gtk_widget_show_all ( dialog ); }
/* * diagram_get_file_filter: * * Return value: a new #GtkFileFilter object for diagrams. */ static GtkFileFilter * diagram_get_file_filter (void) { GtkFileFilter *filter; filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Logdiag Diagrams (*.ldd)")); gtk_file_filter_add_pattern (filter, "*.ldd"); return filter; }
void assign_etf_fc_filters(GtkFileChooser *fc) { GtkFileFilter *filter_1, *filter_2; /* all files filter */ filter_1 = gtk_file_filter_new(); gtk_file_filter_add_pattern(filter_1, "*"); gtk_file_filter_set_name(GTK_FILE_FILTER(filter_1), _("All Files")); gtk_file_chooser_add_filter(fc, filter_1); /* music store files filter */ filter_2 = gtk_file_filter_new(); gtk_file_filter_add_pattern(filter_2, "*.[lL][uU][aA]"); gtk_file_filter_set_name(GTK_FILE_FILTER(filter_2), _("Lua Extension Files (*.lua)")); gtk_file_chooser_add_filter(fc, filter_2); gtk_file_chooser_set_filter(fc, filter_2); }
void assign_store_fc_filters(GtkFileChooser *fc) { GtkFileFilter *filter_1, *filter_2; /* all files filter */ filter_1 = gtk_file_filter_new(); gtk_file_filter_add_pattern(filter_1, "*"); gtk_file_filter_set_name(GTK_FILE_FILTER(filter_1), _("All Files")); gtk_file_chooser_add_filter(fc, filter_1); /* music store files filter */ filter_2 = gtk_file_filter_new(); gtk_file_filter_add_pattern(filter_2, "*.[xX][mM][lL]"); gtk_file_filter_set_name(GTK_FILE_FILTER(filter_2), _("Music Store Files (*.xml)")); gtk_file_chooser_add_filter(fc, filter_2); gtk_file_chooser_set_filter(fc, filter_2); }
// GTK >= 2.4 static const gchar* create_fsel_2(const gchar *dirname, const gchar *filename, const gchar *ext, gboolean save) { GtkWidget *dialog; GtkFileFilter *filter; gchar *path, *tmp; gchar **sarray; gint i; gchar *sfilename, *sext; // gtk_file_chooser_set_current_name and gtk_file_filter_add_pattern ALWAYS want UTF-8. sfilename = filename ? g_filename_to_utf8(filename,-1,NULL,NULL,NULL) : NULL; sext = ext ? g_filename_to_utf8(ext,-1,NULL,NULL,NULL) : NULL; // create box dialog = gtk_file_chooser_dialog_new ( save ? "Save File" : "Open File", NULL, save ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); // set default folder tmp = g_strconcat(dirname, G_DIR_SEPARATOR_S, NULL); // add leading '/' otherwise get_dirname is confused path = g_path_get_dirname(tmp); g_free(tmp); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path); g_free(path); // set default name if(filename) gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), sfilename); // set wildcards filter = gtk_file_filter_new(); sarray = g_strsplit(sext, ";", -1); for(i = 0; sarray[i] != NULL; i++) gtk_file_filter_add_pattern (filter, sarray[i]); g_strfreev(sarray); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); // get result g_free(fname); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); else fname = NULL; gtk_widget_destroy (dialog); g_free(sfilename); g_free(sext); return fname; }
void run_open_dialog() { GtkWidget *file_chooser = gtk_file_chooser_dialog_new("Open Map", GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (file_chooser), GTK_RESPONSE_ACCEPT); GtkFileFilter *filter; /* Filters */ filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, "All Emergence Maps"); gtk_file_filter_add_pattern (filter, "*.map"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_chooser), filter); /* Make this filter the default */ gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (file_chooser), 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_chooser), filter); if (gtk_dialog_run (GTK_DIALOG (file_chooser)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (file_chooser)); open_dialog_ok (filename); g_free (filename); } gtk_widget_destroy (file_chooser); }
void ui_open_file_cb(GtkWidget* widget, gpointer data) { GtkWidget* ui_filedialog; GtkFileFilter* ui_filefilter; ui_filedialog = gtk_file_chooser_dialog_new("Open...", GTK_WINDOW(ui_window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); GList *formats = io_get_handler_descriptions(IO_LOAD_HANDLER); GList *iter; for(iter = g_list_first(formats); iter; iter = g_list_next(iter)) { io_handler_desc_t *format = (io_handler_desc_t *) iter->data; ui_filefilter = gtk_file_filter_new(); gtk_file_filter_set_name(GTK_FILE_FILTER(ui_filefilter), format->desc); GList *f_it; for(f_it = g_list_first(format->filters); f_it; f_it = g_list_next(f_it)) { gtk_file_filter_add_pattern( GTK_FILE_FILTER(ui_filefilter), (char *) f_it->data); } gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(ui_filedialog), ui_filefilter); } g_list_free_full(formats, free); if( gtk_dialog_run(GTK_DIALOG(ui_filedialog)) == GTK_RESPONSE_ACCEPT) { gchar* filename; filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(ui_filedialog)); if( io_load_image(filename) != CLIPT_OK) { GtkWidget *err_dialog; err_dialog = gtk_message_dialog_new(ui_filedialog, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Cannot open file specified"); gtk_dialog_run(err_dialog); gtk_widget_destroy(err_dialog); } g_free(filename); } g_signal_emit(ui_window, ui_new_image_signal, 0); gtk_widget_destroy(ui_filedialog); }
int main(int argc, char **argv) { GtkBuilder* builder; GError* error = NULL; /* Starts Gtk+ subsystem */ gtk_init(&argc, &argv); /* Load GUI interface */ builder = gtk_builder_new(); if(!gtk_builder_add_from_file(builder, "gui/probwin.glade", &error)) { if(error) { g_warning("%s", error->message); g_error_free(error); } else { g_warning("Unknown error."); } return(1); } /* Get pointers to objects */ window = GTK_WINDOW(gtk_builder_get_object(builder, "window")); format_view = GTK_TREE_VIEW(gtk_builder_get_object(builder, "format_view")); format_model = GTK_LIST_STORE(gtk_builder_get_object(builder, "format_model")); team_a_name = GTK_ENTRY(gtk_builder_get_object(builder, "team_a_name")); team_b_name = GTK_ENTRY(gtk_builder_get_object(builder, "team_b_name")); prob_a_home = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "prob_a_home")); prob_a_road = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "prob_a_road")); num_games = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "num_games")); prob_b_home = GTK_LABEL(gtk_builder_get_object(builder, "prob_b_home")); prob_b_road = GTK_LABEL(gtk_builder_get_object(builder, "prob_b_road")); load_dialog = GTK_FILE_CHOOSER(gtk_builder_get_object(builder, "load_dialog")); save_dialog = GTK_FILE_CHOOSER(gtk_builder_get_object(builder, "save_dialog")); GtkFileFilter* file_filter = gtk_file_filter_new(); gtk_file_filter_set_name(file_filter, "Custom data file (*.probwin)"); gtk_file_filter_add_pattern(file_filter, "*.probwin"); gtk_file_chooser_add_filter(load_dialog, file_filter); gtk_file_chooser_add_filter(save_dialog, file_filter); /* Connect signals */ gtk_builder_connect_signals(builder, NULL); g_object_unref(G_OBJECT(builder)); gtk_widget_show(GTK_WIDGET(window)); gtk_main(); return(0); }
static void pixbufEditor_init(PixbufEditor *e) { GtkFileFilter *filter; filter = gtk_file_filter_new(); gtk_file_filter_add_pixbuf_formats(filter); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(e), filter); g_signal_connect(e, "file-set", G_CALLBACK(pixbufEditor_file_set), e); if (e->pixbuf == NULL) e->pixbuf = PIXBUF_EDITOR_GET_CLASS(e)->missing; }
static gchar * gnc_plugin_bi_import_getFilename(void) { // prepare file import dialog gchar *filename; GList *filters; GtkFileFilter *filter; filters = NULL; filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, "comma separated values (*.csv)"); gtk_file_filter_add_pattern (filter, "*.csv"); filters = g_list_append( filters, filter ); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, "text files (*.txt)"); gtk_file_filter_add_pattern (filter, "*.txt"); filters = g_list_append( filters, filter ); filename = gnc_file_dialog(_("Import Bills or Invoices from csv"), filters, NULL, GNC_FILE_DIALOG_IMPORT); return filename; }
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; }
static std::string add_imageload_filter_to_gtkchooser(GtkWindow *picker) { GtkFileFilter *gfilter = gtk_file_filter_new(); gtk_file_filter_add_pattern(gfilter, "*.tga"); gtk_file_filter_add_mime_type(gfilter, "image/jpeg"); gtk_file_filter_add_mime_type(gfilter, "image/png"); gtk_file_filter_add_mime_type(gfilter, "image/bmp"); std::string filtername = "Images (*.tga; *.bmp; *.jpg; *.png)"; add_common_filters_to_gtkchooser(gfilter, picker, filtername); return filtername; }
static void on_browse_button_clicked(GtkWidget * widget, gpointer data) { GtkWidget *file_chooser; GtkFileFilter *filter; /* Create the selector */ file_chooser = gtk_file_chooser_dialog_new("Choose exported CRL filename", GTK_WINDOW(data), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); filter = gtk_file_filter_new(); gtk_file_filter_add_pattern(filter, "*.crl"); gtk_file_filter_set_name(filter, "*.crl files"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser), filter); filter = NULL; 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(file_chooser), filter); filter = NULL; /* Display that dialog */ { gint result = gtk_dialog_run(GTK_DIALOG(file_chooser)); if (result == GTK_RESPONSE_ACCEPT) { gchar *filename; filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser)); gtk_entry_set_text(GTK_ENTRY (g_object_get_data(G_OBJECT(widget), "entry")), filename); gtk_widget_destroy(file_chooser); g_free(filename); } else { gtk_widget_destroy(file_chooser); } } }
/* File->Import Into Skein... */ void action_import_into_skein(GtkAction *action, I7Story *story) { GError *err = NULL; /* Ask the user for a file to import */ /* TRANSLATORS: File->Import Into Skein... */ GtkWidget *dialog = gtk_file_chooser_dialog_new( _("Select the file to import into the skein"), GTK_WINDOW(story), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); /* Create appropriate file filters */ GtkFileFilter *filter1 = gtk_file_filter_new(); gtk_file_filter_set_name(filter1, _("Interpreter recording files (*.rec)")); gtk_file_filter_add_pattern(filter1, "*.rec"); GtkFileFilter *filter2 = gtk_file_filter_new(); gtk_file_filter_set_name(filter2, _("All Files")); gtk_file_filter_add_pattern(filter2, "*"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter1); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter2); if(gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) { gtk_widget_destroy(dialog); return; } GFile *file = gtk_file_chooser_get_file(GTK_FILE_CHOOSER(dialog)); gtk_widget_destroy(dialog); if(!file) return; /* Fail silently */ /* Provide some visual feedback that the command did something */ if(!i7_skein_import(i7_story_get_skein(story), file, &err)) error_dialog_file_operation(GTK_WINDOW(story), file, err, I7_FILE_ERROR_OPEN, NULL); else i7_story_show_pane(story, I7_PANE_SKEIN); g_object_unref(file); }
void file_chooser_add_filters(GtkWidget * chooser, FileTypes * filters) { GtkFileFilter *filter; gint i; for (i = 0; filters[i].name; i++) { filter = gtk_file_filter_new(); gtk_file_filter_add_mime_type(filter, filters[i].mime_type); gtk_file_filter_set_name(filter, filters[i].name); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(chooser), filter); } }
static void add_filters (GtkFileChooser *dialog) { GtkFileFilter *filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Bridge files")); gtk_file_filter_add_pattern (filter, "*.lin"); gtk_file_filter_add_pattern (filter, "*.pbn"); gtk_file_chooser_add_filter (dialog, filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("LIN files")); gtk_file_filter_add_pattern (filter, "*.lin"); gtk_file_chooser_add_filter (dialog, filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("PBN files")); gtk_file_filter_add_pattern (filter, "*.pbn"); gtk_file_chooser_add_filter (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 (dialog, filter); }
//static void on_browse(GtkWidget * widget, gpointer data) void ladish_run_load_project_dialog(ladish_room_proxy_handle room) { GtkFileFilter * filter; GtkWidget * dialog; char * filename; dialog = gtk_file_chooser_dialog_new( _("Load project"), NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_create_folders(GTK_FILE_CHOOSER(dialog), FALSE); filter = gtk_file_filter_new(); gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_FILENAME, reject_filter, dialog, NULL); /* reject all files */ gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); //g_signal_connect(G_OBJECT(dialog), "selection-changed", G_CALLBACK(on_dir_select), dialog); g_signal_connect(G_OBJECT(dialog), "current-folder-changed", G_CALLBACK(dir_changed), dialog); loop: if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); if (!is_project_dir(filename)) { GtkWidget * dialog; dialog = get_gtk_builder_widget("error_dialog"); gtk_message_dialog_set_markup(GTK_MESSAGE_DIALOG(dialog), _("<b><big>Not a project dir</big></b>")); gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(dialog), "%s", filename); gtk_widget_show(dialog); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_hide(dialog); goto loop; } //gtk_entry_set_text(GTK_ENTRY(get_gtk_builder_widget("load_project_path_entry")), filename); log_info("Loading project from '%s'", filename); if (!ladish_room_proxy_load_project(room, filename)) { log_error("ladish_room_proxy_load_project() failed."); } g_free(filename); //gtk_widget_activate(gtk_dialog_get_widget_for_response(GTK_DIALOG(data), GTK_RESPONSE_OK)); } gtk_widget_destroy(dialog); return; }
void on_filechooserbutton_input2_realize (GtkWidget *widget, gpointer user_data) { GtkFileFilter *filter = NULL; filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, "*.dbf"); gtk_file_filter_add_pattern(filter, "*.dbf"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(widget), filter); }