void check_file_add_filters(GtkFileFilter *filter) { gtk_file_filter_add_mime_type(filter, "application/x-md5"); gtk_file_filter_add_mime_type(filter, "application/x-sha1"); gtk_file_filter_add_mime_type(filter, "text/x-sfv"); gtk_file_filter_add_pattern(filter, "*.md5"); gtk_file_filter_add_pattern(filter, "*.sfv"); gtk_file_filter_add_pattern(filter, "*.sha1"); gtk_file_filter_add_pattern(filter, "*.sha224"); gtk_file_filter_add_pattern(filter, "*.sha256"); gtk_file_filter_add_pattern(filter, "*.sha384"); gtk_file_filter_add_pattern(filter, "*.sha512"); gtk_file_filter_add_pattern(filter, "*md5sum*"); gtk_file_filter_add_pattern(filter, "*sha1sum*"); gtk_file_filter_add_pattern(filter, "*sha224sum*"); gtk_file_filter_add_pattern(filter, "*sha256sum*"); gtk_file_filter_add_pattern(filter, "*sha384sum*"); gtk_file_filter_add_pattern(filter, "*sha512sum*"); gtk_file_filter_add_pattern(filter, "*MD5SUM*"); gtk_file_filter_add_pattern(filter, "*SHA1SUM*"); gtk_file_filter_add_pattern(filter, "*SHA224SUM*"); gtk_file_filter_add_pattern(filter, "*SHA256SUM*"); gtk_file_filter_add_pattern(filter, "*SHA384SUM*"); gtk_file_filter_add_pattern(filter, "*SHA512SUM*"); gtk_file_filter_add_pattern(filter, "*CHECKSUM*"); gtk_file_filter_add_pattern(filter, "*DIGEST*"); }
void ui_signal_export (GtkMenuItem * item, gpointer data) { GtkWidget *dialog; GtkWidget *window = GET_OBJECT("window"); GtkFileFilter * filter_auto; GtkFileFilter * filter_pdf; GtkFileFilter * filter_svg; GtkFileFilter * filter_png; dialog = gtk_file_chooser_dialog_new (_("Export"), GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); /* Set filters */ filter_auto = gtk_file_filter_new(); filter_pdf = gtk_file_filter_new(); filter_svg = gtk_file_filter_new(); filter_png = gtk_file_filter_new(); gtk_file_filter_add_pattern (filter_auto, "*"); gtk_file_filter_add_mime_type (filter_pdf, "application/pdf"); gtk_file_filter_add_mime_type (filter_svg, "image/svg+xml"); gtk_file_filter_add_mime_type (filter_png, "image/png"); gtk_file_filter_set_name (filter_pdf, "Portable Document Format (PDF)"); gtk_file_filter_set_name (filter_svg, "Scalable Vector Graphcis (SVG)"); gtk_file_filter_set_name (filter_png, "Portable Networks Graphcis (PNG)"); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_png); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_pdf); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_svg); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { char *filename; char * ext; gint width, height; GtkFileFilter * filter; gboolean successp; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); filter = gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (dialog)); gdk_window_get_size (hexboard->window, &width, &height); if (filter == filter_pdf) ext = "pdf"; else if (filter == filter_png) ext = "png"; else if (filter == filter_svg) ext = "svg"; successp = hexboard_save_as_image (HEXBOARD(hexboard), filename, ext, width, height); if (!successp) g_message (_("An error ocurred while export the board.")); g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Board was exported to %s."), filename); g_free (filename); } gtk_widget_destroy (dialog); }
static void file_filter_add_mime_types (EvTypeInfo *info, GtkFileFilter *filter) { const gchar *mime_type; gint i = 0; #ifdef ENABLE_PIXBUF if (g_ascii_strcasecmp (info->mime_types[0], "image/*") == 0) { GList *pixbuf_types, *l; pixbuf_types = gdk_pixbuf_mime_type_list (); for (l = pixbuf_types; l; l = g_list_next (l)) { gchar **mime_types = (gchar **)l->data; gint j = 0; while ((mime_type = mime_types[j++])) gtk_file_filter_add_mime_type (filter, mime_type); g_strfreev (mime_types); } g_list_free (pixbuf_types); return; } #endif /* ENABLE_PIXBUF */ while ((mime_type = info->mime_types[i++])) gtk_file_filter_add_mime_type (filter, mime_type); }
void bmd_open_callback (GSimpleAction *action, GVariant *parameter, gpointer data) { gchar *filename; bmd_widgets *a = (bmd_widgets *) data; GtkFileFilter *filter = gtk_file_filter_new (); GtkWidget *dialog = gtk_file_chooser_dialog_new ("Open library", GTK_WINDOW (a->window), GTK_FILE_CHOOSER_ACTION_OPEN, "_OK", GTK_RESPONSE_ACCEPT, "_Cancel", GTK_RESPONSE_CANCEL, NULL); gtk_file_filter_set_name (filter, "*.csv, *.txt"); // I used "xdg-mime query default application/csv" to determine whether a CSV // mime-type is available gtk_file_filter_add_mime_type (filter, "text/csv"); gtk_file_filter_add_mime_type (filter, "application/csv"); gtk_file_filter_add_mime_type (filter, "text/x-csv"); gtk_file_filter_add_mime_type (filter, "application/x-extension-txt"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); switch (gtk_dialog_run (GTK_DIALOG (dialog))) { case GTK_RESPONSE_ACCEPT: { filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); g_print ("Selected filename: %s\n", filename); break; } default: break; } gtk_widget_destroy (dialog); }
static void add_image_files (GtkWidget *dialog) { GtkFileFilter* filter; GSList *formats, *l; gchar **mimes, **t; filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All image files")); formats = gdk_pixbuf_get_formats (); for (l = formats; l; l = g_slist_next (l)) { mimes = gdk_pixbuf_format_get_mime_types ((GdkPixbufFormat*)l->data); for (t = mimes; *t; t++) gtk_file_filter_add_mime_type (filter, *t); g_strfreev (mimes); } g_slist_free (formats); 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 JPEG files")); gtk_file_filter_add_mime_type (filter, "image/jpeg"); gtk_file_chooser_add_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 void setup_file_filters_fixme (void) { filter_all = gtk_file_filter_new (); gtk_file_filter_set_name (filter_all, _("All files")); gtk_file_filter_add_pattern (filter_all, "*"); g_object_ref (filter_all); filter_supported = gtk_file_filter_new (); gtk_file_filter_set_name (filter_supported, _("Supported files")); #if USE_GSTREAMER gtk_file_filter_add_mime_type (filter_supported, "application/ogg"); gtk_file_filter_add_mime_type (filter_supported, "audio/*"); #else xine_t *xine; char* xine_supported = xine_get_mime_types(xine); char* result = strtok(xine_supported, ":"); while (result != NULL) { gtk_file_filter_add_mime_type (filter_supported, result); strtok(NULL, ";"); result = strtok(NULL, ":"); } #endif g_object_ref (filter_supported); }
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 exporter_display_chooser (GcrCertificateExporter *self) { GtkFileFilter* filter; GtkWidget *dialog; gchar *filename; g_assert (!self->pv->chooser_dialog); dialog = gtk_file_chooser_dialog_new (_("Export certificate"), NULL, GTK_FILE_CHOOSER_ACTION_SAVE, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Save"), GTK_RESPONSE_ACCEPT, NULL); self->pv->chooser_dialog = g_object_ref_sink(dialog); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT); gtk_file_chooser_set_local_only (self->pv->chooser_dialog, FALSE); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Certificate files")); gtk_file_filter_add_mime_type (filter, "application/x-x509-ca-cert"); gtk_file_filter_add_mime_type (filter, "application/x-x509-user-cert"); gtk_file_filter_add_mime_type (filter, "application/pkix-cert"); gtk_file_filter_add_pattern (filter, "*.cer"); gtk_file_filter_add_pattern (filter, "*.crt"); g_object_set_data (G_OBJECT (filter), "prepare-data-func", prepare_data_for_der); gtk_file_chooser_add_filter (self->pv->chooser_dialog, filter); gtk_file_chooser_set_filter (self->pv->chooser_dialog, filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("PEM files")); gtk_file_filter_add_mime_type (filter, "text/plain"); gtk_file_filter_add_pattern (filter, "*.pem"); g_object_set_data (G_OBJECT (filter), "prepare-data-func", prepare_data_for_pem); gtk_file_chooser_add_filter (self->pv->chooser_dialog, filter); filename = g_strconcat (self->pv->label, ".crt", NULL); g_strdelimit (filename, BAD_FILENAME_CHARS, '_'); gtk_file_chooser_set_current_name (self->pv->chooser_dialog, filename); g_free (filename); g_signal_connect (self->pv->chooser_dialog, "response", G_CALLBACK (on_chooser_dialog_response), self); if (self->pv->cancellable) g_cancellable_connect (self->pv->cancellable, G_CALLBACK (on_cancel_chooser_dialog), self, NULL); gtk_widget_show (GTK_WIDGET (self->pv->chooser_dialog)); }
static void gtk_openavatarthread(void *UNUSED(args)) { void *dialog = gtk_file_chooser_dialog_new((const char *)S(SELECT_AVATAR_TITLE), NULL, GTK_FILE_CHOOSER_ACTION_OPEN, "_Cancel", GTK_RESPONSE_CANCEL, "_Open", GTK_RESPONSE_ACCEPT, NULL); void *filter = gtk_file_filter_new(); gtk_file_filter_add_mime_type(filter, "image/jpeg"); gtk_file_filter_add_mime_type(filter, "image/png"); gtk_file_filter_add_mime_type(filter, "image/bmp"); gtk_file_filter_add_mime_type(filter, "image/gif"); gtk_file_chooser_set_filter(dialog, filter); void *preview = gtk_image_new(); gtk_file_chooser_set_preview_widget(dialog, preview); g_signal_connect_data(dialog, "update-preview", update_image_preview, preview, NULL, 0); while (gtk_dialog_run(dialog) == GTK_RESPONSE_ACCEPT) { char *filename = gtk_file_chooser_get_filename(dialog); int size; int width, height, bpp; uint8_t *img = stbi_load(filename, &width, &height, &bpp, 0); uint8_t *file_data = stbi_write_png_to_mem(img, 0, width, height, bpp, &size); free(img); g_free_utox(filename); if (!file_data) { void *message_dialog = gtk_message_dialog_new(dialog, 0, 1, 2, (const char *)S(CANT_FIND_FILE_OR_EMPTY)); gtk_dialog_run(message_dialog); gtk_widget_destroy(message_dialog); } else if (size > UTOX_AVATAR_MAX_DATA_LENGTH) { free(file_data); char_t size_str[16]; int len = sprint_humanread_bytes(size_str, sizeof(size_str), UTOX_AVATAR_MAX_DATA_LENGTH); void *message_dialog = gtk_message_dialog_new(dialog, 0, 1, 2, "%s%.*s.", S(AVATAR_TOO_LARGE_MAX_SIZE_IS), len, size_str); gtk_dialog_run(message_dialog); gtk_widget_destroy(message_dialog); } else { postmessage(SELF_AVATAR_SET, size, 0, file_data); break; } } gtk_widget_destroy(dialog); while(gtk_events_pending()) { gtk_main_iteration(); } gtk_open = false; }
GtkFileFilter * gtk_file_filter_from_gvariant (GVariant *variant) { GtkFileFilter *filter; GVariantIter *iter; const char *name; int type; char *tmp; filter = gtk_file_filter_new (); g_variant_get (variant, "(&sa(us))", &name, &iter); gtk_file_filter_set_name (filter, name); while (g_variant_iter_next (iter, "(u&s)", &type, &tmp)) { switch (type) { case 0: gtk_file_filter_add_pattern (filter, tmp); break; case 1: gtk_file_filter_add_mime_type (filter, tmp); break; default: break; } } g_variant_iter_free (iter); return filter; }
void open_image_file_cb ( GtkWidget *widget, AnypaperWindow *window ) { GtkWidget *dialog; GtkWidget *preview; GtkFileFilter *filterImages, *filterAll; preview = gtk_image_new (); dialog = gtk_file_chooser_dialog_new ("Open File", GTK_WINDOW(window->priv->window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); filterImages = gtk_file_filter_new (); gtk_file_filter_set_name (GTK_FILE_FILTER(filterImages),"JPEG images"); gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filterImages), "image/jpeg/*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filterImages); filterAll = gtk_file_filter_new (); gtk_file_filter_set_name (GTK_FILE_FILTER(filterAll),"All files"); gtk_file_filter_add_pattern(GTK_FILE_FILTER(filterAll), "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filterAll); gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), preview); gtk_file_chooser_set_filename(GTK_FILE_CHOOSER (dialog), gtk_entry_get_text (GTK_ENTRY (window->priv->file_entry))); g_signal_connect (dialog, "update-preview", G_CALLBACK (update_preview_cb), preview); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { g_free(window->parameters->file); window->parameters->file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); gtk_entry_set_text (GTK_ENTRY (window->priv->file_entry), window->parameters->file); set_image_common(window); } gtk_widget_destroy (dialog); }
static GtkFileFilter * ephy_file_chooser_add_mime_filter (GtkFileChooser *dialog, const char *title, const char *first_mimetype, ...) { GtkFileFilter *filth; va_list args; const char *mimetype; filth = gtk_file_filter_new (); va_start (args, first_mimetype); mimetype = first_mimetype; while (mimetype != NULL) { gtk_file_filter_add_mime_type (filth, mimetype); mimetype = va_arg (args, const char *); } va_end (args); gtk_file_filter_set_name (filth, title); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filth); return filth; }
static GtkWidget *xml_file_selector(GtkWidget *vbox, GtkWidget *main_dialog) { GtkWidget *hbox, *frame, *chooser, *dialog; GtkFileFilter *filter; hbox = gtk_hbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3); frame = gtk_frame_new("XML file name"); gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 3); dialog = gtk_file_chooser_dialog_new("Open XML 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), FALSE); 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); chooser = gtk_file_chooser_button_new_with_dialog(dialog); g_signal_connect(G_OBJECT(chooser), "file-set", G_CALLBACK(on_file_set), main_dialog); gtk_file_chooser_button_set_width_chars(GTK_FILE_CHOOSER_BUTTON(chooser), 30); gtk_container_add(GTK_CONTAINER(frame), chooser); return chooser; }
static void add_file_button_clicked_cb (GtkButton *button, gpointer user_data) { GthSlideshowPreferences *self = user_data; GtkWidget *dialog; GtkFileFilter *filter; dialog = gtk_file_chooser_dialog_new (_("Choose the files to play"), GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (self))), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), g_get_user_special_dir (G_USER_DIRECTORY_MUSIC)); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Audio files")); gtk_file_filter_add_mime_type (filter, "audio/*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); g_signal_connect (dialog, "delete-event", G_CALLBACK (gtk_true), NULL); g_signal_connect (dialog, "response", G_CALLBACK (file_chooser_dialog_response_cb), self); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_widget_show (dialog); }
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; }
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; }
/*# @method add_mime_type GtkFileFilter @brief Adds a rule allowing a given mime type to filter. @param mime_type name of a MIME type */ FALCON_FUNC FileFilter::add_mime_type( VMARG ) { Item* i_tp = vm->param( 0 ); #ifndef NO_PARAMETER_CHECK if ( !i_tp || !i_tp->isString() ) throw_inv_params( "S" ); #endif AutoCString tp( i_tp->asString() ); gtk_file_filter_add_mime_type( GET_FILEFILTER( vm->self() ), tp.c_str() ); }
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 brasero_file_chooser_init (BraseroFileChooser *obj) { GtkFileFilter *filter; obj->priv = g_new0 (BraseroFileChooserPrivate, 1); obj->priv->chooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_OPEN); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (obj->priv->chooser), FALSE); gtk_widget_show (obj->priv->chooser); gtk_container_add (GTK_CONTAINER (obj), obj->priv->chooser); g_signal_connect (obj->priv->chooser, "file-activated", G_CALLBACK (brasero_file_chooser_uri_activated_cb), obj); g_signal_connect (obj->priv->chooser, "selection-changed", G_CALLBACK (brasero_file_chooser_uri_selection_changed_cb), obj); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (obj->priv->chooser), TRUE); 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 (obj->priv->chooser), filter); obj->priv->filter_any = filter; filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Audio files")); gtk_file_filter_add_mime_type (filter, "audio/*"); gtk_file_filter_add_mime_type (filter, "application/ogg"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (obj->priv->chooser), filter); obj->priv->filter_audio = filter; filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Movies")); gtk_file_filter_add_mime_type (filter, "video/*"); gtk_file_filter_add_mime_type (filter, "application/ogg"); gtk_file_filter_add_mime_type (filter, "application/x-flash-video"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (obj->priv->chooser), filter); obj->priv->filter_video = filter; filter = gtk_file_filter_new (); /* Translators: this is an image, a picture, not a "Disc Image" */ gtk_file_filter_set_name (filter, C_("picture", "Image files")); gtk_file_filter_add_mime_type (filter, "image/*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (obj->priv->chooser), filter); /* this is a hack/workaround to add support for multi DND */ gtk_container_foreach (GTK_CONTAINER (obj->priv->chooser), brasero_file_chooser_customize, NULL); }
static GtkFileFilter *make_xml_file_filter(){ GtkFileFilter *new_filter; new_filter = gtk_file_filter_new(); gtk_file_filter_set_name(new_filter, _("XML Files")); gtk_file_filter_add_mime_type(new_filter, "text/xml"); gtk_file_filter_add_pattern(new_filter, "*.xml"); gtk_file_filter_add_pattern(new_filter, "*.sgml"); gtk_file_filter_add_pattern(new_filter, "*.xsl"); gtk_file_filter_add_pattern(new_filter, "*.xslt"); gtk_file_filter_add_pattern(new_filter, "*.xsd"); gtk_file_filter_add_pattern(new_filter, "*.xhtml"); return new_filter; }
static void file_filter_add_mime_types (EvBackendInfo *info, GtkFileFilter *filter) { char **mime_types; guint i; mime_types = info->mime_types; if (mime_types == NULL) return; for (i = 0; mime_types[i] != NULL; ++i) gtk_file_filter_add_mime_type (filter, mime_types[i]); }
void file_type_archive_initializer(file_type_handler_t *info) {/*{{{*/ // Fill the file filter pattern info->file_types_handled = gtk_file_filter_new(); // Mime types for archives gtk_file_filter_add_mime_type(info->file_types_handled, "application/x-tar"); gtk_file_filter_add_mime_type(info->file_types_handled, "application/x-zip"); gtk_file_filter_add_mime_type(info->file_types_handled, "application/x-rar"); // Arbitrary archive files gtk_file_filter_add_pattern(info->file_types_handled, "*.zip"); gtk_file_filter_add_pattern(info->file_types_handled, "*.rar"); gtk_file_filter_add_pattern(info->file_types_handled, "*.7z"); gtk_file_filter_add_pattern(info->file_types_handled, "*.tar"); gtk_file_filter_add_pattern(info->file_types_handled, "*.tbz"); gtk_file_filter_add_pattern(info->file_types_handled, "*.tgz"); gtk_file_filter_add_pattern(info->file_types_handled, "*.tar.bz2"); gtk_file_filter_add_pattern(info->file_types_handled, "*.tar.gz"); // Assign the handlers info->alloc_fn = file_type_archive_alloc; }/*}}}*/
GtkFileFilter* sgml_importer_filter_factory_callback (CongServiceImporter *importer) { GtkFileFilter *filter; g_return_val_if_fail (importer, NULL); filter = cong_service_importer_make_basic_filter (importer); gtk_file_filter_add_mime_type (filter, "text/sgml"); return filter; }
void save_default_file_cb( GtkWidget *widget, AnypaperWindow *window ) { GtkWidget *dialog, *dialog_error; GtkFileFilter *filterImages, *filterAll; dialog = gtk_file_chooser_dialog_new ("Default file", GTK_WINDOW(window->priv->window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); filterImages = gtk_file_filter_new (); gtk_file_filter_set_name (GTK_FILE_FILTER(filterImages),"JPEG images"); gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filterImages), "image/jpeg/*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filterImages); filterAll = gtk_file_filter_new (); gtk_file_filter_set_name (GTK_FILE_FILTER(filterAll),"All files"); gtk_file_filter_add_pattern(GTK_FILE_FILTER(filterAll), "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filterAll); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), FALSE); gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dialog), gtk_entry_get_text (GTK_ENTRY (window->priv->def_entry))); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { char *filename, *down_filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); down_filename = g_ascii_strdown (filename, -1); if ((g_str_has_suffix (down_filename, ".jpg")) || (g_str_has_suffix (down_filename, ".jpeg")) || (g_str_has_suffix (down_filename, ".png"))) { g_free(window->parameters->defaultfile); gtk_entry_set_text (GTK_ENTRY (window->priv->def_entry),filename); window->parameters->defaultfile = filename; } else { dialog_error = gtk_message_dialog_new (GTK_WINDOW (window->priv->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Invalid format"); gtk_window_set_title (GTK_WINDOW (dialog_error), "Error"); g_signal_connect_swapped (dialog_error, "response", G_CALLBACK (gtk_widget_destroy), dialog_error); gtk_widget_show(dialog_error); } g_free (filename); g_free (down_filename); } gtk_widget_destroy (dialog); }
static void open_cb (GSimpleAction *action, GVariant *parameter, gpointer app) { GtkWidget *dialog; GtkWindow *win; const char *home_path; GFile *home; GtkFileFilter *filter_audio; GtkFileFilter *filter_all; gchar *uri = NULL; win = gtk_application_get_active_window (app); dialog = gtk_file_chooser_dialog_new ( _("Open Audio File"), win, GTK_FILE_CHOOSER_ACTION_OPEN, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Open"), GTK_RESPONSE_ACCEPT, NULL); /* Set current folder to user's home directory */ home_path = g_get_home_dir (); home = g_file_new_for_path (home_path); gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (dialog), home, NULL); filter_audio = gtk_file_filter_new (); filter_all = gtk_file_filter_new (); gtk_file_filter_set_name (filter_audio, _("Audio files")); gtk_file_filter_set_name (filter_all, _("All files")); gtk_file_filter_add_mime_type (filter_audio, "audio/*"); gtk_file_filter_add_pattern (filter_all, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_audio); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter_all); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter_audio); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog)); } g_object_unref (home); gtk_widget_destroy (dialog); if (uri) { pt_window_open_file (PT_WINDOW (win), uri); g_free (uri); } }
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); }
int clip_GTK_FILEFILTERADDMIMETYPE(ClipMachine * cm) { C_object *cfilter = _fetch_co_arg(cm); gchar *type = _clip_parc(cm, 2); CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object)); CHECKARG(2, CHARACTER_t); gtk_file_filter_add_mime_type(GTK_FILE_FILTER(cfilter->object), type); return 0; err: return 1; }
void file_chooser_dialog_add_writable_pixbuf_formats (GtkFileChooser *chooser) { GSList *pixbuf_formats = NULL; GSList *iter; GtkFileFilter *filter; int i; filter = gtk_file_filter_new(); gtk_file_filter_set_name (filter, _("By extension")); g_object_set_data (G_OBJECT(filter), "pixbuf-format", NULL); gtk_file_chooser_add_filter (chooser, filter); pixbuf_formats = gdk_pixbuf_get_formats (); for (iter = pixbuf_formats; iter; iter = iter->next) { GdkPixbufFormat *format = iter->data; gchar *description, *name, *extensions; gchar **extension_list, **mime_types; if (gdk_pixbuf_format_is_disabled (format) || !gdk_pixbuf_format_is_writable (format)) continue; name = gdk_pixbuf_format_get_description (format); extension_list = gdk_pixbuf_format_get_extensions (format); extensions = g_strjoinv (", ", extension_list); g_strfreev (extension_list); description = g_strdup_printf ("%s (%s)", name, extensions); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, description); g_object_set_data (G_OBJECT (filter), "pixbuf-format", format); gtk_file_chooser_add_filter (chooser, filter); g_free (description); g_free (extensions); g_free (name); mime_types = gdk_pixbuf_format_get_mime_types (format); for (i = 0; mime_types[i] != 0; i++) gtk_file_filter_add_mime_type (filter, mime_types[i]); g_strfreev (mime_types); } g_slist_free (pixbuf_formats); }
void gdb_on_printer_add (GtkButton *button, gpointer user_data) { PreferenceDialog *dlg = (PreferenceDialog *)user_data; GtkWidget *chooser; GtkFileFilter *filter; chooser = gtk_file_chooser_dialog_new (_("Select a pretty printer file"), GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (button))), 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_mime_type (filter, "text/x-python"); gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (chooser), TRUE); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser),filter); if (gtk_dialog_run (GTK_DIALOG (chooser)) == GTK_RESPONSE_ACCEPT) { GSList *filenames; GSList *item; filenames = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (chooser)); for (item = filenames; item != NULL; item = g_slist_next (item)) { GtkTreeIter iter; gchar *path = (gchar *)item->data; gchar *function; function = gdb_find_register_function (path); gtk_list_store_append (dlg->model, &iter); gtk_list_store_set (dlg->model, &iter, GDB_PP_ACTIVE_COLUMN, TRUE, GDB_PP_FILENAME_COLUMN, path, GDB_PP_REGISTER_COLUMN, function, -1); g_free (path); g_free (function); gdb_check_register_function (dlg, &iter); } g_slist_free (filenames); } gtk_widget_destroy (chooser); }
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); }