Adding upstream version 2.10.34.upstream/2.10.34upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1400 insertions, 0 deletions

diff --git a/libgimpthumb/gimpthumbnail.c b/libgimpthumb/gimpthumbnail.c
new file mode 100644
index 0000000..e7f9d3d
--- /dev/null
+++ b/libgimpthumb/gimpthumbnail.c
@@ -0,0 +1,1400 @@
+/* LIBGIMP - The GIMP Library
+ * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
+ *
+ * Thumbnail handling according to the Thumbnail Managing Standard.
+ * https://specifications.freedesktop.org/thumbnail-spec/
+ *
+ * Copyright (C) 2001-2004  Sven Neumann <sven@gimp.org>
+ *                          Michael Natterer <mitch@gimp.org>
+ *
+ * This library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see
+ * <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <glib/gstdio.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "libgimpbase/gimpparam.h"
+
+#ifdef G_OS_WIN32
+#include "libgimpbase/gimpwin32-io.h"
+#include <process.h>
+#define _getpid getpid
+#endif
+
+#include "gimpthumb-types.h"
+#include "gimpthumb-error.h"
+#include "gimpthumb-utils.h"
+#include "gimpthumbnail.h"
+
+#include "libgimp/libgimp-intl.h"
+
+
+/**
+ * SECTION: gimpthumbnail
+ * @title: GimpThumbnail
+ * @short_description: The GimpThumbnail object
+ *
+ * The GimpThumbnail object
+ **/
+
+
+/*  #define GIMP_THUMB_DEBUG  */
+
+
+#if defined (GIMP_THUMB_DEBUG) && defined (__GNUC__)
+#define GIMP_THUMB_DEBUG_CALL(t) \
+        g_printerr ("%s: %s\n", \
+                     __FUNCTION__, t->image_uri ? t->image_uri : "(null)")
+#else
+#define GIMP_THUMB_DEBUG_CALL(t) ((void)(0))
+#endif
+
+
+#define TAG_DESCRIPTION           "tEXt::Description"
+#define TAG_SOFTWARE              "tEXt::Software"
+#define TAG_THUMB_URI             "tEXt::Thumb::URI"
+#define TAG_THUMB_MTIME           "tEXt::Thumb::MTime"
+#define TAG_THUMB_FILESIZE        "tEXt::Thumb::Size"
+#define TAG_THUMB_MIMETYPE        "tEXt::Thumb::Mimetype"
+#define TAG_THUMB_IMAGE_WIDTH     "tEXt::Thumb::Image::Width"
+#define TAG_THUMB_IMAGE_HEIGHT    "tEXt::Thumb::Image::Height"
+#define TAG_THUMB_GIMP_TYPE       "tEXt::Thumb::X-GIMP::Type"
+#define TAG_THUMB_GIMP_LAYERS     "tEXt::Thumb::X-GIMP::Layers"
+
+
+enum
+{
+  PROP_0,
+  PROP_IMAGE_STATE,
+  PROP_IMAGE_URI,
+  PROP_IMAGE_MTIME,
+  PROP_IMAGE_FILESIZE,
+  PROP_IMAGE_MIMETYPE,
+  PROP_IMAGE_WIDTH,
+  PROP_IMAGE_HEIGHT,
+  PROP_IMAGE_TYPE,
+  PROP_IMAGE_NUM_LAYERS,
+  PROP_THUMB_STATE
+};
+
+
+static void      gimp_thumbnail_finalize     (GObject        *object);
+static void      gimp_thumbnail_set_property (GObject        *object,
+                                              guint           property_id,
+                                              const GValue   *value,
+                                              GParamSpec     *pspec);
+static void      gimp_thumbnail_get_property (GObject        *object,
+                                              guint           property_id,
+                                              GValue         *value,
+                                              GParamSpec     *pspec);
+static void      gimp_thumbnail_reset_info   (GimpThumbnail  *thumbnail);
+
+static void      gimp_thumbnail_update_image (GimpThumbnail  *thumbnail);
+static void      gimp_thumbnail_update_thumb (GimpThumbnail  *thumbnail,
+                                              GimpThumbSize   size);
+
+static gboolean  gimp_thumbnail_save         (GimpThumbnail  *thumbnail,
+                                              GimpThumbSize   size,
+                                              const gchar    *filename,
+                                              GdkPixbuf      *pixbuf,
+                                              const gchar    *software,
+                                              GError        **error);
+#ifdef GIMP_THUMB_DEBUG
+static void      gimp_thumbnail_debug_notify (GObject        *object,
+                                              GParamSpec     *pspec);
+#endif
+
+
+G_DEFINE_TYPE (GimpThumbnail, gimp_thumbnail, G_TYPE_OBJECT)
+
+#define parent_class gimp_thumbnail_parent_class
+
+
+static void
+gimp_thumbnail_class_init (GimpThumbnailClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize     = gimp_thumbnail_finalize;
+  object_class->set_property = gimp_thumbnail_set_property;
+  object_class->get_property = gimp_thumbnail_get_property;
+
+  g_object_class_install_property (object_class,
+                                   PROP_IMAGE_STATE,
+                                   g_param_spec_enum ("image-state", NULL,
+                                                      "State of the image associated to the thumbnail object",
+                                                      GIMP_TYPE_THUMB_STATE,
+                                                      GIMP_THUMB_STATE_UNKNOWN,
+                                                      GIMP_PARAM_READWRITE));
+  g_object_class_install_property (object_class,
+                                   PROP_IMAGE_URI,
+                                   g_param_spec_string ("image-uri", NULL,
+                                                       "URI of the image file",
+                                                        NULL,
+                                                        GIMP_PARAM_READWRITE));
+  g_object_class_install_property (object_class,
+                                   PROP_IMAGE_MTIME,
+                                   g_param_spec_int64 ("image-mtime", NULL,
+                                                       "Modification time of the image file in seconds since the Epoch",
+                                                       G_MININT64, G_MAXINT64, 0,
+                                                       GIMP_PARAM_READWRITE));
+  g_object_class_install_property (object_class,
+                                   PROP_IMAGE_FILESIZE,
+                                   g_param_spec_int64 ("image-filesize", NULL,
+                                                       "Size of the image file in bytes",
+                                                       0, G_MAXINT64, 0,
+                                                       GIMP_PARAM_READWRITE));
+  /**
+   * GimpThumbnail::image-mimetype:
+   *
+   * Image mimetype
+   *
+   * Since: 2.2
+   **/
+  g_object_class_install_property (object_class,
+                                   PROP_IMAGE_MIMETYPE,
+                                   g_param_spec_string ("image-mimetype", NULL,
+                                                        "Image mimetype",
+                                                        NULL,
+                                                        GIMP_PARAM_READWRITE));
+  g_object_class_install_property (object_class,
+                                   PROP_IMAGE_WIDTH,
+                                   g_param_spec_int ("image-width", NULL,
+                                                     "Width of the image in pixels",
+                                                     0, G_MAXINT, 0,
+                                                     GIMP_PARAM_READWRITE));
+  g_object_class_install_property (object_class,
+                                   PROP_IMAGE_HEIGHT,
+                                   g_param_spec_int ("image-height", NULL,
+                                                     "Height of the image in pixels",
+                                                     0, G_MAXINT, 0,
+                                                     GIMP_PARAM_READWRITE));
+  g_object_class_install_property (object_class,
+                                   PROP_IMAGE_TYPE,
+                                   g_param_spec_string ("image-type", NULL,
+                                                        "String describing the type of the image format",
+                                                        NULL,
+                                                        GIMP_PARAM_READWRITE));
+  g_object_class_install_property (object_class,
+                                   PROP_IMAGE_NUM_LAYERS,
+                                   g_param_spec_int ("image-num-layers", NULL,
+                                                     "The number of layers in the image",
+                                                     0, G_MAXINT, 0,
+                                                     GIMP_PARAM_READWRITE));
+  g_object_class_install_property (object_class,
+                                   PROP_THUMB_STATE,
+                                   g_param_spec_enum ("thumb-state", NULL,
+                                                      "State of the thumbnail file",
+                                                      GIMP_TYPE_THUMB_STATE,
+                                                      GIMP_THUMB_STATE_UNKNOWN,
+                                                      GIMP_PARAM_READWRITE));
+}
+
+static void
+gimp_thumbnail_init (GimpThumbnail *thumbnail)
+{
+  thumbnail->image_state      = GIMP_THUMB_STATE_UNKNOWN;
+  thumbnail->image_uri        = NULL;
+  thumbnail->image_filename   = NULL;
+  thumbnail->image_mtime      = 0;
+  thumbnail->image_filesize   = 0;
+  thumbnail->image_mimetype   = NULL;
+  thumbnail->image_width      = 0;
+  thumbnail->image_height     = 0;
+  thumbnail->image_type       = NULL;
+  thumbnail->image_num_layers = 0;
+
+  thumbnail->thumb_state      = GIMP_THUMB_STATE_UNKNOWN;
+  thumbnail->thumb_size       = -1;
+  thumbnail->thumb_filename   = NULL;
+  thumbnail->thumb_mtime      = 0;
+  thumbnail->thumb_filesize   = 0;
+
+#ifdef GIMP_THUMB_DEBUG
+  g_signal_connect (thumbnail, "notify",
+                    G_CALLBACK (gimp_thumbnail_debug_notify),
+                    NULL);
+#endif
+}
+
+static void
+gimp_thumbnail_finalize (GObject *object)
+{
+  GimpThumbnail *thumbnail = GIMP_THUMBNAIL (object);
+
+  g_clear_pointer (&thumbnail->image_uri,      g_free);
+  g_clear_pointer (&thumbnail->image_filename, g_free);
+  g_clear_pointer (&thumbnail->image_mimetype, g_free);
+  g_clear_pointer (&thumbnail->image_type,     g_free);
+  g_clear_pointer (&thumbnail->thumb_filename, g_free);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gimp_thumbnail_set_property (GObject      *object,
+                             guint         property_id,
+                             const GValue *value,
+                             GParamSpec   *pspec)
+{
+  GimpThumbnail *thumbnail = GIMP_THUMBNAIL (object);
+
+  switch (property_id)
+    {
+    case PROP_IMAGE_STATE:
+      thumbnail->image_state = g_value_get_enum (value);
+      break;
+    case PROP_IMAGE_URI:
+      gimp_thumbnail_set_uri (GIMP_THUMBNAIL (object),
+                              g_value_get_string (value));
+      break;
+    case PROP_IMAGE_MTIME:
+      thumbnail->image_mtime = g_value_get_int64 (value);
+      break;
+    case PROP_IMAGE_FILESIZE:
+      thumbnail->image_filesize = g_value_get_int64 (value);
+      break;
+    case PROP_IMAGE_MIMETYPE:
+      g_free (thumbnail->image_mimetype);
+      thumbnail->image_mimetype = g_value_dup_string (value);
+      break;
+    case PROP_IMAGE_WIDTH:
+      thumbnail->image_width = g_value_get_int (value);
+      break;
+    case PROP_IMAGE_HEIGHT:
+      thumbnail->image_height = g_value_get_int (value);
+      break;
+    case PROP_IMAGE_TYPE:
+      g_free (thumbnail->image_type);
+      thumbnail->image_type = g_value_dup_string (value);
+      break;
+    case PROP_IMAGE_NUM_LAYERS:
+      thumbnail->image_num_layers = g_value_get_int (value);
+      break;
+    case PROP_THUMB_STATE:
+      thumbnail->thumb_state = g_value_get_enum (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_thumbnail_get_property (GObject    *object,
+                             guint       property_id,
+                             GValue     *value,
+                             GParamSpec *pspec)
+{
+  GimpThumbnail *thumbnail = GIMP_THUMBNAIL (object);
+
+  switch (property_id)
+    {
+    case PROP_IMAGE_STATE:
+      g_value_set_enum (value, thumbnail->image_state);
+      break;
+    case PROP_IMAGE_URI:
+      g_value_set_string (value, thumbnail->image_uri);
+      break;
+    case PROP_IMAGE_MTIME:
+      g_value_set_int64 (value, thumbnail->image_mtime);
+      break;
+    case PROP_IMAGE_FILESIZE:
+      g_value_set_int64 (value, thumbnail->image_filesize);
+      break;
+    case PROP_IMAGE_MIMETYPE:
+      g_value_set_string (value, thumbnail->image_mimetype);
+      break;
+    case PROP_IMAGE_WIDTH:
+      g_value_set_int (value, thumbnail->image_width);
+      break;
+    case PROP_IMAGE_HEIGHT:
+      g_value_set_int (value, thumbnail->image_height);
+      break;
+    case PROP_IMAGE_TYPE:
+      g_value_set_string (value, thumbnail->image_type);
+      break;
+    case PROP_IMAGE_NUM_LAYERS:
+      g_value_set_int (value, thumbnail->image_num_layers);
+      break;
+    case PROP_THUMB_STATE:
+      g_value_set_enum (value, thumbnail->thumb_state);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+/**
+ * gimp_thumbnail_new:
+ *
+ * Creates a new #GimpThumbnail object.
+ *
+ * Return value: a newly allocated GimpThumbnail object
+ **/
+GimpThumbnail *
+gimp_thumbnail_new (void)
+{
+  return g_object_new (GIMP_TYPE_THUMBNAIL, NULL);
+}
+
+/**
+ * gimp_thumbnail_set_uri:
+ * @thumbnail: a #GimpThumbnail object
+ * @uri: an escaped URI
+ *
+ * Sets the location of the image file associated with the #thumbnail.
+ *
+ * All information stored in the #GimpThumbnail is reset.
+ **/
+void
+gimp_thumbnail_set_uri (GimpThumbnail *thumbnail,
+                        const gchar   *uri)
+{
+  g_return_if_fail (GIMP_IS_THUMBNAIL (thumbnail));
+
+  GIMP_THUMB_DEBUG_CALL (thumbnail);
+
+  if (thumbnail->image_uri)
+    g_free (thumbnail->image_uri);
+
+  thumbnail->image_uri = g_strdup (uri);
+
+  g_clear_pointer (&thumbnail->image_filename, g_free);
+  g_clear_pointer (&thumbnail->thumb_filename, g_free);
+
+  thumbnail->thumb_size     = -1;
+  thumbnail->thumb_filesize = 0;
+  thumbnail->thumb_mtime    = 0;
+
+  g_object_set (thumbnail,
+                "image-state",      GIMP_THUMB_STATE_UNKNOWN,
+                "image-filesize",   (gint64) 0,
+                "image-mtime",      (gint64) 0,
+                "image-mimetype",   NULL,
+                "image-width",      0,
+                "image-height",     0,
+                "image-type",       NULL,
+                "image-num-layers", 0,
+                "thumb-state",      GIMP_THUMB_STATE_UNKNOWN,
+                NULL);
+}
+
+/**
+ * gimp_thumbnail_set_filename:
+ * @thumbnail: a #GimpThumbnail object
+ * @filename: a local filename in the encoding of the filesystem
+ * @error: return location for possible errors
+ *
+ * Sets the location of the image file associated with the #thumbnail.
+ *
+ * Return value: %TRUE if the filename was successfully set,
+ *               %FALSE otherwise
+ **/
+gboolean
+gimp_thumbnail_set_filename (GimpThumbnail  *thumbnail,
+                             const gchar    *filename,
+                             GError        **error)
+{
+  gchar *uri = NULL;
+
+  g_return_val_if_fail (GIMP_IS_THUMBNAIL (thumbnail), FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  GIMP_THUMB_DEBUG_CALL (thumbnail);
+
+  if (filename)
+    uri = g_filename_to_uri (filename, NULL, error);
+
+  gimp_thumbnail_set_uri (thumbnail, uri);
+
+  g_free (uri);
+
+  return (!filename || uri);
+}
+
+/**
+ * gimp_thumbnail_set_from_thumb:
+ * @thumbnail: a #GimpThumbnail object
+ * @filename: filename of a local thumbnail file
+ * @error: return location for possible errors
+ *
+ * This function tries to load the thumbnail file pointed to by
+ * @filename and retrieves the URI of the original image file from
+ * it. This allows you to find the image file associated with a
+ * thumbnail file.
+ *
+ * This will only work with thumbnails from the global thumbnail
+ * directory that contain a valid Thumb::URI tag.
+ *
+ * Return value: %TRUE if the pixbuf could be loaded, %FALSE otherwise
+ **/
+gboolean
+gimp_thumbnail_set_from_thumb (GimpThumbnail  *thumbnail,
+                               const gchar    *filename,
+                               GError        **error)
+{
+  GdkPixbuf   *pixbuf;
+  const gchar *uri;
+
+  g_return_val_if_fail (GIMP_IS_THUMBNAIL (thumbnail), FALSE);
+  g_return_val_if_fail (filename != NULL, FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  GIMP_THUMB_DEBUG_CALL (thumbnail);
+
+  pixbuf = gdk_pixbuf_new_from_file (filename, error);
+  if (! pixbuf)
+    return FALSE;
+
+  uri = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_URI);
+  if (! uri)
+    {
+      g_set_error (error, GIMP_THUMB_ERROR, 0,
+                   _("Thumbnail contains no Thumb::URI tag"));
+      g_object_unref (pixbuf);
+      return FALSE;
+    }
+
+  gimp_thumbnail_set_uri (thumbnail, uri);
+  g_object_unref (pixbuf);
+
+  return TRUE;
+}
+
+/**
+ * gimp_thumbnail_peek_image:
+ * @thumbnail: a #GimpThumbnail object
+ *
+ * Checks the image file associated with the @thumbnail and updates
+ * information such as state, filesize and modification time.
+ *
+ * Return value: the image's #GimpThumbState after the update
+ **/
+GimpThumbState
+gimp_thumbnail_peek_image (GimpThumbnail *thumbnail)
+{
+  g_return_val_if_fail (GIMP_IS_THUMBNAIL (thumbnail),
+                        GIMP_THUMB_STATE_UNKNOWN);
+
+  GIMP_THUMB_DEBUG_CALL (thumbnail);
+
+  g_object_freeze_notify (G_OBJECT (thumbnail));
+
+  gimp_thumbnail_update_image (thumbnail);
+
+  g_object_thaw_notify (G_OBJECT (thumbnail));
+
+  return thumbnail->image_state;
+}
+
+/**
+ * gimp_thumbnail_peek_thumb:
+ * @thumbnail: a #GimpThumbnail object
+ * @size: the preferred size of the thumbnail image
+ *
+ * Checks if a thumbnail file for the @thumbnail exists. It doesn't
+ * load the thumbnail image and thus cannot check if the thumbnail is
+ * valid and uptodate for the image file asosciated with the
+ * @thumbnail.
+ *
+ * If you want to check the thumbnail, either attempt to load it using
+ * gimp_thumbnail_load_thumb(), or, if you don't need the resulting
+ * thumbnail pixbuf, use gimp_thumbnail_check_thumb().
+ *
+ * Return value: the thumbnail's #GimpThumbState after the update
+ **/
+GimpThumbState
+gimp_thumbnail_peek_thumb (GimpThumbnail *thumbnail,
+                           GimpThumbSize  size)
+{
+  g_return_val_if_fail (GIMP_IS_THUMBNAIL (thumbnail),
+                        GIMP_THUMB_STATE_UNKNOWN);
+
+  GIMP_THUMB_DEBUG_CALL (thumbnail);
+
+  g_object_freeze_notify (G_OBJECT (thumbnail));
+
+  gimp_thumbnail_update_image (thumbnail);
+  gimp_thumbnail_update_thumb (thumbnail, size);
+
+  g_object_thaw_notify (G_OBJECT (thumbnail));
+
+  return thumbnail->thumb_state;
+}
+
+/**
+ * gimp_thumbnail_check_thumb:
+ * @thumbnail: a #GimpThumbnail object
+ * @size: the preferred size of the thumbnail image
+ *
+ * Checks if a thumbnail file for the @thumbnail exists, loads it and
+ * verifies it is valid and uptodate for the image file asosciated
+ * with the @thumbnail.
+ *
+ * Return value: the thumbnail's #GimpThumbState after the update
+ *
+ * Since: 2.2
+ **/
+GimpThumbState
+gimp_thumbnail_check_thumb (GimpThumbnail *thumbnail,
+                            GimpThumbSize  size)
+{
+  GdkPixbuf *pixbuf;
+
+  g_return_val_if_fail (GIMP_IS_THUMBNAIL (thumbnail), FALSE);
+
+  GIMP_THUMB_DEBUG_CALL (thumbnail);
+
+  if (gimp_thumbnail_peek_thumb (thumbnail, size) == GIMP_THUMB_STATE_OK)
+    return GIMP_THUMB_STATE_OK;
+
+  pixbuf = gimp_thumbnail_load_thumb (thumbnail, size, NULL);
+
+  if (pixbuf)
+    g_object_unref (pixbuf);
+
+  return thumbnail->thumb_state;
+}
+
+static void
+gimp_thumbnail_update_image (GimpThumbnail *thumbnail)
+{
+  GimpThumbState  state;
+  gint64          mtime    = 0;
+  gint64          filesize = 0;
+
+  if (! thumbnail->image_uri)
+    return;
+
+  state = thumbnail->image_state;
+
+  switch (state)
+    {
+    case GIMP_THUMB_STATE_UNKNOWN:
+      g_return_if_fail (thumbnail->image_filename == NULL);
+
+      thumbnail->image_filename =
+        _gimp_thumb_filename_from_uri (thumbnail->image_uri);
+
+      if (! thumbnail->image_filename)
+        state = GIMP_THUMB_STATE_REMOTE;
+
+      break;
+
+    case GIMP_THUMB_STATE_REMOTE:
+      break;
+
+    default:
+      g_return_if_fail (thumbnail->image_filename != NULL);
+      break;
+    }
+
+  switch (state)
+    {
+    case GIMP_THUMB_STATE_REMOTE:
+      break;
+
+    default:
+      switch (gimp_thumb_file_test (thumbnail->image_filename,
+                                    &mtime, &filesize,
+                                    &thumbnail->image_not_found_errno))
+        {
+        case GIMP_THUMB_FILE_TYPE_REGULAR:
+          state = GIMP_THUMB_STATE_EXISTS;
+          break;
+
+        case GIMP_THUMB_FILE_TYPE_FOLDER:
+          state = GIMP_THUMB_STATE_FOLDER;
+          break;
+
+        case GIMP_THUMB_FILE_TYPE_SPECIAL:
+          state = GIMP_THUMB_STATE_SPECIAL;
+          break;
+
+        default:
+          state = GIMP_THUMB_STATE_NOT_FOUND;
+          break;
+        }
+      break;
+    }
+
+  if (state != thumbnail->image_state)
+    {
+      g_object_set (thumbnail,
+                    "image-state", state,
+                    NULL);
+    }
+
+  if (mtime != thumbnail->image_mtime || filesize != thumbnail->image_filesize)
+    {
+      g_object_set (thumbnail,
+                    "image-mtime",    mtime,
+                    "image-filesize", filesize,
+                    NULL);
+
+      if (thumbnail->thumb_state == GIMP_THUMB_STATE_OK)
+        g_object_set (thumbnail,
+                      "thumb-state", GIMP_THUMB_STATE_OLD,
+                      NULL);
+    }
+}
+
+static void
+gimp_thumbnail_update_thumb (GimpThumbnail *thumbnail,
+                             GimpThumbSize  size)
+{
+  gchar          *filename;
+  GimpThumbState  state;
+  gint64          filesize = 0;
+  gint64          mtime    = 0;
+
+  if (! thumbnail->image_uri)
+    return;
+
+  state = thumbnail->thumb_state;
+
+  filename = gimp_thumb_find_thumb (thumbnail->image_uri, &size);
+
+  /* We don't want to clear the GIMP_THUMB_STATE_FAILED state, because
+   * it is normal to have no filename if thumbnail creation failed. */
+  if (state != GIMP_THUMB_STATE_FAILED && ! filename)
+    state = GIMP_THUMB_STATE_NOT_FOUND;
+
+  switch (state)
+    {
+    case GIMP_THUMB_STATE_EXISTS:
+    case GIMP_THUMB_STATE_OLD:
+    case GIMP_THUMB_STATE_OK:
+      g_return_if_fail (thumbnail->thumb_filename != NULL);
+
+      if (thumbnail->thumb_size     == size     &&
+          thumbnail->thumb_filesize == filesize &&
+          thumbnail->thumb_mtime    == mtime)
+        {
+          g_free (filename);
+          return;
+        }
+      break;
+    default:
+      break;
+    }
+
+  if (thumbnail->thumb_filename)
+    g_free (thumbnail->thumb_filename);
+
+  thumbnail->thumb_filename = filename;
+
+  if (filename)
+    state = (size > GIMP_THUMB_SIZE_FAIL ?
+             GIMP_THUMB_STATE_EXISTS : GIMP_THUMB_STATE_FAILED);
+
+  thumbnail->thumb_size     = size;
+  thumbnail->thumb_filesize = filesize;
+  thumbnail->thumb_mtime    = mtime;
+
+  if (state != thumbnail->thumb_state)
+    {
+      g_object_freeze_notify (G_OBJECT (thumbnail));
+
+      g_object_set (thumbnail, "thumb-state", state, NULL);
+      gimp_thumbnail_reset_info (thumbnail);
+
+      g_object_thaw_notify (G_OBJECT (thumbnail));
+    }
+}
+
+static void
+gimp_thumbnail_reset_info (GimpThumbnail *thumbnail)
+{
+  g_object_set (thumbnail,
+                "image-width",      0,
+                "image-height",     0,
+                "image-type",       NULL,
+                "image-num-layers", 0,
+                NULL);
+}
+
+static void
+gimp_thumbnail_set_info_from_pixbuf (GimpThumbnail *thumbnail,
+                                     GdkPixbuf     *pixbuf)
+{
+  const gchar  *option;
+  gint          num;
+
+  g_object_freeze_notify (G_OBJECT (thumbnail));
+
+  gimp_thumbnail_reset_info (thumbnail);
+
+  g_free (thumbnail->image_mimetype);
+  thumbnail->image_mimetype =
+    g_strdup (gdk_pixbuf_get_option (pixbuf, TAG_THUMB_MIMETYPE));
+
+  option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_IMAGE_WIDTH);
+  if (option && sscanf (option, "%d", &num) == 1)
+    thumbnail->image_width = num;
+
+  option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_IMAGE_HEIGHT);
+  if (option && sscanf (option, "%d", &num) == 1)
+    thumbnail->image_height = num;
+
+  thumbnail->image_type =
+    g_strdup (gdk_pixbuf_get_option (pixbuf, TAG_THUMB_GIMP_TYPE));
+
+  option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_GIMP_LAYERS);
+  if (option && sscanf (option, "%d", &num) == 1)
+    thumbnail->image_num_layers = num;
+
+  g_object_thaw_notify (G_OBJECT (thumbnail));
+}
+
+static gboolean
+gimp_thumbnail_save (GimpThumbnail  *thumbnail,
+                     GimpThumbSize   size,
+                     const gchar    *filename,
+                     GdkPixbuf      *pixbuf,
+                     const gchar    *software,
+                     GError        **error)
+{
+  const gchar  *keys[12];
+  gchar        *values[12];
+  gchar        *basename;
+  gchar        *dirname;
+  gchar        *tmpname;
+  gboolean      success;
+  gint          i = 0;
+
+  keys[i]   = TAG_DESCRIPTION;
+  values[i] = g_strdup_printf ("Thumbnail of %s",  thumbnail->image_uri);
+  i++;
+
+  keys[i]   = TAG_SOFTWARE;
+  values[i] = g_strdup (software);
+  i++;
+
+  keys[i]   = TAG_THUMB_URI;
+  values[i] = g_strdup (thumbnail->image_uri);
+  i++;
+
+  keys[i]   = TAG_THUMB_MTIME;
+  values[i] = g_strdup_printf ("%" G_GINT64_FORMAT, thumbnail->image_mtime);
+  i++;
+
+  keys[i]   = TAG_THUMB_FILESIZE;
+  values[i] = g_strdup_printf ("%" G_GINT64_FORMAT, thumbnail->image_filesize);
+  i++;
+
+  if (thumbnail->image_mimetype)
+    {
+      keys[i]   = TAG_THUMB_MIMETYPE;
+      values[i] = g_strdup (thumbnail->image_mimetype);
+      i++;
+    }
+
+  if (thumbnail->image_width > 0)
+    {
+      keys[i]   = TAG_THUMB_IMAGE_WIDTH;
+      values[i] = g_strdup_printf ("%d", thumbnail->image_width);
+      i++;
+    }
+
+  if (thumbnail->image_height > 0)
+    {
+      keys[i]   = TAG_THUMB_IMAGE_HEIGHT;
+      values[i] = g_strdup_printf ("%d", thumbnail->image_height);
+      i++;
+    }
+
+  if (thumbnail->image_type)
+    {
+      keys[i]   = TAG_THUMB_GIMP_TYPE;
+      values[i] = g_strdup (thumbnail->image_type);
+      i++;
+    }
+
+  if (thumbnail->image_num_layers > 0)
+    {
+      keys[i]   = TAG_THUMB_GIMP_LAYERS;
+      values[i] = g_strdup_printf ("%d", thumbnail->image_num_layers);
+      i++;
+    }
+
+  keys[i]   = NULL;
+  values[i] = NULL;
+
+  basename = g_path_get_basename (filename);
+  dirname  = g_path_get_dirname (filename);
+
+  tmpname = g_strdup_printf ("%s%cgimp-thumb-%d-%.8s",
+                             dirname, G_DIR_SEPARATOR, getpid (), basename);
+
+  g_free (dirname);
+  g_free (basename);
+
+  success = gdk_pixbuf_savev (pixbuf, tmpname, "png",
+                              (gchar **) keys, values,
+                              error);
+
+  for (i = 0; keys[i]; i++)
+    g_free (values[i]);
+
+  if (success)
+    {
+#ifdef GIMP_THUMB_DEBUG
+      g_printerr ("thumbnail saved to temporary file %s\n", tmpname);
+#endif
+
+      success = (g_rename (tmpname, filename) == 0);
+
+      if (! success)
+        g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
+                     _("Could not create thumbnail for %s: %s"),
+                     thumbnail->image_uri, g_strerror (errno));
+    }
+
+  if (success)
+    {
+#ifdef GIMP_THUMB_DEBUG
+      g_printerr ("temporary thumbnail file renamed to %s\n", filename);
+#endif
+
+      success = (g_chmod (filename, 0600) == 0);
+
+      if (! success)
+        g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
+                     "Could not set permissions of thumbnail for %s: %s",
+                     thumbnail->image_uri, g_strerror (errno));
+
+      g_object_freeze_notify (G_OBJECT (thumbnail));
+
+      gimp_thumbnail_update_thumb (thumbnail, size);
+
+      if (success &&
+          thumbnail->thumb_state == GIMP_THUMB_STATE_EXISTS &&
+          strcmp (filename, thumbnail->thumb_filename) == 0)
+        {
+          thumbnail->thumb_state = GIMP_THUMB_STATE_OK;
+        }
+
+      g_object_thaw_notify (G_OBJECT (thumbnail));
+    }
+
+  g_unlink (tmpname);
+  g_free (tmpname);
+
+  return success;
+}
+
+#ifdef GIMP_THUMB_DEBUG
+static void
+gimp_thumbnail_debug_notify (GObject    *object,
+                             GParamSpec *pspec)
+{
+  GValue       value = G_VALUE_INIT;
+  gchar       *str   = NULL;
+  const gchar *name;
+
+  g_value_init (&value, pspec->value_type);
+  g_object_get_property (object, pspec->name, &value);
+
+  if (G_VALUE_HOLDS_STRING (&value))
+    {
+      str = g_value_dup_string (&value);
+    }
+  else if (g_value_type_transformable (pspec->value_type, G_TYPE_STRING))
+    {
+      GValue  tmp = G_VALUE_INIT;
+
+      g_value_init (&tmp, G_TYPE_STRING);
+      g_value_transform (&value, &tmp);
+
+      str = g_value_dup_string (&tmp);
+
+      g_value_unset (&tmp);
+    }
+
+  g_value_unset (&value);
+
+  name = GIMP_THUMBNAIL (object)->image_uri;
+
+  g_printerr (" GimpThumb (%s) %s: %s\n",
+              name ? name : "(null)", pspec->name, str);
+
+  g_free (str);
+}
+#endif
+
+
+/**
+ * gimp_thumbnail_load_thumb:
+ * @thumbnail: a #GimpThumbnail object
+ * @size: the preferred #GimpThumbSize for the preview
+ * @error: return location for possible errors
+ *
+ * Attempts to load a thumbnail preview for the image associated with
+ * @thumbnail. Before you use this function you need need to set an
+ * image location using gimp_thumbnail_set_uri() or
+ * gimp_thumbnail_set_filename(). You can also peek at the thumb
+ * before loading it using gimp_thumbnail_peek_thumb.
+ *
+ * This function will return the best matching pixbuf for the
+ * specified @size. It returns the pixbuf as loaded from disk. It is
+ * left to the caller to scale it to the desired size. The returned
+ * pixbuf may also represent an outdated preview of the image file.
+ * In order to verify if the preview is uptodate, you should check the
+ * "thumb_state" property after calling this function.
+ *
+ * Return value: a preview pixbuf or %NULL if no thumbnail was found
+ **/
+GdkPixbuf *
+gimp_thumbnail_load_thumb (GimpThumbnail  *thumbnail,
+                           GimpThumbSize   size,
+                           GError        **error)
+{
+  GimpThumbState  state;
+  GdkPixbuf      *pixbuf;
+  const gchar    *option;
+  gint64          image_mtime;
+  gint64          image_size;
+
+  g_return_val_if_fail (GIMP_IS_THUMBNAIL (thumbnail), NULL);
+
+  GIMP_THUMB_DEBUG_CALL (thumbnail);
+
+  if (! thumbnail->image_uri)
+    return NULL;
+
+  state = gimp_thumbnail_peek_thumb (thumbnail, size);
+
+  if (state < GIMP_THUMB_STATE_EXISTS || state == GIMP_THUMB_STATE_FAILED)
+    return NULL;
+
+  pixbuf = gdk_pixbuf_new_from_file (thumbnail->thumb_filename, NULL);
+  if (! pixbuf)
+    return NULL;
+
+#ifdef GIMP_THUMB_DEBUG
+  g_printerr ("thumbnail loaded from %s\n", thumbnail->thumb_filename);
+#endif
+
+  g_object_freeze_notify (G_OBJECT (thumbnail));
+
+  /* URI and mtime from the thumbnail need to match our file */
+  option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_URI);
+  if (!option)
+    goto finish;
+
+  if (strcmp (option, thumbnail->image_uri))
+    {
+      /*  might be a local thumbnail, try if the local part matches  */
+      const gchar *baseuri = strrchr (thumbnail->image_uri, '/');
+
+      if (!baseuri || strcmp (option, baseuri))
+        goto finish;
+    }
+
+  state = GIMP_THUMB_STATE_OLD;
+
+  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))
+    {
+      if (thumbnail->thumb_size == GIMP_THUMB_SIZE_FAIL)
+        state = GIMP_THUMB_STATE_FAILED;
+      else
+        state = GIMP_THUMB_STATE_OK;
+    }
+
+  if (state == GIMP_THUMB_STATE_FAILED)
+    gimp_thumbnail_reset_info (thumbnail);
+  else
+    gimp_thumbnail_set_info_from_pixbuf (thumbnail, pixbuf);
+
+ finish:
+  if (thumbnail->thumb_size == GIMP_THUMB_SIZE_FAIL ||
+      (state != GIMP_THUMB_STATE_OLD && state != GIMP_THUMB_STATE_OK))
+    {
+      g_object_unref (pixbuf);
+      pixbuf = NULL;
+    }
+
+  g_object_set (thumbnail,
+                "thumb-state", state,
+                NULL);
+
+  g_object_thaw_notify (G_OBJECT (thumbnail));
+
+  return pixbuf;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * gimp_thumbnail_save_thumb_local:
+ * @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 local thumbnail repository. Local thumbnails have been added
+ * with version 0.7 of the spec.
+ *
+ * Please see also gimp_thumbnail_save_thumb(). The notes made there
+ * apply here as well.
+ *
+ * Return value: %TRUE if a thumbnail was successfully written,
+ *               %FALSE otherwise
+ *
+ * Since: 2.2
+ **/
+gboolean
+gimp_thumbnail_save_thumb_local (GimpThumbnail  *thumbnail,
+                                 GdkPixbuf      *pixbuf,
+                                 const gchar    *software,
+                                 GError        **error)
+{
+  GimpThumbSize  size;
+  gchar         *name;
+  gchar         *filename;
+  gchar         *dirname;
+  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;
+
+  filename = _gimp_thumb_filename_from_uri (thumbnail->image_uri);
+  if (! filename)
+    return TRUE;
+
+  dirname = g_path_get_dirname (filename);
+  g_free (filename);
+
+  name = gimp_thumb_name_from_uri_local (thumbnail->image_uri, size);
+  if (! name)
+    {
+      g_free (dirname);
+      return TRUE;
+    }
+
+  if (! gimp_thumb_ensure_thumb_dir_local (dirname, size, error))
+    {
+      g_free (name);
+      g_free (dirname);
+      return FALSE;
+    }
+
+  g_free (dirname);
+
+  success = gimp_thumbnail_save (thumbnail,
+                                 size, name, pixbuf, software,
+                                 error);
+  g_free (name);
+
+  return success;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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_thumbnail_delete_others:
+ * @thumbnail: a #GimpThumbnail object
+ * @size: the thumbnail size which should not be deleted
+ *
+ * Removes all other thumbnails from the global thumbnail
+ * repository. Only the thumbnail for @size is not deleted.  This
+ * function should be used after a thumbnail has been successfully
+ * updated. See the spec for a more detailed description on when to
+ * delete thumbnails.
+ *
+ * Since: 2.2
+ **/
+void
+gimp_thumbnail_delete_others (GimpThumbnail *thumbnail,
+                              GimpThumbSize  size)
+{
+  g_return_if_fail (GIMP_IS_THUMBNAIL (thumbnail));
+  g_return_if_fail (thumbnail->image_uri != NULL);
+
+  GIMP_THUMB_DEBUG_CALL (thumbnail);
+
+  _gimp_thumbs_delete_others (thumbnail->image_uri, size);
+}
+
+/**
+ * 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;
+}