void rejilla_mime_filter_add_mime (RejillaMimeFilter *filter, const gchar *mime) { GtkFileFilter *item; item = g_hash_table_lookup (filter->priv->table, mime); if (!item) { GIcon *icon; GtkTreeIter row; gchar *description; GtkTreeModel *model; description = g_content_type_get_description (mime); icon = g_content_type_get_icon (mime); /* create the GtkFileFilter */ item = gtk_file_filter_new (); gtk_file_filter_set_name (item, mime); gtk_file_filter_add_mime_type (item, mime); g_hash_table_insert (filter->priv->table, g_strdup (mime), item); g_object_add_toggle_ref (G_OBJECT (item), (GToggleNotify) rejilla_mime_filter_destroy_item_cb, filter); model = gtk_combo_box_get_model (GTK_COMBO_BOX (filter->combo)); gtk_list_store_append (GTK_LIST_STORE (model), &row); g_object_ref_sink (item); gtk_list_store_set (GTK_LIST_STORE (model), &row, REJILLA_MIME_FILTER_DISPLAY_COL, description, REJILLA_MIME_FILTER_ICON_COL, icon, REJILLA_MIME_FILTER_FILTER_COL, item, -1); g_object_unref (icon); g_free (description); /* we check that the first entry at least is visible */ if (gtk_combo_box_get_active (GTK_COMBO_BOX (filter->combo)) == -1 && gtk_tree_model_get_iter_first (model, &row) == TRUE) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (filter->combo), &row); } else g_object_ref (item); }
static void setup_background_filechooser (GtkWidget *filechooser, TerminalProfile *profile) { GtkFileFilter *filter; const char *home_dir; filter = gtk_file_filter_new (); gtk_file_filter_add_pixbuf_formats (filter); gtk_file_filter_set_name (filter, _("Images")); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (filechooser), filter); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filechooser), TRUE); /* Start filechooser in $HOME instead of the current dir of the factory which is "/" */ home_dir = g_get_home_dir (); if (home_dir) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filechooser), home_dir); #if 0 GtkWidget *image_preview; GdkPixbuf *pixbuf = NULL; image_preview = gtk_image_new (); /* FIXMchpe this is bogus */ pixbuf = create_preview_pixbuf (terminal_profile_get_property_string (profile, TERMINAL_PROFILE_BACKGROUND_IMAGE_FILE)); if (pixbuf != NULL) { gtk_image_set_from_pixbuf (GTK_IMAGE (image_preview), pixbuf); g_object_unref (pixbuf); } else { gtk_image_set_from_stock (GTK_IMAGE (image_preview), "gtk-dialog-question", GTK_ICON_SIZE_DIALOG); } gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (filechooser), image_preview); gtk_file_chooser_set_use_preview_label (GTK_FILE_CHOOSER (filechooser), FALSE); gtk_widget_set_size_request (image_preview, 128, -1); gtk_widget_show (image_preview); g_signal_connect (filechooser, "update-preview", G_CALLBACK (update_image_preview), NULL); #endif }
void gtkui_file_open() { // Open a file using a GTK+ dialog GtkWidget *dialog = gtk_file_chooser_dialog_new( "Select a ROM", GTK_WINDOW(gtkwindow), GTK_FILE_CHOOSER_ACTION_OPEN, "Cancel", GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL); if(conf.misc_last_folder != NULL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), conf.misc_last_folder); GtkFileFilter *filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, "NES ROMs and Archives"); gtk_file_filter_add_pattern(filter, "*.nes"); gtk_file_filter_add_pattern(filter, "*.fds"); gtk_file_filter_add_pattern(filter, "*.unf"); gtk_file_filter_add_pattern(filter, "*.unif"); gtk_file_filter_add_pattern(filter, "*.nsf"); gtk_file_filter_add_pattern(filter, "*.zip"); gtk_file_filter_add_pattern(filter, "*.7z"); gtk_file_filter_add_pattern(filter, "*.txz"); gtk_file_filter_add_pattern(filter, "*.tar.xz"); gtk_file_filter_add_pattern(filter, "*.xz"); gtk_file_filter_add_pattern(filter, "*.tgz"); gtk_file_filter_add_pattern(filter, "*.tar.gz"); gtk_file_filter_add_pattern(filter, "*.gz"); gtk_file_filter_add_pattern(filter, "*.tbz"); gtk_file_filter_add_pattern(filter, "*.tar.bz2"); gtk_file_filter_add_pattern(filter, "*.bz2"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); if(conf.misc_last_folder != NULL) free(conf.misc_last_folder); conf.misc_last_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog)); gtk_widget_destroy(dialog); nst_load(filename); g_free(filename); } else { gtk_widget_destroy(dialog); } }
static void set_file_filter_saveplaylist (GtkFileChooser *dlg) { GtkFileFilter* flt; flt = gtk_file_filter_new (); gtk_file_filter_set_name (flt, _("DeaDBeeF playlist files (*.dbpl)")); gtk_file_filter_add_pattern (flt, "*.dbpl"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt); DB_playlist_t **plug = deadbeef->plug_get_playlist_list (); for (int i = 0; plug[i]; i++) { if (plug[i]->extensions && plug[i]->load) { const char **exts = plug[i]->extensions; if (exts && plug[i]->save) { for (int e = 0; exts[e]; e++) { char s[100]; flt = gtk_file_filter_new (); gtk_file_filter_set_name (flt, exts[e]); snprintf (s, sizeof (s), "*.%s", exts[e]); gtk_file_filter_add_pattern (flt, s); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt); } } } } }
static GtkFileFilter * set_file_filter (GtkFileChooser *dlg, const char *name) { if (!name) { name = _("Supported sound formats"); } static char extlist[10000]; // Build extension list if (extlist[0] == '\0') { DB_decoder_t **codecs = deadbeef->plug_get_decoder_list (); for (int i = 0; codecs[i]; i++) { if (codecs[i]->exts && codecs[i]->insert) { const char **exts = codecs[i]->exts; for (int e = 0; exts[e]; e++) { char buf[100]; snprintf (buf, sizeof (buf), "*.%s;", exts[e]); strcat (extlist, buf); } } } } GtkFileFilter* flt; flt = gtk_file_filter_new (); gtk_file_filter_set_name (flt, name); gtk_file_filter_add_pattern (flt, extlist); 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; }
static gboolean create_file_filter(lua_State* L, GtkFileChooser*dlg, const gchar*mask) { gchar **patterns=NULL; if (mask && *mask) { patterns=g_strsplit(mask, "|", 64); if (patterns) { gchar**pattern=patterns; if (g_strv_length(patterns)%2) { g_strfreev(patterns); return FALSE; } while (*pattern) { if (!**pattern) { g_strfreev(patterns); return FALSE; } pattern++; } pattern=patterns; while (*pattern) { gchar*maskname,*wildcard; maskname=*pattern; pattern++; wildcard=*pattern; if (maskname && wildcard) { GtkFileFilter*filter=gtk_file_filter_new(); gchar*wc=wildcard; gtk_file_filter_set_name(filter, maskname); do { gchar*sem=strchr(wc,';'); if (sem) { *sem='\0'; gtk_file_filter_add_pattern(filter,wc); wc++; } else { gtk_file_filter_add_pattern(filter,wc); break; } } while (1); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dlg),filter); } pattern++; } } } if (patterns) { g_strfreev(patterns); } return TRUE; }
void FileDialog::SetWildcard(const wxString& wildCard) { // parse filters wxArrayString wildDescriptions, wildFilters; if (!wxParseCommonDialogsFilter(wildCard, wildDescriptions, wildFilters)) { wxFAIL_MSG( wxT("FileDialog::SetWildCard - bad wildcard string") ); } else { // Parsing went fine. Set m_wildCard to be returned by FileDialogBase::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])); m_patterns.Add(wildFilters[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); } }
void SludgeApplication::saveToFile() { GtkWidget *dialog; GtkFileFilter *filter; dialog = gtk_file_chooser_dialog_new ("Save File", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, getFilterName()); gtk_file_filter_add_pattern(filter, getFilterPattern()); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter); if (currentShortname[0] != 0) { gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), currentShortname); } if (currentFolder[0] != 0) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), currentFolder); } if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); flipBackslashes(&filename); if (!saveFile (filename)) { errorBox ("Error", "Saving file failed."); } else { setFilename(filename); setFolderFromFilename(filename); } g_free (filename); } gtk_widget_destroy (dialog); }
void cir_gtk_file_open() { // Open a file using a GTK+ dialog GtkWidget *dialog = gtk_file_chooser_dialog_new( "Select a ROM", GTK_WINDOW(mainwindow), GTK_FILE_CHOOSER_ACTION_OPEN, ("_Cancel"), GTK_RESPONSE_CANCEL, ("_Open"), GTK_RESPONSE_ACCEPT, NULL); GtkFileFilter *filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, "NES ROMs"); gtk_file_filter_add_pattern(filter, "*.nes"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); gtk_widget_destroy(dialog); cir_rom_cleanup(); romloaded = 0; if (cir_rom_load(filename)) { cir_gtk_reset_spinbuttons(); // Split the header and the ROM cir_rom_split_header_rom(); if (cir_header_validate()) { // Check header version version = cir_header_get_version(); cir_gtk_header_parse(); char message[128]; snprintf(message, sizeof(message), "Loaded: %s", filename); cir_gtk_status_update(message); cir_gtk_set_sensitive(); romloaded = 1; } else { cir_gtk_message("Invalid File (No NES ROM Header)"); } } g_free(filename); } else { gtk_widget_destroy(dialog); } }
void fileio_do_movie_load(void) { Nes::Api::Machine machine( emulator ); Nes::Api::Movie movie( emulator ); GtkWidget *dialog; GtkFileFilter *filter; if (moviePlayFile) { delete moviePlayFile; moviePlayFile = NULL; } dialog = gtk_file_chooser_dialog_new ("Load a movie (.nsv)", GTK_WINDOW(mainwindow), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, "Nestopia movies"); gtk_file_filter_add_pattern(filter, "*.nsv"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { char *filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); moviePlayFile = new std::ifstream( filename, std::ifstream::in|std::ifstream::binary ); if (moviePlayFile->is_open()) { movie.Play(*moviePlayFile); } else { delete moviePlayFile; moviePlayFile = NULL; } g_free (filename); } gtk_widget_destroy(dialog); }
int clip_GTK_FILEFILTERSETNAME(ClipMachine * cm) { C_object *cfilter = _fetch_co_arg(cm); gchar *name = _clip_parc(cm, 2); CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object)); CHECKARG(2, CHARACTER_t); LOCALE_TO_UTF(name); gtk_file_filter_set_name(GTK_FILE_FILTER(cfilter->object), name); FREE_TEXT(name); return 0; err: return 1; }
static void panel_properties_dialog_setup_image_chooser (PanelPropertiesDialog *dialog, GladeXML *gui) { GtkFileFilter *filter; GtkWidget *chooser_preview; char *image; dialog->image_chooser = glade_xml_get_widget (gui, "image_chooser"); 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 (dialog->image_chooser), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog->image_chooser), filter); chooser_preview = gtk_image_new (); gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog->image_chooser), chooser_preview); g_signal_connect (dialog->image_chooser, "update-preview", G_CALLBACK (panel_properties_dialog_chooser_preview_update), chooser_preview); image = panel_profile_get_background_image (dialog->toplevel); if (string_empty (image)) gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (dialog->image_chooser)); else gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog->image_chooser), image); if (image) g_free (image); dialog->selection_emitted = 0; g_signal_connect_swapped (dialog->image_chooser, "selection-changed", G_CALLBACK (panel_properties_dialog_image_changed), dialog); if ( ! panel_profile_is_writable_background_image (dialog->toplevel)) { gtk_widget_set_sensitive (dialog->image_chooser, FALSE); gtk_widget_show (dialog->writability_warn_background); } }
static void file_open(GtkWidget *w, gpointer data) { GtkWidget *dialog; GtkFileFilter *filter; dialog = gtk_file_chooser_dialog_new("Open File", GTK_WINDOW(main_window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE); filter = gtk_file_filter_new(); gtk_file_filter_add_pattern(filter, "*.xml"); gtk_file_filter_add_pattern(filter, "*.XML"); gtk_file_filter_add_pattern(filter, "*.sda"); gtk_file_filter_add_pattern(filter, "*.SDA"); gtk_file_filter_add_mime_type(filter, "text/xml"); gtk_file_filter_set_name(filter, "XML file"); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { GSList *filenames; char *filename; filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog)); GError *error = NULL; while(filenames != NULL) { filename = filenames->data; parse_xml_file(filename, &error); if (error != NULL) { report_error(error); g_error_free(error); error = NULL; } g_free(filename); filenames = g_slist_next(filenames); } g_slist_free(filenames); report_dives(FALSE); } gtk_widget_destroy(dialog); }
static void on_load_clicked(GtkWidget* widget, void* handle) { FeedbackSuppressorUI* ui = (FeedbackSuppressorUI*)handle; /* Create a dialog to select a sample file. */ GtkWidget* dialog = gtk_file_chooser_dialog_new( "Load Sample", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); GtkFileFilter *filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, "Filter Lists"); gtk_file_filter_add_pattern(filter,"*.ofs"); gtk_file_chooser_add_filter((GtkFileChooser *) dialog,filter); /* Run the dialog, and return if it is cancelled. */ if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) { gtk_widget_destroy(dialog); return; } /* Get the file path from the dialog. */ char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); /* Got what we need, destroy the dialog and filter. */ gtk_widget_destroy(dialog); #define OBJ_BUF_SIZE 1024 uint8_t obj_buf[OBJ_BUF_SIZE]; lv2_atom_forge_set_buffer(&ui->forge, obj_buf, OBJ_BUF_SIZE); LV2_Atom* msg = write_set_file(&ui->forge, &ui->uris, filename, strlen(filename)); ui->write(ui->controller, 0, lv2_atom_total_size(msg), ui->uris.atom_eventTransfer, msg); g_free(filename); }
void on_save_preset_clicked (GtkMenuItem *menuitem, gpointer user_data) { GtkWidget *dlg = gtk_file_chooser_dialog_new (_("Save DeaDBeeF EQ Preset"), GTK_WINDOW (mainwin), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dlg), TRUE); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dlg), "untitled.ddbeq"); GtkFileFilter* flt; flt = gtk_file_filter_new (); gtk_file_filter_set_name (flt, _("DeaDBeeF EQ preset files (*.ddbeq)")); gtk_file_filter_add_pattern (flt, "*.ddbeq"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), flt); if (gtk_dialog_run (GTK_DIALOG (dlg)) == GTK_RESPONSE_OK) { gchar *fname = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dlg)); gtk_widget_destroy (dlg); if (fname) { FILE *fp = fopen (fname, "w+b"); if (fp) { ddb_dsp_context_t *eq = get_supereq (); if (eq) { char fv[100]; float v; for (int i = 0; i < 18; i++) { eq->plugin->get_param (eq, i+1, fv, sizeof (fv)); v = atof (fv); fprintf (fp, "%f\n", v); } eq->plugin->get_param (eq, 0, fv, sizeof (fv)); v = atof (fv); fprintf (fp, "%f\n", v); } fclose (fp); } g_free (fname); } } else { gtk_widget_destroy (dlg); } }
static GdkPixbuf * choose_new_face (void) { GdkPixbuf *res = NULL; GtkWidget *filesel, *preview; GtkFileFilter *filter; filesel = gtk_file_chooser_dialog_new ( _("Select a Face Picture"), NULL, 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 (filesel), GTK_RESPONSE_OK); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Image files")); gtk_file_filter_add_mime_type (filter, "image/*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (filesel), filter); preview = gtk_image_new (); gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (filesel), preview); g_signal_connect (filesel, "update-preview", G_CALLBACK (update_preview_cb), preview); if (GTK_RESPONSE_OK == gtk_dialog_run (GTK_DIALOG (filesel))) { gchar *image_filename, *file_contents = NULL; gsize length = 0; image_filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filesel)); gtk_widget_destroy (filesel); if (prepare_image (image_filename, &file_contents, &length, &res, TRUE)) { set_face_raw (file_contents, length); } g_free (file_contents); g_free (image_filename); } else { gtk_widget_destroy (filesel); } return res; }
static void byzanz_encoder_flv_class_init (ByzanzEncoderFlvClass *klass) { ByzanzEncoderClass *encoder_class = BYZANZ_ENCODER_CLASS (klass); ByzanzEncoderGStreamerClass *gstreamer_class = BYZANZ_ENCODER_GSTREAMER_CLASS (klass); encoder_class->filter = gtk_file_filter_new (); g_object_ref_sink (encoder_class->filter); gtk_file_filter_set_name (encoder_class->filter, _("Flash video")); gtk_file_filter_add_mime_type (encoder_class->filter, "video/x-flv"); gtk_file_filter_add_pattern (encoder_class->filter, "*.flv"); gstreamer_class->pipeline_string = "appsrc name=src ! videoconvert ! avenc_flashsv buffer-size=8388608 ! flvmux ! giostreamsink name=sink"; gstreamer_class->audio_pipeline_string = "autoaudiosrc name=audiosrc ! audioconvert ! audio/x-raw-int,width=16 ! queue ! flvmux name=muxer ! giostreamsink name=sink " "appsrc name=src ! videoconvert ! avenc_flashsv buffer-size=8388608 ! muxer."; }
static void byzanz_encoder_byzanz_class_init (ByzanzEncoderByzanzClass *klass) { ByzanzEncoderClass *encoder_class = BYZANZ_ENCODER_CLASS (klass); /* We don't use the run vfunc and just g_output_stream_slice() here, * because this way we get data verification. */ encoder_class->setup = byzanz_encoder_byzanz_setup; encoder_class->process = byzanz_encoder_byzanz_process; encoder_class->close = byzanz_encoder_byzanz_close; encoder_class->filter = gtk_file_filter_new (); g_object_ref_sink (encoder_class->filter); gtk_file_filter_set_name (encoder_class->filter, _("Byzanz debug files")); gtk_file_filter_add_mime_type (encoder_class->filter, "application/x-byzanz"); gtk_file_filter_add_pattern (encoder_class->filter, "*.byzanz"); }
void add_dialog_filters(GtkWidget *dialog, char * const p_types[], uint4 p_type_count ) { GtkFileFilter *filter ; if ( p_type_count >= 1 ) { for (uint4 a=0; a < p_type_count; a++) { char *t_filter_name, *t_filter_masks; t_filter_name = get_filter_name(p_types[a]); t_filter_masks = get_filter_masks(p_types[a]); filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, t_filter_name); if (strcasecmp (t_filter_name, "All files") != 0) { for ( uint4 m = 0 ; m < get_filter_count(t_filter_masks); m++) { char *t_filter_mask; t_filter_mask = get_filter_mask(m, t_filter_masks); char *filter_mask; filter_mask = nil; MCCStringFormat(filter_mask, "*.%s", t_filter_mask); gtk_file_filter_add_pattern(filter, filter_mask); MCCStringFree(filter_mask); delete t_filter_mask; } } else gtk_file_filter_add_pattern ( filter, "*" ); gtk_file_chooser_add_filter ( GTK_FILE_CHOOSER ( dialog ) , filter ) ; delete t_filter_name; delete t_filter_masks; } } }
GFile * ImageOpenDlg::show(GtkWindow * win, Settings * settings, bool localOnly, bool * attach) { GtkWidget * dialog = gtk_file_chooser_dialog_new(_("Open Image"), win, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(dialog), localOnly); GtkFileFilter * filterSupported = gtk_file_filter_new(); gtk_file_filter_set_name(filterSupported, _("Images")); gtk_file_filter_add_pixbuf_formats(filterSupported); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filterSupported); if (!settings->getLastImagePath().isEmpty()) { gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(dialog), settings->getLastImagePath().c_str()); } GtkWidget * cbAttach = NULL; if (attach) { cbAttach = gtk_check_button_new_with_label(_("Attach file to the journal")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbAttach), false); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), cbAttach); } GtkWidget * image = gtk_image_new(); gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), image); g_signal_connect(dialog, "update-preview", G_CALLBACK(updatePreviewCallback), NULL); gtk_window_set_transient_for(GTK_WINDOW(dialog), win); if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) { gtk_widget_destroy(dialog); return NULL; } GFile * file = gtk_file_chooser_get_file(GTK_FILE_CHOOSER(dialog)); if (attach) { *attach = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cbAttach)); } char * folder = gtk_file_chooser_get_current_folder_uri(GTK_FILE_CHOOSER(dialog)); settings->setLastImagePath(folder); g_free(folder); gtk_widget_destroy(dialog); return file; }
void ui_save_file_cb(GtkWidget* widget, gpointer data) { GtkWidget *filedialog; GtkFileFilter *filefilter; filedialog = gtk_file_chooser_dialog_new("Save...", GTK_WINDOW(ui_window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); GList *handlers = io_get_save_handlers(); GList *iter; for(iter = g_list_first(handlers); iter; iter = g_list_next(iter)) { plugin_save_handler_t *handler = (plugin_save_handler_t *) iter->data; filefilter = gtk_file_filter_new(); gtk_file_filter_set_name(GTK_FILE_FILTER(filefilter), handler->desc); int i; for(i=0; i<handler->nfilters; i++) { gtk_file_filter_add_pattern(GTK_FILE_FILTER(filefilter), (char*) handler->filters[i]); } gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filedialog), filefilter); g_object_set_data(G_OBJECT(filefilter), "handler", (gpointer) handler); } g_list_free(handlers); if(gtk_dialog_run(GTK_DIALOG(filedialog)) == GTK_RESPONSE_ACCEPT) { GtkWidget* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(filedialog)); plugin_save_handler_t *handler = g_object_get_data(G_OBJECT(filter), "handler"); gchar *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filedialog)); io_save_image(path, handler); } gtk_widget_destroy(GTK_WIDGET(filedialog)); }
static void byzanz_encoder_webm_class_init (ByzanzEncoderWebmClass *klass) { ByzanzEncoderClass *encoder_class = BYZANZ_ENCODER_CLASS (klass); ByzanzEncoderGStreamerClass *gstreamer_class = BYZANZ_ENCODER_GSTREAMER_CLASS (klass); encoder_class->filter = gtk_file_filter_new (); g_object_ref_sink (encoder_class->filter); gtk_file_filter_set_name (encoder_class->filter, _("WebM video")); gtk_file_filter_add_mime_type (encoder_class->filter, "video/webm"); gtk_file_filter_add_pattern (encoder_class->filter, "*.webm"); gstreamer_class->pipeline_string = "appsrc name=src ! videoconvert ! videorate ! " "video/x-raw,format=I420,framerate=25/1 ! vp8enc ! webmmux ! giostreamsink name=sink"; gstreamer_class->audio_pipeline_string = "autoaudiosrc name=audiosrc ! audioconvert ! vorbisenc ! queue ! webmmux name=muxer ! giostreamsink name=sink " "appsrc name=src ! videoconvert ! videorate ! " "video/x-raw,format=I420,framerate=25/1 ! vp8enc ! queue ! muxer."; }
static GtkFileFilter* egg_file_format_filter_new (const gchar *name, gboolean show_extensions) { GtkFileFilter *filter; EggFileFormatFilterInfo *info; filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, name); info = egg_file_format_filter_info_new (name, show_extensions); gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_FILENAME, egg_file_format_filter_filter, info, NULL); g_object_set_qdata_full (G_OBJECT (filter), egg_file_format_filter_info_quark (), info, egg_file_format_filter_info_free); return filter; }
static void byzanz_encoder_ogv_class_init (ByzanzEncoderOgvClass *klass) { ByzanzEncoderClass *encoder_class = BYZANZ_ENCODER_CLASS (klass); ByzanzEncoderGStreamerClass *gstreamer_class = BYZANZ_ENCODER_GSTREAMER_CLASS (klass); encoder_class->filter = gtk_file_filter_new (); g_object_ref_sink (encoder_class->filter); gtk_file_filter_set_name (encoder_class->filter, _("Theora video")); gtk_file_filter_add_mime_type (encoder_class->filter, "video/ogg"); gtk_file_filter_add_pattern (encoder_class->filter, "*.ogv"); gtk_file_filter_add_pattern (encoder_class->filter, "*.ogg"); gstreamer_class->pipeline_string = "appsrc name=src ! videoconvert ! videorate !" "video/x-raw,format=Y444,framerate=25/1 ! theoraenc ! oggmux ! giostreamsink name=sink"; gstreamer_class->audio_pipeline_string = "autoaudiosrc name=audiosrc ! audioconvert ! queue ! oggmux name=muxer ! giostreamsink name=sink " "appsrc name=src ! videoconvert ! videorate ! " "video/x-raw,format=Y444,framerate=25/1 ! theoraenc ! queue ! muxer."; }
/* See VikDataSourceInterface */ static void datasource_file_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data ) { datasource_file_widgets_t *widgets = (datasource_file_widgets_t *)user_data; GtkWidget *filename_label, *type_label; /* The file selector */ filename_label = gtk_label_new (_("File:")); widgets->file = gtk_file_chooser_button_new (_("File to import"), GTK_FILE_CHOOSER_ACTION_OPEN); if (last_folder_uri) gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(widgets->file), last_folder_uri); /* Add filters */ g_list_foreach ( a_babel_file_list, add_file_filter, widgets->file ); GtkFileFilter *all_filter = gtk_file_filter_new (); gtk_file_filter_add_pattern ( all_filter, "*" ); gtk_file_filter_set_name ( all_filter, _("All files") ); gtk_file_chooser_add_filter ( GTK_FILE_CHOOSER(widgets->file), all_filter ); if ( last_file_filter == NULL ) /* No previously selected filter or 'All files' selected */ gtk_file_chooser_set_filter ( GTK_FILE_CHOOSER(widgets->file), all_filter ); /* The file format selector */ type_label = gtk_label_new (_("File type:")); /* Propose any readable file */ BabelMode mode = { 1, 0, 1, 0, 1, 0 }; widgets->type = a_babel_ui_file_type_selector_new ( mode ); g_signal_connect ( G_OBJECT(widgets->type), "changed", G_CALLBACK(a_babel_ui_type_selector_dialog_sensitivity_cb), dialog ); gtk_combo_box_set_active ( GTK_COMBO_BOX(widgets->type), last_type ); /* Manually call the callback to fix the state */ a_babel_ui_type_selector_dialog_sensitivity_cb ( GTK_COMBO_BOX(widgets->type), dialog ); /* Packing all these widgets */ GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))); gtk_box_pack_start ( box, filename_label, FALSE, FALSE, 5 ); gtk_box_pack_start ( box, widgets->file, FALSE, FALSE, 5 ); gtk_box_pack_start ( box, type_label, FALSE, FALSE, 5 ); gtk_box_pack_start ( box, widgets->type, FALSE, FALSE, 5 ); gtk_widget_show_all(dialog); }
static void gwwv_file_def_filters(GtkWidget *dialog, const char *def_name, const struct gwwv_filter *filters ) { GtkFileFilter *filter, *standard; int i; g_object_set(G_OBJECT(dialog),"show-hidden",TRUE,NULL); if ( def_name!=NULL ) { gsize read, written; char *temp = g_filename_from_utf8(def_name,-1,&read,&written,NULL); char *pt = strrchr( temp,'/'); if ( pt!=NULL ) { *pt = '\0'; gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( dialog ), temp ); gtk_file_chooser_set_current_name( GTK_FILE_CHOOSER( dialog ), pt+1 ); } else gtk_file_chooser_set_current_name( GTK_FILE_CHOOSER( dialog ), temp ); free(temp); } if ( filters!=NULL ) { standard = NULL; for ( i=0; filters[i].name!=NULL; ++i ) { filter = gtk_file_filter_new(); if ( filters[i].filtfunc!=NULL ) gtk_file_filter_add_custom( filter,GTK_FILE_FILTER_FILENAME, filters[i].filtfunc, (gpointer) filters[i].wild, NULL); else /* GTK's gtk_file_filter_add_pattern doesn't handled {} wildcards */ /* and I depend on those. So I use my own patern matcher */ gtk_file_filter_add_custom( filter,GTK_FILE_FILTER_FILENAME, gwwv_file_pattern_matcher, (gpointer) filters[i].wild, NULL); gtk_file_filter_set_name( filter,filters[i].name ); gtk_file_chooser_add_filter( GTK_FILE_CHOOSER( dialog ), filter ); if ( i==0 ) standard = filter; } if ( standard!=NULL ) gtk_file_chooser_set_filter( GTK_FILE_CHOOSER( dialog ), standard ); } }
void ol_menu_assign_lrc (GtkWidget *widget, gpointer data) { static char *prev_path = NULL; OlMetadata *info = ol_app_get_current_music (); GtkFileFilter *lrc_filter = NULL; lrc_filter = gtk_file_filter_new (); gtk_file_filter_set_name (lrc_filter, _("LRC files")); gtk_file_filter_add_pattern (lrc_filter, "*.lrc"); if (info != NULL) { ol_debugf ("prev_path: %s\n", prev_path); GtkWidget *dialog = NULL; dialog = gtk_file_chooser_dialog_new (_("Choose LRC file to assign"), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), lrc_filter); if (prev_path != NULL) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), prev_path); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { char *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); ol_app_assign_lrcfile (info, filename, TRUE); g_free (filename); if (prev_path != NULL) g_free (prev_path); prev_path = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog)); } gtk_widget_destroy (dialog); dialog = NULL; } }
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("Import Certificate Request", GTK_WINDOW(data), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, 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, *utf_filename; filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser)); utf_filename = g_filename_to_utf8(filename, -1, NULL, NULL, NULL); g_free(filename); gtk_entry_set_text(GTK_ENTRY (g_object_get_data(G_OBJECT(widget), "entry")), utf_filename); g_free(utf_filename); gtk_widget_destroy(file_chooser); } else { gtk_widget_destroy(file_chooser); } } }
void gtkui_state_load() { // Load a state from the GUI GtkWidget *dialog = gtk_file_chooser_dialog_new("Load State (.nst)", GTK_WINDOW(gtkwindow), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); GtkFileFilter *filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, "Nestopia Save States"); gtk_file_filter_add_pattern(filter, "*.nst"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), nstpaths.statepath); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); nst_state_load(filename); g_free(filename); } gtk_widget_destroy(dialog); }
void gtkui_cheats_load() { // Load cheats from the GUI GtkWidget *dialog = gtk_file_chooser_dialog_new("Load cheats (.xml)", GTK_WINDOW(gtkwindow), GTK_FILE_CHOOSER_ACTION_OPEN, "Cancel", GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL); GtkFileFilter *filter = gtk_file_filter_new(); gtk_file_filter_set_name(filter, "Nestopia cheats"); gtk_file_filter_add_pattern(filter, "*.xml"); gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filter); gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), nstpaths.nstdir); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); gtkui_cheats_fill_tree(filename); g_free(filename); } gtk_widget_destroy(dialog); }