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);
}
GdkPixbuf *
tpaw_pixbuf_from_data_and_mime (gchar *data,
gsize data_size,
gchar **mime_type)
{
GdkPixbufLoader *loader;
GdkPixbufFormat *format;
GdkPixbuf *pixbuf = NULL;
gchar **mime_types;
GError *error = NULL;
if (!data)
return NULL;
loader = gdk_pixbuf_loader_new ();
if (!gdk_pixbuf_loader_write (loader, (guchar *) data, data_size, &error))
{
DEBUG ("Failed to write to pixbuf loader: %s",
error ? error->message : "No error given");
goto out;
}
if (!gdk_pixbuf_loader_close (loader, &error))
{
DEBUG ("Failed to close pixbuf loader: %s",
error ? error->message : "No error given");
goto out;
}
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (pixbuf)
{
g_object_ref (pixbuf);
if (mime_type != NULL)
{
format = gdk_pixbuf_loader_get_format (loader);
mime_types = gdk_pixbuf_format_get_mime_types (format);
*mime_type = g_strdup (*mime_types);
if (mime_types[1] != NULL)
DEBUG ("Loader supports more than one mime "
"type! Picking the first one, %s",
*mime_type);
g_strfreev (mime_types);
}
}
out:
g_clear_error (&error);
g_object_unref (loader);
return pixbuf;
}
static void
soi_info_cb (GdkPixbufLoader *loader,
int width,
int height,
gpointer data)
{
SheetObjectImage *soi = SHEET_OBJECT_IMAGE (data);
GdkPixbufFormat *format = gdk_pixbuf_loader_get_format (loader);
char *name = gdk_pixbuf_format_get_name (format);
g_free (soi->type);
soi->type = name;
}
/** Convert Base64 to pixbuf
* @param b64 Base64 encoded data
*/
GdkPixbuf *
pixbuf_decode_base64 (const gchar *b64)
{
/* see lib/prop_pixbuf.c(data_pixbuf) for a very similar implementation */
GdkPixbuf *pixbuf = NULL;
GdkPixbufLoader *loader;
GError *error = NULL;
loader = gdk_pixbuf_loader_new ();
if (loader) {
gint state = 0;
guint save = 0;
# define BUF_SIZE 4096
guchar buf[BUF_SIZE];
gchar *in = (gchar *)b64; /* direct access, not involving another xmlStrDup/xmlFree */
gssize len = strlen (b64);
do {
gsize step = g_base64_decode_step (in,
len > BUF_SIZE ? BUF_SIZE : len,
buf, &state, &save);
if (!gdk_pixbuf_loader_write (loader, buf, step, &error))
break;
in += BUF_SIZE;
len -= BUF_SIZE;
} while (len > 0);
if (gdk_pixbuf_loader_close (loader, error ? NULL : &error)) {
GdkPixbufFormat *format = gdk_pixbuf_loader_get_format (loader);
gchar *format_name = gdk_pixbuf_format_get_name (format);
gchar **mime_types = gdk_pixbuf_format_get_mime_types (format);
dia_log_message ("Loaded pixbuf from '%s' with '%s'\n", format_name, mime_types[0]);
pixbuf = g_object_ref (gdk_pixbuf_loader_get_pixbuf (loader));
/* attach the mime-type to the pixbuf */
g_object_set_data_full (G_OBJECT (pixbuf), "mime-type",
g_strdup (mime_types[0]),
(GDestroyNotify)g_free);
g_strfreev (mime_types);
g_free (format_name);
} else {
message_warning (_("Failed to load image form diagram:\n%s"), error->message);
g_error_free (error);
}
g_object_unref (loader);
}
return pixbuf;
# undef BUF_SIZE
}
Pixbuf *Pixbuf::create_from_file(std::string const &fn)
{
Pixbuf *pb = NULL;
// test correctness of filename
if (!g_file_test(fn.c_str(), G_FILE_TEST_EXISTS)) {
return NULL;
}
struct stat stdir;
int val = g_stat(fn.c_str(), &stdir);
if (val == 0 && stdir.st_mode & S_IFDIR){
return NULL;
}
// we need to load the entire file into memory,
// since we'll store it as MIME data
gchar *data = NULL;
gsize len = 0;
GError *error;
if (g_file_get_contents(fn.c_str(), &data, &len, &error)) {
GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
gdk_pixbuf_loader_write(loader, (guchar *) data, len, NULL);
gdk_pixbuf_loader_close(loader, NULL);
GdkPixbuf *buf = gdk_pixbuf_loader_get_pixbuf(loader);
if (buf) {
g_object_ref(buf);
pb = new Pixbuf(buf);
pb->_mod_time = stdir.st_mtime;
pb->_path = fn;
GdkPixbufFormat *fmt = gdk_pixbuf_loader_get_format(loader);
gchar *fmt_name = gdk_pixbuf_format_get_name(fmt);
pb->_setMimeData((guchar *) data, len, fmt_name);
g_free(fmt_name);
} else {
g_free(data);
}
g_object_unref(loader);
// TODO: we could also read DPI, ICC profile, gamma correction, and other information
// from the file. This can be done by using format-specific libraries e.g. libpng.
} else {
return NULL;
}
return pb;
}
static void
gst_gdk_pixbuf_type_find (GstTypeFind * tf, gpointer ignore)
{
guint8 *data;
GdkPixbufLoader *pixbuf_loader;
GdkPixbufFormat *format;
data = gst_type_find_peek (tf, 0, GST_GDK_PIXBUF_TYPE_FIND_SIZE);
if (data == NULL)
return;
GST_DEBUG ("creating new loader");
pixbuf_loader = gdk_pixbuf_loader_new ();
gdk_pixbuf_loader_write (pixbuf_loader, data, GST_GDK_PIXBUF_TYPE_FIND_SIZE,
NULL);
format = gdk_pixbuf_loader_get_format (pixbuf_loader);
if (format != NULL) {
GstCaps *caps;
gchar **p;
gchar **mlist = gdk_pixbuf_format_get_mime_types (format);
for (p = mlist; *p; ++p) {
GST_DEBUG ("suggesting mime type %s", *p);
caps = gst_caps_new_simple (*p, NULL);
gst_type_find_suggest (tf, GST_TYPE_FIND_MINIMUM, caps);
gst_caps_free (caps);
}
g_strfreev (mlist);
}
GST_DEBUG ("closing pixbuf loader, hope it doesn't hang ...");
/* librsvg 2.4.x has a bug where it triggers an endless loop in trying
to close a gzip that's not an svg; fixed upstream but no good way
to work around it */
gdk_pixbuf_loader_close (pixbuf_loader, NULL);
GST_DEBUG ("closed pixbuf loader");
g_object_unref (G_OBJECT (pixbuf_loader));
}
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*/
}
GdkPixbuf * IE_ImpGraphic_GdkPixbuf::pixbufForByteBuf (UT_ByteBuf * pBB,
std::string & mimetype)
{
if ( !pBB || !pBB->getLength() )
return NULL;
GdkPixbuf * pixbuf = NULL;
bool bIsXPM = false;
const char * szBuf = reinterpret_cast<const char *>(pBB->getPointer(0));
if((pBB->getLength() > 9) && (strncmp (szBuf, "/* XPM */", 9) == 0))
{
bIsXPM = true;
}
if(bIsXPM)
{
pixbuf = _loadXPM(pBB);
}
else
{
GError * err = 0;
GdkPixbufLoader * ldr = 0;
ldr = gdk_pixbuf_loader_new ();
if (!ldr)
{
UT_DEBUGMSG (("GdkPixbuf: couldn't create loader! WTF?\n"));
UT_ASSERT (ldr);
return NULL ;
}
if (!gdk_pixbuf_loader_write (ldr, static_cast<const guchar *>(pBB->getPointer (0)),
static_cast<gsize>(pBB->getLength ()), &err) )
{
UT_DEBUGMSG(("DOM: couldn't write to loader: %s\n", err->message));
g_error_free(err);
gdk_pixbuf_loader_close (ldr, NULL);
g_object_unref (G_OBJECT(ldr));
mimetype.clear();
return NULL ;
}
gdk_pixbuf_loader_close (ldr, NULL);
pixbuf = gdk_pixbuf_loader_get_pixbuf (ldr);
GdkPixbufFormat * format = gdk_pixbuf_loader_get_format(ldr);
gchar ** mime_types = gdk_pixbuf_format_get_mime_types(format);
gchar ** current = mime_types;
while(*current) {
if((strcmp(*current, "image/jpeg") == 0)
|| (strcmp(*current, "image/png") == 0)) {
mimetype = *current;
break;
}
current++;
}
g_strfreev(mime_types);
// ref before closing the loader
if ( pixbuf )
g_object_ref (G_OBJECT(pixbuf));
g_object_unref (G_OBJECT(ldr));
}
return pixbuf;
}
cairo_surface_t *
rsvg_cairo_surface_new_from_href (RsvgHandle *handle,
const char *href,
GError **error)
{
char *data;
gsize data_len;
char *mime_type = NULL;
GdkPixbufLoader *loader = NULL;
GdkPixbuf *pixbuf = NULL;
cairo_surface_t *surface = NULL;
data = _rsvg_handle_acquire_data (handle, href, &mime_type, &data_len, error);
if (data == NULL)
return NULL;
if (mime_type) {
loader = gdk_pixbuf_loader_new_with_mime_type (mime_type, error);
} else {
loader = gdk_pixbuf_loader_new ();
}
if (loader == NULL)
goto out;
if (!gdk_pixbuf_loader_write (loader, (guchar *) data, data_len, error)) {
gdk_pixbuf_loader_close (loader, NULL);
goto out;
}
if (!gdk_pixbuf_loader_close (loader, error))
goto out;
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (!pixbuf) {
g_set_error (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_FAILED,
_("Failed to load image '%s': reason not known, probably a corrupt image file"),
href);
goto out;
}
surface = rsvg_cairo_surface_from_pixbuf (pixbuf);
if (mime_type == NULL) {
/* Try to get the information from the loader */
GdkPixbufFormat *format;
char **mime_types;
if ((format = gdk_pixbuf_loader_get_format (loader)) != NULL) {
mime_types = gdk_pixbuf_format_get_mime_types (format);
if (mime_types != NULL)
mime_type = g_strdup (mime_types[0]);
g_strfreev (mime_types);
}
}
if ((handle->priv->flags & RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA) != 0 &&
mime_type != NULL &&
cairo_surface_set_mime_data (surface, mime_type, (guchar *) data,
data_len, g_free, data) == CAIRO_STATUS_SUCCESS) {
data = NULL; /* transferred to the surface */
}
out:
if (loader)
g_object_unref (loader);
g_free (mime_type);
g_free (data);
return surface;
}
GdkPixbuf *
eventd_nd_pixbuf_from_data(GVariant *var, gint width, gint height)
{
GdkPixbuf *pixbuf = NULL;
GError *error = NULL;
const gchar *mime_type;
GVariant *invar;
g_variant_get(var, "(m&sm&sv)", &mime_type, NULL, &invar);
if ( g_strcmp0(mime_type, "image/x.eventd.pixbuf") == 0 )
{
gboolean a;
gint b, w, h, s, n;
GVariant *data;
g_variant_get(invar, "(iiibii@ay)", &w, &h, &s, &a, &b, &n, &data);
/* This is the only format gdk-pixbuf can read */
if ( ( b == 8 ) && ( n == ( a ? 4 : 3 ) ) && ( h * s == (gint) g_variant_get_size(data) ) )
return gdk_pixbuf_new_from_data(g_variant_get_data(data), GDK_COLORSPACE_RGB, a, b, w, h, s, _eventd_nd_pixbuf_free_data, data);
g_variant_unref(data);
goto end;
}
if ( ! g_variant_is_of_type(invar, G_VARIANT_TYPE_BYTESTRING) )
goto end;
GdkPixbufLoader *loader;
const guchar *data;
gsize length;
data = g_variant_get_data(invar);
length = g_variant_get_size(invar);
if ( mime_type != NULL )
{
loader = gdk_pixbuf_loader_new_with_mime_type(mime_type, &error);
if ( loader == NULL )
{
g_warning("Couldn't create loader for MIME type '%s': %s", mime_type, error->message);
goto end;
}
GdkPixbufFormat *format;
if ( ( ( width > 0 ) || ( height > 0 ) ) && ( ( format = gdk_pixbuf_loader_get_format(loader) ) != NULL ) && gdk_pixbuf_format_is_scalable(format) )
gdk_pixbuf_loader_set_size(loader, width, height);
}
else
loader = gdk_pixbuf_loader_new();
if ( ! gdk_pixbuf_loader_write(loader, data, length, &error) )
{
g_warning("Couldn't write image data: %s", error->message);
goto error;
}
if ( ! gdk_pixbuf_loader_close(loader, &error) )
{
g_warning("Couldn't load image data: %s", error->message);
goto error;
}
pixbuf = g_object_ref(gdk_pixbuf_loader_get_pixbuf(loader));
error:
g_object_unref(loader);
end:
g_variant_unref(invar);
g_variant_unref(var);
g_clear_error(&error);
return pixbuf;
}
static VALUE
loader_get_format(VALUE self)
{
GdkPixbufFormat* format = gdk_pixbuf_loader_get_format(_SELF(self));
return BOXED2RVAL(format, GDK_TYPE_PIXBUF_FORMAT);
}
static VALUE
rg_format(VALUE self)
{
GdkPixbufFormat* format = gdk_pixbuf_loader_get_format(_SELF(self));
return GDKPIXBUFFORMAT2RVAL(format);
}
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
}
Pixbuf *Pixbuf::create_from_data_uri(gchar const *uri_data)
{
Pixbuf *pixbuf = NULL;
bool data_is_image = false;
bool data_is_base64 = false;
gchar const *data = uri_data;
while (*data) {
if (strncmp(data,"base64",6) == 0) {
/* base64-encoding */
data_is_base64 = true;
data_is_image = true; // Illustrator produces embedded images without MIME type, so we assume it's image no matter what
data += 6;
}
else if (strncmp(data,"image/png",9) == 0) {
/* PNG image */
data_is_image = true;
data += 9;
}
else if (strncmp(data,"image/jpg",9) == 0) {
/* JPEG image */
data_is_image = true;
data += 9;
}
else if (strncmp(data,"image/jpeg",10) == 0) {
/* JPEG image */
data_is_image = true;
data += 10;
}
else if (strncmp(data,"image/jp2",9) == 0) {
/* JPEG2000 image */
data_is_image = true;
data += 9;
}
else { /* unrecognized option; skip it */
while (*data) {
if (((*data) == ';') || ((*data) == ',')) {
break;
}
data++;
}
}
if ((*data) == ';') {
data++;
continue;
}
if ((*data) == ',') {
data++;
break;
}
}
if ((*data) && data_is_image && data_is_base64) {
GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
if (!loader) return NULL;
gsize decoded_len = 0;
guchar *decoded = g_base64_decode(data, &decoded_len);
if (gdk_pixbuf_loader_write(loader, decoded, decoded_len, NULL)) {
gdk_pixbuf_loader_close(loader, NULL);
GdkPixbuf *buf = gdk_pixbuf_loader_get_pixbuf(loader);
if (buf) {
g_object_ref(buf);
pixbuf = new Pixbuf(buf);
GdkPixbufFormat *fmt = gdk_pixbuf_loader_get_format(loader);
gchar *fmt_name = gdk_pixbuf_format_get_name(fmt);
pixbuf->_setMimeData(decoded, decoded_len, fmt_name);
g_free(fmt_name);
} else {
g_free(decoded);
}
} else {
g_free(decoded);
}
g_object_unref(loader);
}
return pixbuf;
}
static void metadata_menuitem_on_fetcher_completed (MetadataMenuitem* self, GByteArray* update, const gchar* property) {
GError * _inner_error_ = NULL;
g_return_if_fail (self != NULL);
g_return_if_fail (update != NULL);
g_return_if_fail (property != NULL);
{
GdkPixbufLoader* _tmp0_;
GdkPixbufLoader* loader;
GdkPixbufLoader* _tmp1_;
GByteArray* _tmp2_;
guint8* _tmp3_;
gint _tmp3__length1;
GdkPixbufLoader* _tmp4_;
GdkPixbufLoader* _tmp5_;
GdkPixbuf* _tmp6_ = NULL;
GdkPixbuf* _tmp7_;
GdkPixbuf* icon;
const gchar* _tmp8_;
gchar* _tmp9_ = NULL;
gchar* path;
const gchar* _tmp10_;
gint _tmp11_ = 0;
gint r;
gint _tmp12_;
_tmp0_ = gdk_pixbuf_loader_new ();
loader = _tmp0_;
_tmp1_ = loader;
_tmp2_ = update;
_tmp3_ = _tmp2_->data;
_tmp3__length1 = (gint) _tmp2_->len;
gdk_pixbuf_loader_write (_tmp1_, _tmp3_, (gsize) _tmp3__length1, &_inner_error_);
if (_inner_error_ != NULL) {
_g_object_unref0 (loader);
goto __catch6_g_error;
}
_tmp4_ = loader;
gdk_pixbuf_loader_close (_tmp4_, &_inner_error_);
if (_inner_error_ != NULL) {
_g_object_unref0 (loader);
goto __catch6_g_error;
}
_tmp5_ = loader;
_tmp6_ = gdk_pixbuf_loader_get_pixbuf (_tmp5_);
_tmp7_ = _g_object_ref0 (_tmp6_);
icon = _tmp7_;
_tmp8_ = metadata_menuitem_album_art_cache_dir;
_tmp9_ = g_strconcat (_tmp8_, "/downloaded-coverart-XXXXXX", NULL);
path = _tmp9_;
_tmp10_ = path;
_tmp11_ = g_mkstemp (_tmp10_);
r = _tmp11_;
_tmp12_ = r;
if (_tmp12_ != (-1)) {
GdkPixbuf* _tmp13_;
const gchar* _tmp14_;
GdkPixbufLoader* _tmp15_;
GdkPixbufFormat* _tmp16_ = NULL;
gchar* _tmp17_ = NULL;
gchar* _tmp18_;
const gchar* _tmp19_;
const gchar* _tmp20_;
const gchar* _tmp21_;
const gchar* _tmp23_;
gchar* _tmp24_;
_tmp13_ = icon;
_tmp14_ = path;
_tmp15_ = loader;
_tmp16_ = gdk_pixbuf_loader_get_format (_tmp15_);
_tmp17_ = gdk_pixbuf_format_get_name (_tmp16_);
_tmp18_ = _tmp17_;
gdk_pixbuf_save (_tmp13_, _tmp14_, _tmp18_, &_inner_error_, NULL);
_g_free0 (_tmp18_);
if (_inner_error_ != NULL) {
_g_free0 (path);
_g_object_unref0 (icon);
_g_object_unref0 (loader);
goto __catch6_g_error;
}
_tmp19_ = property;
_tmp20_ = path;
dbusmenu_menuitem_property_set ((DbusmenuMenuitem*) self, _tmp19_, _tmp20_);
_tmp21_ = self->priv->previous_temp_album_art_path;
if (_tmp21_ != NULL) {
const gchar* _tmp22_;
_tmp22_ = self->priv->previous_temp_album_art_path;
g_remove (_tmp22_);
}
_tmp23_ = path;
_tmp24_ = g_strdup (_tmp23_);
_g_free0 (self->priv->previous_temp_album_art_path);
self->priv->previous_temp_album_art_path = _tmp24_;
}
_g_free0 (path);
_g_object_unref0 (icon);
_g_object_unref0 (loader);
}
goto __finally6;
__catch6_g_error:
{
GError* e = NULL;
GError* _tmp25_;
const gchar* _tmp26_;
e = _inner_error_;
_inner_error_ = NULL;
_tmp25_ = e;
_tmp26_ = _tmp25_->message;
g_warning ("metadata-menu-item.vala:163: Problem creating file from bytearray fetc" \
"hed from the interweb - error: %s", _tmp26_);
_g_error_free0 (e);
}
__finally6:
if (_inner_error_ != NULL) {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
