static void append_basic_info (NemoImagePropertiesPage *page) { GdkPixbufFormat *format; char *name; char *desc; char *value; format = gdk_pixbuf_loader_get_format (page->details->loader); name = gdk_pixbuf_format_get_name (format); desc = gdk_pixbuf_format_get_description (format); value = g_strdup_printf ("%s (%s)", name, desc); g_free (name); g_free (desc); append_item (page, _("Image Type"), value); g_free (value); value = g_strdup_printf (ngettext ("%d pixel", "%d pixels", page->details->width), page->details->width); append_item (page, _("Width"), value); g_free (value); value = g_strdup_printf (ngettext ("%d pixel", "%d pixels", page->details->height), page->details->height); append_item (page, _("Height"), value); g_free (value); }
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); }
static void go_image_build_pixbuf_format_infos (void) { #ifdef GOFFICE_WITH_GTK GdkPixbufFormat *fmt; GSList *l, *pixbuf_fmts; GOImageFormatInfo *format_info; gchar **exts; unsigned i; if (pixbuf_format_done) return; pixbuf_fmts = gdk_pixbuf_get_formats (); pixbuf_format_nbr = g_slist_length (pixbuf_fmts); if (pixbuf_format_nbr > 0) { pixbuf_image_format_infos = g_new (GOImageFormatInfo, pixbuf_format_nbr); for (l = pixbuf_fmts, i = 1, format_info = pixbuf_image_format_infos; l != NULL; l = l->next, i++, format_info++) { fmt = (GdkPixbufFormat *)l->data; format_info->format = GO_IMAGE_FORMAT_UNKNOWN + i; format_info->name = gdk_pixbuf_format_get_name (fmt); format_info->desc = gdk_pixbuf_format_get_description (fmt); exts = gdk_pixbuf_format_get_extensions (fmt); format_info->ext = g_strdup (exts[0]); if (format_info->ext == NULL) format_info->ext = format_info->name; g_strfreev (exts); format_info->has_pixbuf_saver = gdk_pixbuf_format_is_writable (fmt); format_info->is_dpi_useful = FALSE; format_info->alpha_support = FALSE; } } g_slist_free (pixbuf_fmts); #endif /* GOFFICE_WITH_GTK */ pixbuf_format_done = TRUE; }
static void sanity_check(const gchar *filename) { GdkPixbufLoader *loader; GSList *formats, *l; GError *err = NULL; GdkPixbuf *pixbuf; gchar *buf = NULL; gsize size; FILE *fh; gboolean ok, fileok = TRUE; g_printerr("Performing sanity check for %s.\n", filename); fileok &= ok = g_file_test(filename, G_FILE_TEST_EXISTS); g_printerr("Does it exist: %s\n", ok ? "YES" : "NO"); fileok &= ok = g_file_test(filename, G_FILE_TEST_IS_REGULAR); g_printerr("Is it a regular file: %s\n", ok ? "YES" : "NO"); fh = fopen(filename, "rb"); fileok &= ok = !!fh; g_printerr("Can we open it for reading: %s\n", ok ? "YES" : "NO"); if (fh) fclose(fh); else g_printerr("fopen() fails with: %s\n", g_strerror(errno)); fileok &= ok = g_file_get_contents(filename, &buf, &size, &err); g_printerr("Can we use g_file_get_contents(): %s\n", ok ? "YES" : "NO"); if (!ok) { g_printerr("g_file_get_contents() fails with: %s\n", err->message); g_clear_error(&err); } if (!fileok) { if (buf) g_free(buf); g_printerr("The file does not seem OK. No point continuing.\n"); return; } g_printerr("The file seems OK, continuing checks.\n"); pixbuf = gdk_pixbuf_new_from_file(filename, &err); if (pixbuf) { g_printerr("Apparently we can load the pixbuf (%dx%d) now?!\n", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf)); g_printerr("What has changed?\n"); g_printerr("This is completely f****d up.\n"); g_object_unref(pixbuf); } else { g_printerr("gdk_pixbuf_new_from_file() fails with: %s\n", err->message); g_clear_error(&err); } g_printerr("Checking the pixbuf loaders.\n"); formats = gdk_pixbuf_get_formats(); for (l = formats; l; l = g_slist_next(l)) { GdkPixbufFormat *pixbuf_format = (GdkPixbufFormat*)l->data; gchar **ext; gchar *fmtname, *desc, *exts; fmtname = gdk_pixbuf_format_get_name(pixbuf_format); desc = gdk_pixbuf_format_get_description(pixbuf_format); ext = gdk_pixbuf_format_get_extensions(pixbuf_format); exts = g_strjoinv(" ", ext); g_printerr("Found format %s: %s (%s)\n", fmtname, desc, exts); g_free(exts); g_strfreev(ext); g_free(desc); format_check(pixbuf_format, buf, size); loader = gdk_pixbuf_loader_new_with_type(fmtname, &err); if (!loader) { g_printerr(" Cannot create loader for %s: %s\n", fmtname, err->message); g_clear_error(&err); g_free(fmtname); continue; } ok = gdk_pixbuf_loader_write(loader, buf, size, &err); if (ok) { g_printerr(" Loader %s accepts the file content.\n", fmtname); ok = gdk_pixbuf_loader_close(loader, &err); if (ok) { g_printerr(" Loader %s accepts the entire file.\n", fmtname); pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); if (pixbuf) { g_printerr(" Obtained pixbuf %dx%d from the loader.\n", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf)); } else { g_printerr(" Cannot obtain pixbuf from the loader.\n"); } } else { g_printerr(" Loader %s fails at close(): %s.\n", fmtname, err->message); g_clear_error(&err); } } else { g_printerr(" Loader %s does not accept the file content: %s\n", fmtname, err->message); g_clear_error(&err); } g_object_unref(loader); g_free(fmtname); } g_slist_free(formats); }
static void load_finished (CajaImagePropertiesPage *page) { GdkPixbufFormat *format; char *name, *desc; gtk_widget_destroy (page->details->loading_label); if (page->details->loader != NULL) { gdk_pixbuf_loader_close (page->details->loader, NULL); } if (page->details->got_size) { #ifdef HAVE_EXIF ExifData *exif_data; #endif /*HAVE_EXIF*/ format = gdk_pixbuf_loader_get_format (page->details->loader); name = gdk_pixbuf_format_get_name (format); desc = gdk_pixbuf_format_get_description (format); append_label_take_str (page->details->vbox, g_strdup_printf ("<b>%s</b> %s (%s)", _("Image Type:"), name, desc)); append_label_take_str (page->details->vbox, g_strdup_printf (ngettext ("<b>Width:</b> %d pixel", "<b>Width:</b> %d pixels", page->details->width), page->details->width)); append_label_take_str (page->details->vbox, g_strdup_printf (ngettext ("<b>Height:</b> %d pixel", "<b>Height:</b> %d pixels", page->details->height), page->details->height)); g_free (name); g_free (desc); #ifdef HAVE_EXIF exif_data = exif_loader_get_data (page->details->exifldr); append_exifdata_string (exif_data, page); exif_data_unref (exif_data); #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI append_xmpdata_string (page->details->xmp, page); #endif /*HAVE_EXEMPI*/ } else { append_label (page->details->vbox, _("Failed to load image information")); } if (page->details->loader != NULL) { g_object_unref (page->details->loader); page->details->loader = NULL; } #ifdef HAVE_EXIF if (page->details->exifldr != NULL) { exif_loader_unref (page->details->exifldr); page->details->exifldr = NULL; } #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI if (page->details->xmp != NULL) { xmp_free(page->details->xmp); page->details->xmp = NULL; } #endif /*HAVE_EXEMPI*/ }
void GdkpixbufInput::init(void) { GSList * formatlist, * formatlisthead; /* \todo I'm not sure if I need to free this list */ for (formatlist = formatlisthead = gdk_pixbuf_get_formats(); formatlist != NULL; formatlist = g_slist_next(formatlist)) { GdkPixbufFormat *pixformat = (GdkPixbufFormat *)formatlist->data; gchar *name = gdk_pixbuf_format_get_name(pixformat); gchar *description = gdk_pixbuf_format_get_description(pixformat); gchar **extensions = gdk_pixbuf_format_get_extensions(pixformat); gchar **mimetypes = gdk_pixbuf_format_get_mime_types(pixformat); for (int i = 0; extensions[i] != NULL; i++) { for (int j = 0; mimetypes[j] != NULL; j++) { /* thanks but no thanks, we'll handle SVG extensions... */ if (strcmp(extensions[i], "svg") == 0) { continue; } if (strcmp(extensions[i], "svgz") == 0) { continue; } if (strcmp(extensions[i], "svg.gz") == 0) { continue; } gchar *caption = g_strdup_printf(_("%s bitmap image import"), name); gchar *xmlString = g_strdup_printf( "<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n" "<name>%s</name>\n" "<id>org.inkscape.input.gdkpixbuf.%s</id>\n" "<param name='link' type='optiongroup' appearance='full' _gui-text='" N_("Image Import Type:") "' _gui-description='" N_("Embed results in stand-alone, larger SVG files. Link references a file outside this SVG document and all files must be moved together.") "' >\n" "<_option value='embed' >" N_("Embed") "</_option>\n" "<_option value='link' >" N_("Link") "</_option>\n" "</param>\n" "<param name='dpi' type='optiongroup' appearance='full' _gui-text='" N_("Image DPI:") "' _gui-description='" N_("Take information from file or use default bitmap import resolution as defined in the preferences.") "' >\n" "<_option value='from_file' >" N_("From file") "</_option>\n" "<_option value='from_default' >" N_("Default import resolution") "</_option>\n" "</param>\n" "<param name='scale' type='optiongroup' appearance='full' _gui-text='" N_("Image Rendering Mode:") "' _gui-description='" N_("When an image is upscaled, apply smoothing or keep blocky (pixelated). (Will not work in all browsers.)") "' >\n" "<_option value='auto' >" N_("None (auto)") "</_option>\n" "<_option value='optimizeQuality' >" N_("Smooth (optimizeQuality)") "</_option>\n" "<_option value='optimizeSpeed' >" N_("Blocky (optimizeSpeed)") "</_option>\n" "</param>\n" "<param name=\"do_not_ask\" _gui-description='" N_("Hide the dialog next time and always apply the same actions.") "' gui-text=\"" N_("Don't ask again") "\" type=\"boolean\" >false</param>\n" "<input>\n" "<extension>.%s</extension>\n" "<mimetype>%s</mimetype>\n" "<filetypename>%s (*.%s)</filetypename>\n" "<filetypetooltip>%s</filetypetooltip>\n" "</input>\n" "</inkscape-extension>", caption, extensions[i], extensions[i], mimetypes[j], name, extensions[i], description ); Inkscape::Extension::build_from_mem(xmlString, new GdkpixbufInput()); g_free(xmlString); g_free(caption); } } g_free(name); g_free(description); g_strfreev(mimetypes); g_strfreev(extensions); } g_slist_free(formatlisthead); }
void filter_add_defaults(void) { GSList *list, *work; list = gdk_pixbuf_get_formats(); work = list; while (work) { GdkPixbufFormat *format; gchar *name; gchar *desc; gchar **extensions; GString *filter = NULL; gint i; format = work->data; work = work->next; name = gdk_pixbuf_format_get_name(format); desc = gdk_pixbuf_format_get_description(format); extensions = gdk_pixbuf_format_get_extensions(format); i = 0; while (extensions[i]) { if (!filter) { filter = g_string_new("."); filter = g_string_append(filter, extensions[i]); } else { filter = g_string_append(filter, ";."); filter = g_string_append(filter, extensions[i]); } i++; } if (debug) printf("loader reported [%s] [%s] [%s]\n", name, desc, filter->str); filter_add_if_missing(name, desc, filter->str, TRUE); g_free(name); g_free(desc); g_strfreev(extensions); g_string_free(filter, TRUE); } g_slist_free(list); /* add defaults even if gdk-pixbuf does not have them, but disabled */ filter_add_if_missing("jpeg", "JPEG group", ".jpg;.jpeg;.jpe", FALSE); filter_add_if_missing("png", "Portable Network Graphic", ".png", FALSE); filter_add_if_missing("tiff", "Tiff", ".tif;.tiff", FALSE); filter_add_if_missing("pnm", "Packed Pixel formats", ".pbm;.pgm;.pnm;.ppm", FALSE); filter_add_if_missing("gif", "Graphics Interchange Format", ".gif", FALSE); filter_add_if_missing("xbm", "X bitmap", ".xbm", FALSE); filter_add_if_missing("xpm", "X pixmap", ".xpm", FALSE); filter_add_if_missing("bmp", "Bitmap", ".bmp", FALSE); filter_add_if_missing("ico", "Icon file", ".ico;.cur", FALSE); filter_add_if_missing("ras", "Raster", ".ras", FALSE); filter_add_if_missing("svg", "Scalable Vector Graphics", ".svg", FALSE); /* These are the raw camera formats with embedded jpeg/exif. * (see format_raw.c) */ filter_add_if_missing("crw", "Canon raw format", ".crw;.cr2", TRUE); filter_add_if_missing("raf", "Fujifilm raw format", ".raf", TRUE); filter_add_if_missing("nef", "Nikon raw format", ".nef", TRUE); filter_add_if_missing("orf", "Olympus raw format", ".orf", TRUE); filter_add_if_missing("pef", "Pentax raw format", ".pef", TRUE); }
static VALUE rg_description(VALUE self) { return CSTR2RVAL_FREE(gdk_pixbuf_format_get_description(_SELF(self))); }
static void gth_metadata_provider_image_read (GthMetadataProvider *self, GthFileData *file_data, const char *attributes, GCancellable *cancellable) { gboolean format_recognized; GFileInputStream *stream; char *description = NULL; int width; int height; const char *mime_type = NULL; format_recognized = FALSE; stream = g_file_read (file_data->file, cancellable, NULL); if (stream != NULL) { int buffer_size; guchar *buffer; gssize size; buffer_size = BUFFER_SIZE; buffer = g_new (guchar, buffer_size); size = g_input_stream_read (G_INPUT_STREAM (stream), buffer, buffer_size, cancellable, NULL); if (size >= 0) { if ((size >= 24) /* PNG signature */ && (buffer[0] == 0x89) && (buffer[1] == 0x50) && (buffer[2] == 0x4E) && (buffer[3] == 0x47) && (buffer[4] == 0x0D) && (buffer[5] == 0x0A) && (buffer[6] == 0x1A) && (buffer[7] == 0x0A) /* IHDR Image header */ && (buffer[12] == 0x49) && (buffer[13] == 0x48) && (buffer[14] == 0x44) && (buffer[15] == 0x52)) { /* PNG */ width = (buffer[16] << 24) + (buffer[17] << 16) + (buffer[18] << 8) + buffer[19]; height = (buffer[20] << 24) + (buffer[21] << 16) + (buffer[22] << 8) + buffer[23]; description = _("PNG"); mime_type = "image/png"; format_recognized = TRUE; } #if HAVE_LIBJPEG else if ((size >= 4) && (buffer[0] == 0xff) && (buffer[1] == 0xd8) && (buffer[2] == 0xff)) { /* JPEG */ GthTransform orientation; if (g_seekable_can_seek (G_SEEKABLE (stream))) { g_seekable_seek (G_SEEKABLE (stream), 0, G_SEEK_SET, cancellable, NULL); } else { g_object_unref (stream); stream = g_file_read (file_data->file, cancellable, NULL); } if (_jpeg_get_image_info (G_INPUT_STREAM (stream), &width, &height, &orientation, cancellable, NULL)) { description = _("JPEG"); mime_type = "image/jpeg"; format_recognized = TRUE; if ((orientation == GTH_TRANSFORM_ROTATE_90) || (orientation == GTH_TRANSFORM_ROTATE_270) || (orientation == GTH_TRANSFORM_TRANSPOSE) || (orientation == GTH_TRANSFORM_TRANSVERSE)) { int tmp = width; width = height; height = tmp; } } } #endif /* HAVE_LIBJPEG */ #if HAVE_LIBWEBP else if ((size > 15) && (memcmp (buffer + 8, "WEBPVP8", 7) == 0)) { WebPDecoderConfig config; if (WebPInitDecoderConfig (&config)) { if (WebPGetFeatures (buffer, buffer_size, &config.input) == VP8_STATUS_OK) { width = config.input.width; height = config.input.height; description = _("WebP"); mime_type = "image/webp"; format_recognized = TRUE; } WebPFreeDecBuffer (&config.output); } } #endif /* HAVE_LIBWEBP */ else if ((size >= 26) && (strncmp ((char *) buffer, "gimp xcf ", 9) == 0)) { /* XCF */ GInputStream *mem_stream; GDataInputStream *data_stream; mem_stream = g_memory_input_stream_new_from_data (buffer, BUFFER_SIZE, NULL); data_stream = g_data_input_stream_new (mem_stream); g_data_input_stream_set_byte_order (data_stream, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN); if (g_seekable_seek (G_SEEKABLE (data_stream), 14, G_SEEK_SET, NULL, NULL)) { int base_type; width = g_data_input_stream_read_uint32 (data_stream, NULL, NULL); height = g_data_input_stream_read_uint32 (data_stream, NULL, NULL); base_type = g_data_input_stream_read_uint32 (data_stream, NULL, NULL); if (base_type == 0) description = "XCF RGB"; else if (base_type == 1) description = "XCF grayscale"; else if (base_type == 2) description = "XCF indexed"; else description = "XCF"; mime_type = "image/x-xcf"; format_recognized = TRUE; } g_object_unref (data_stream); g_object_unref (mem_stream); } } g_free (buffer); g_object_unref (stream); } if (! format_recognized) { /* use gdk_pixbuf_get_file_info */ char *filename; filename = g_file_get_path (file_data->file); if (filename != NULL) { GdkPixbufFormat *format; format = gdk_pixbuf_get_file_info (filename, &width, &height); if (format != NULL) { format_recognized = TRUE; description = gdk_pixbuf_format_get_description (format); } g_free (filename); } } if (format_recognized) { char *size; g_file_info_set_attribute_string (file_data->info, "general::format", description); g_file_info_set_attribute_int32 (file_data->info, "image::width", width); g_file_info_set_attribute_int32 (file_data->info, "image::height", height); g_file_info_set_attribute_int32 (file_data->info, "frame::width", width); g_file_info_set_attribute_int32 (file_data->info, "frame::height", height); if (mime_type != NULL) gth_file_data_set_mime_type (file_data, mime_type); size = g_strdup_printf (_("%d × %d"), width, height); g_file_info_set_attribute_string (file_data->info, "general::dimensions", size); g_free (size); } }
char* get_save_filename( GtkWindow* parent, const char* cwd, char** type ) { char* file = NULL; GtkFileChooser* dlg = (GtkFileChooser*)gtk_file_chooser_dialog_new( NULL, parent, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL ); GSList* modules, *module; GtkFileFilter *filter; gtk_file_chooser_set_current_folder( dlg, cwd ); GtkWidget* img = gtk_image_new(); gtk_widget_set_size_request( img, 128, 128 ); gtk_file_chooser_set_preview_widget( dlg, img ); g_signal_connect( dlg, "update-preview", G_CALLBACK(on_update_preview), img ); g_signal_connect( dlg, "notify::filter", G_CALLBACK(on_file_save_filter_changed), NULL ); /* /// TODO: determine file type from file name filter = gtk_file_filter_new(); gtk_file_filter_set_name( filter, _("Determined by File Name") ); gtk_file_filter_add_pixbuf_formats( filter ); gtk_file_chooser_add_filter( dlg, filter ); */ modules = gdk_pixbuf_get_formats(); for( module = modules; module; module = module->next ) { char *name, *desc, *tmp; char **exts, **mimes, **mime; GdkPixbufFormat* format = (GdkPixbufFormat*)module->data; if( ! gdk_pixbuf_format_is_writable( format ) ) continue; filter = gtk_file_filter_new(); name = gdk_pixbuf_format_get_name( format ); desc = gdk_pixbuf_format_get_description( format ); exts = gdk_pixbuf_format_get_extensions( format ); mimes = gdk_pixbuf_format_get_mime_types( format ); tmp = g_strdup_printf( "%s (*.%s)", desc, exts[0], NULL ); g_object_set_data_full(G_OBJECT(filter), "type", name, (GDestroyNotify)g_free); g_strfreev(exts); g_free( desc ); gtk_file_filter_set_name( filter, tmp ); g_free( tmp ); for( mime = mimes; *mime ; ++mime ) gtk_file_filter_add_mime_type( filter, *mime ); g_strfreev( mimes ); gtk_file_chooser_add_filter( dlg, filter ); } g_slist_free( modules ); int initial_jpg_quality = pref.jpg_quality; int initial_png_compression = pref.png_compression; if( gtk_dialog_run( (GtkDialog*)dlg ) == GTK_RESPONSE_OK ) { filter = gtk_file_chooser_get_filter( dlg ); file = gtk_file_chooser_get_filename( dlg ); *type = g_object_steal_data(G_OBJECT(filter), "type"); if( !*type ) // auto detection { /// TODO: auto file type } else { /* TODO: append appropriate extension if needed. */ } } gtk_widget_destroy( (GtkWidget*)dlg ); if ((initial_jpg_quality != pref.jpg_quality) || (initial_png_compression != pref.png_compression)) save_preferences(); return file; }
static void append_xmp_value_pair (GString *string, XmpPtr xmp, const char *ns, const char *propname, char *descr) { uint32_t options; XmpStringPtr value; value = xmp_string_new(); #ifdef HAVE_EXEMPI_NEW_API if (xmp_get_property (xmp, ns, propname, value, &options)) { #else if (xmp_get_property_and_bits (xmp, ns, propname, value, &options)) { #endif if (XMP_IS_PROP_SIMPLE (options)) { g_string_append_printf (string, "<b>%s:</b> %s\n", descr, xmp_string_cstr (value)); } else if (XMP_IS_PROP_ARRAY (options)) { XmpIteratorPtr iter; iter = xmp_iterator_new (xmp, ns, propname, XMP_ITER_JUSTLEAFNODES); if (iter) { gboolean first = TRUE; g_string_append_printf (string, "<b>%s:</b> ", descr); while (xmp_iterator_next (iter, NULL, NULL, value, &options) && !XMP_IS_PROP_QUALIFIER(options)) { if (!first) { g_string_append_printf (string, ", "); } else { first = FALSE; } g_string_append_printf (string, "%s", xmp_string_cstr(value)); } xmp_iterator_free(iter); g_string_append_printf(string, "\n"); } } } xmp_string_free(value); } static void append_xmpdata_string(XmpPtr xmp, GString *string) { if(xmp != NULL) { append_xmp_value_pair(string, xmp, NS_IPTC4XMP, "Location", _("Location")); append_xmp_value_pair(string, xmp, NS_DC, "description", _("Description")); append_xmp_value_pair(string, xmp, NS_DC, "subject", _("Keywords")); append_xmp_value_pair(string, xmp, NS_DC, "creator", _("Creator")); append_xmp_value_pair(string, xmp, NS_DC, "rights", _("Copyright")); append_xmp_value_pair(string, xmp, NS_XAP,"Rating", _("Rating")); /* TODO add CC licenses */ } } #endif static void load_finished (NautilusImagePropertiesPage *page) { GdkPixbufFormat *format; char *name, *desc; GString *str; if (page->details->got_size) { #ifdef HAVE_EXIF ExifData *exif_data; #endif str = g_string_new (NULL); format = gdk_pixbuf_loader_get_format (page->details->loader); name = gdk_pixbuf_format_get_name (format); desc = gdk_pixbuf_format_get_description (format); g_string_append_printf (str, "<b>%s</b> %s (%s)\n", _("Image Type:"), name, desc); g_string_append_printf (str, ngettext ("<b>Width:</b> %d pixel\n", "<b>Width:</b> %d pixels\n", page->details->width), page->details->width); g_string_append_printf (str, ngettext ("<b>Height:</b> %d pixel\n", "<b>Height:</b> %d pixels\n", page->details->height), page->details->height); g_free (name); g_free (desc); #ifdef HAVE_EXIF exif_data = exif_loader_get_data (page->details->exifldr); append_exifdata_string (exif_data, str); exif_data_unref (exif_data); #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI append_xmpdata_string(page->details->xmp, str); #endif /*HAVE EXEMPI*/ gtk_label_set_markup (GTK_LABEL (page->details->resolution), str->str); gtk_label_set_selectable (GTK_LABEL (page->details->resolution), TRUE); g_string_free (str, TRUE); } else { gtk_label_set_text (GTK_LABEL (page->details->resolution), _("Failed to load image information")); } if (page->details->loader != NULL) { gdk_pixbuf_loader_close (page->details->loader, NULL); g_object_unref (page->details->loader); page->details->loader = NULL; } #ifdef HAVE_EXIF if (page->details->exifldr != NULL) { exif_loader_unref (page->details->exifldr); page->details->exifldr = NULL; } #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI if (page->details->xmp != NULL) { xmp_free(page->details->xmp); page->details->xmp = NULL; } #endif }