procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-03 17:33:25 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions
gimp/libgimpthumb/gimpthumbnail.c
Michael Natterer 8005eea835 Remove the "GIMP" from all "Since: GIMP 2.x" API doc comments 
because it confuses gtk-doc and breaks some links. Also change the
"Index of new symbols in GIMP 2.x" sections to be what seems to be the
modern standard (looked at the GLib and GTK+ docs), and update some
other stuff.
2015-05-31 21:18:09 +02:00

1429 lines
42 KiB
C
Raw Blame History

/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* Thumbnail handling according to the Thumbnail Managing Standard.
* http://triq.net/~pearl/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
* <http://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);
if (thumbnail->image_uri)
{
g_free (thumbnail->image_uri);
thumbnail->image_uri = NULL;
}
if (thumbnail->image_filename)
{
g_free (thumbnail->image_filename);
thumbnail->image_filename = NULL;
}
if (thumbnail->image_mimetype)
{
g_free (thumbnail->image_mimetype);
thumbnail->image_mimetype = NULL;
}
if (thumbnail->image_type)
{
g_free (thumbnail->image_type);
thumbnail->image_type = NULL;
}
if (thumbnail->thumb_filename)
{
g_free (thumbnail->thumb_filename);
thumbnail->thumb_filename = NULL;
}
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 informations stored in the #GimpThumbnail are 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);
if (thumbnail->image_filename)
{
g_free (thumbnail->image_filename);
thumbnail->image_filename = NULL;
}
if (thumbnail->thumb_filename)
{
g_free (thumbnail->thumb_filename);
thumbnail->thumb_filename = NULL;
}
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 = { 0, };
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 = { 0, };
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;
}
Reference in a new issue View git blame Copy permalink