void _gimp_thumbs_delete_others (const gchar *uri, GimpThumbSize size) { gint i; g_return_if_fail (gimp_thumb_initialized); g_return_if_fail (uri != NULL); size = gimp_thumb_size (size); for (i = 0; i < thumb_num_sizes; i++) { gchar *filename; if (i == size) continue; filename = gimp_thumb_name_from_uri (uri, thumb_sizes[i]); if (filename) { g_unlink (filename); g_free (filename); } } }
/** * gimp_thumbnail_has_failed: * @thumbnail: a #GimpThumbnail object * * Checks if a valid failure thumbnail for the given thumbnail exists * in the global thumbnail repository. This may be the case even if * gimp_thumbnail_peek_thumb() doesn't return %GIMP_THUMB_STATE_FAILED * since there might be a real thumbnail and a failure thumbnail for * the same image file. * * The application should not attempt to create the thumbnail if a * valid failure thumbnail exists. * * Return value: %TRUE if a failure thumbnail exists or * * Since: 2.2 **/ gboolean gimp_thumbnail_has_failed (GimpThumbnail *thumbnail) { GdkPixbuf *pixbuf; const gchar *option; gchar *filename; gint64 image_mtime; gint64 image_size; gboolean failed = FALSE; g_return_val_if_fail (GIMP_IS_THUMBNAIL (thumbnail), FALSE); g_return_val_if_fail (thumbnail->image_uri != NULL, FALSE); GIMP_THUMB_DEBUG_CALL (thumbnail); filename = gimp_thumb_name_from_uri (thumbnail->image_uri, GIMP_THUMB_SIZE_FAIL); if (! filename) return FALSE; pixbuf = gdk_pixbuf_new_from_file (filename, NULL); g_free (filename); if (! pixbuf) return FALSE; if (gimp_thumbnail_peek_image (thumbnail) < GIMP_THUMB_STATE_EXISTS) goto finish; /* URI and mtime from the thumbnail need to match our file */ option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_URI); if (! option || strcmp (option, thumbnail->image_uri)) goto finish; option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_MTIME); if (!option || sscanf (option, "%" G_GINT64_FORMAT, &image_mtime) != 1) goto finish; option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_FILESIZE); if (option && sscanf (option, "%" G_GINT64_FORMAT, &image_size) != 1) goto finish; /* TAG_THUMB_FILESIZE is optional but must match if present */ if (image_mtime == thumbnail->image_mtime && (option == NULL || image_size == thumbnail->image_filesize)) { failed = TRUE; } finish: g_object_unref (pixbuf); return failed; }
/** * gimp_thumbnail_delete_failure: * @thumbnail: a #GimpThumbnail object * * Removes a failure thumbnail if one exists. This function should be * used after a thumbnail has been successfully created. * * Since: 2.2 **/ void gimp_thumbnail_delete_failure (GimpThumbnail *thumbnail) { gchar *filename; g_return_if_fail (GIMP_IS_THUMBNAIL (thumbnail)); g_return_if_fail (thumbnail->image_uri != NULL); GIMP_THUMB_DEBUG_CALL (thumbnail); filename = gimp_thumb_name_from_uri (thumbnail->image_uri, GIMP_THUMB_SIZE_FAIL); if (filename) { g_unlink (filename); g_free (filename); } }
/** * gimp_thumbs_delete_for_uri: * @uri: an escaped URI * * Deletes all thumbnails for the image file specified by @uri from the * user's thumbnail repository. * * Since: GIMP 2.2 **/ void gimp_thumbs_delete_for_uri (const gchar *uri) { gint i; g_return_if_fail (gimp_thumb_initialized); g_return_if_fail (uri != NULL); for (i = 0; i < thumb_num_sizes; i++) { gchar *filename = gimp_thumb_name_from_uri (uri, thumb_sizes[i]); if (filename) { g_unlink (filename); g_free (filename); } } }
/** * gimp_thumbnail_save_thumb: * @thumbnail: a #GimpThumbnail object * @pixbuf: a #GdkPixbuf representing the preview thumbnail * @software: a string describing the software saving the thumbnail * @error: return location for possible errors * * Saves a preview thumbnail for the image associated with @thumbnail. * to the global thumbnail repository. * * The caller is responsible for setting the image file location, it's * filesize, modification time. One way to set this info is to is to * call gimp_thumbnail_set_uri() followed by gimp_thumbnail_peek_image(). * Since this won't work for remote images, it is left to the user of * gimp_thumbnail_save_thumb() to do this or to set the information * using the @thumbnail object properties. * * The image format type and the number of layers can optionally be * set in order to be stored with the preview image. * * Return value: %TRUE if a thumbnail was successfully written, * %FALSE otherwise **/ gboolean gimp_thumbnail_save_thumb (GimpThumbnail *thumbnail, GdkPixbuf *pixbuf, const gchar *software, GError **error) { GimpThumbSize size; gchar *name; gboolean success; g_return_val_if_fail (GIMP_IS_THUMBNAIL (thumbnail), FALSE); g_return_val_if_fail (thumbnail->image_uri != NULL, FALSE); g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), FALSE); g_return_val_if_fail (software != NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); GIMP_THUMB_DEBUG_CALL (thumbnail); size = MAX (gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf)); if (size < 1) return TRUE; name = gimp_thumb_name_from_uri (thumbnail->image_uri, size); if (! name) return TRUE; if (! gimp_thumb_ensure_thumb_dir (size, error)) { g_free (name); return FALSE; } success = gimp_thumbnail_save (thumbnail, size, name, pixbuf, software, error); g_free (name); return success; }
static PyObject * _wrap_gimp_thumb_name_from_uri(PyObject *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = { "uri", "size", NULL }; char *uri; PyObject *py_size = NULL; gchar *ret; GimpThumbSize size; if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO:name_from_uri", kwlist, &uri, &py_size)) return NULL; if (pyg_enum_get_value(GIMP_TYPE_THUMB_SIZE, py_size, (gpointer)&size)) return NULL; ret = gimp_thumb_name_from_uri(uri, size); if (ret) { PyObject *py_ret = PyString_FromString(ret); g_free(ret); return py_ret; } Py_INCREF(Py_None); return Py_None; }
/** * gimp_thumbnail_save_failure: * @thumbnail: a #GimpThumbnail object * @software: a string describing the software saving the thumbnail * @error: return location for possible errors * * Saves a failure thumbnail for the image associated with * @thumbnail. This is an empty pixbuf that indicates that an attempt * to create a preview for the image file failed. It should be used to * prevent the software from further attempts to create this thumbnail. * * Return value: %TRUE if a failure thumbnail was successfully written, * %FALSE otherwise **/ gboolean gimp_thumbnail_save_failure (GimpThumbnail *thumbnail, const gchar *software, GError **error) { GdkPixbuf *pixbuf; gchar *name; gchar *desc; gchar *time_str; gchar *size_str; gboolean success; g_return_val_if_fail (GIMP_IS_THUMBNAIL (thumbnail), FALSE); g_return_val_if_fail (thumbnail->image_uri != NULL, FALSE); g_return_val_if_fail (software != NULL, FALSE); GIMP_THUMB_DEBUG_CALL (thumbnail); name = gimp_thumb_name_from_uri (thumbnail->image_uri, GIMP_THUMB_SIZE_FAIL); if (! name) return TRUE; if (! gimp_thumb_ensure_thumb_dir (GIMP_THUMB_SIZE_FAIL, error)) { g_free (name); return FALSE; } pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, 1, 1); desc = g_strdup_printf ("Thumbnail failure for %s", thumbnail->image_uri); time_str = g_strdup_printf ("%" G_GINT64_FORMAT, thumbnail->image_mtime); size_str = g_strdup_printf ("%" G_GINT64_FORMAT, thumbnail->image_filesize); success = gdk_pixbuf_save (pixbuf, name, "png", error, TAG_DESCRIPTION, desc, TAG_SOFTWARE, software, TAG_THUMB_URI, thumbnail->image_uri, TAG_THUMB_MTIME, time_str, TAG_THUMB_FILESIZE, size_str, NULL); if (success) { success = (g_chmod (name, 0600) == 0); if (success) gimp_thumbnail_update_thumb (thumbnail, GIMP_THUMB_SIZE_NORMAL); else g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), "Could not set permissions of thumbnail '%s': %s", name, g_strerror (errno)); } g_object_unref (pixbuf); g_free (size_str); g_free (time_str); g_free (desc); g_free (name); return success; }