* Boston, MA 02111-1307, USA.
*/
+#include <config.h>
#include <string.h>
#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-animation.h"
+#include "gdk-pixbuf-scaled-anim.h"
#include "gdk-pixbuf-io.h"
#include "gdk-pixbuf-loader.h"
#include "gdk-pixbuf-marshal.h"
+#include "gdk-pixbuf-alias.h"
enum {
SIZE_PREPARED,
};
-static void gdk_pixbuf_loader_class_init (GdkPixbufLoaderClass *klass);
-static void gdk_pixbuf_loader_init (GdkPixbufLoader *loader);
-static void gdk_pixbuf_loader_finalize (GObject *loader);
+static void gdk_pixbuf_loader_finalize (GObject *loader);
-static gpointer parent_class = NULL;
static guint pixbuf_loader_signals[LAST_SIGNAL] = { 0 };
-
/* Internal data */
-#define LOADER_HEADER_SIZE 128
+#define LOADER_HEADER_SIZE 1024
typedef struct
{
GdkPixbufAnimation *animation;
gboolean closed;
+ gboolean holds_threadlock;
guchar header_buf[LOADER_HEADER_SIZE];
gint header_buf_offset;
GdkPixbufModule *image_module;
gboolean needs_scale;
} GdkPixbufLoaderPrivate;
-
-/**
- * gdk_pixbuf_loader_get_type:
- * @void:
- *
- * Registers the #GdkPixbufLoader class if necessary, and returns the type ID
- * associated to it.
- *
- * Return value: The type ID of the #GdkPixbufLoader class.
- **/
-GType
-gdk_pixbuf_loader_get_type (void)
-{
- static GType loader_type = 0;
-
- if (!loader_type)
- {
- static const GTypeInfo loader_info = {
- sizeof (GdkPixbufLoaderClass),
- (GBaseInitFunc) NULL,
- (GBaseFinalizeFunc) NULL,
- (GClassInitFunc) gdk_pixbuf_loader_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (GdkPixbufLoader),
- 0, /* n_preallocs */
- (GInstanceInitFunc) gdk_pixbuf_loader_init
- };
-
- loader_type = g_type_register_static (G_TYPE_OBJECT,
- "GdkPixbufLoader",
- &loader_info,
- 0);
- }
-
- return loader_type;
-}
+G_DEFINE_TYPE (GdkPixbufLoader, gdk_pixbuf_loader, G_TYPE_OBJECT)
static void
gdk_pixbuf_loader_class_init (GdkPixbufLoaderClass *class)
object_class = (GObjectClass *) class;
- parent_class = g_type_class_peek_parent (class);
-
object_class->finalize = gdk_pixbuf_loader_finalize;
+ /**
+ * GdkPixbufLoader::size-prepared:
+ * @loader: the object which received the signal.
+ * @width: the original width of the image
+ * @height: the original height of the image
+ *
+ * This signal is emitted when the pixbuf loader has been fed the
+ * initial amount of data that is required to figure out the size
+ * of the image that it will create. Applications can call
+ * gdk_pixbuf_loader_set_size() in response to this signal to set
+ * the desired size to which the image should be scaled.
+ */
pixbuf_loader_signals[SIZE_PREPARED] =
g_signal_new ("size_prepared",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GdkPixbufLoaderClass, size_prepared),
NULL, NULL,
- gdk_pixbuf_marshal_VOID__INT_INT,
+ _gdk_pixbuf_marshal_VOID__INT_INT,
G_TYPE_NONE, 2,
G_TYPE_INT,
G_TYPE_INT);
+ /**
+ * GdkPixbufLoader::area-prepared:
+ * @loader: the object which received the signal.
+ *
+ * This signal is emitted when the pixbuf loader has allocated the
+ * pixbuf in the desired size. After this signal is emitted,
+ * applications can call gdk_pixbuf_loader_get_pixbuf() to fetch
+ * the partially-loaded pixbuf.
+ */
pixbuf_loader_signals[AREA_PREPARED] =
g_signal_new ("area_prepared",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GdkPixbufLoaderClass, area_prepared),
NULL, NULL,
- gdk_pixbuf_marshal_VOID__VOID,
+ _gdk_pixbuf_marshal_VOID__VOID,
G_TYPE_NONE, 0);
-
+
+ /**
+ * GdkPixbufLoader::area-updated:
+ * @loader: the object which received the signal.
+ * @x: X offset of upper-left corner of the updated area.
+ * @y: Y offset of upper-left corner of the updated area.
+ * @width: Width of updated area.
+ * @height: Height of updated area.
+ *
+ * This signal is emitted when a significant area of the image being
+ * loaded has been updated. Normally it means that a complete
+ * scanline has been read in, but it could be a different area as
+ * well. Applications can use this signal to know when to repaint
+ * areas of an image that is being loaded.
+ */
pixbuf_loader_signals[AREA_UPDATED] =
g_signal_new ("area_updated",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GdkPixbufLoaderClass, area_updated),
NULL, NULL,
- gdk_pixbuf_marshal_VOID__INT_INT_INT_INT,
+ _gdk_pixbuf_marshal_VOID__INT_INT_INT_INT,
G_TYPE_NONE, 4,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
+ /**
+ * GdkPixbufLoader::closed:
+ * @loader: the object which received the signal.
+ *
+ * This signal is emitted when gdk_pixbuf_loader_close() is called.
+ * It can be used by different parts of an application to receive
+ * notification when an image loader is closed by the code that
+ * drives it.
+ */
pixbuf_loader_signals[CLOSED] =
g_signal_new ("closed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GdkPixbufLoaderClass, closed),
NULL, NULL,
- gdk_pixbuf_marshal_VOID__VOID,
+ _gdk_pixbuf_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
GdkPixbufLoaderPrivate *priv;
priv = g_new0 (GdkPixbufLoaderPrivate, 1);
+ priv->width = -1;
+ priv->height = -1;
+
loader->priv = priv;
}
loader = GDK_PIXBUF_LOADER (object);
priv = loader->priv;
- if (!priv->closed)
+ if (!priv->closed) {
g_warning ("GdkPixbufLoader finalized without calling gdk_pixbuf_loader_close() - this is not allowed. You must explicitly end the data stream to the loader before dropping the last reference.");
-
+ if (priv->holds_threadlock) {
+ _gdk_pixbuf_unlock (priv->image_module);
+ }
+ }
if (priv->animation)
g_object_unref (priv->animation);
g_free (priv);
- G_OBJECT_CLASS (parent_class)->finalize (object);
+ G_OBJECT_CLASS (gdk_pixbuf_loader_parent_class)->finalize (object);
}
/**
*
* Attempts to set the desired image size are ignored after the
* emission of the ::size_prepared signal.
+ *
+ * Since: 2.2
*/
void
gdk_pixbuf_loader_set_size (GdkPixbufLoader *loader,
gint height)
{
GdkPixbufLoaderPrivate *priv = GDK_PIXBUF_LOADER (loader)->priv;
- g_return_if_fail (width > 0 && height > 0);
+ g_return_if_fail (width >= 0 && height >= 0);
if (!priv->size_fixed)
{
GdkPixbufLoaderPrivate *priv = GDK_PIXBUF_LOADER (loader)->priv;
/* allow calling gdk_pixbuf_loader_set_size() before the signal */
- if (priv->width == 0 && priv->height == 0)
+ if (priv->width == -1 && priv->height == -1)
{
priv->width = *width;
priv->height = *height;
else
anim = gdk_pixbuf_non_anim_new (pixbuf);
- priv->animation = anim;
+ if (priv->needs_scale) {
+ priv->animation = _gdk_pixbuf_scaled_anim_new (anim,
+ (double) priv->width / gdk_pixbuf_get_width (pixbuf),
+ (double) priv->height / gdk_pixbuf_get_height (pixbuf),
+ 1.0);
+ g_object_unref (anim);
+ }
+ else
+ priv->animation = anim;
if (!priv->needs_scale)
g_signal_emit (loader, pixbuf_loader_signals[AREA_PREPARED], 0);
MIN (height, gdk_pixbuf_animation_get_height (priv->animation)));
}
+/* Defense against broken loaders; DO NOT take this as a GError example! */
+static void
+gdk_pixbuf_loader_ensure_error (GdkPixbufLoader *loader,
+ GError **error)
+{
+ GdkPixbufLoaderPrivate *priv = loader->priv;
+
+ if (error == NULL || *error != NULL)
+ return;
+
+ g_warning ("Bug! loader '%s' didn't set an error on failure",
+ priv->image_module->module_name);
+ g_set_error (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_FAILED,
+ _("Internal error: Image loader module '%s' failed to"
+ " complete an operation, but didn't give a reason for"
+ " the failure"),
+ priv->image_module->module_name);
+}
+
static gint
gdk_pixbuf_loader_load_module (GdkPixbufLoader *loader,
const char *image_type,
return 0;
}
+ if (!priv->holds_threadlock) {
+ priv->holds_threadlock = _gdk_pixbuf_lock (priv->image_module);
+ }
+
priv->context = priv->image_module->begin_load (gdk_pixbuf_loader_size_func,
gdk_pixbuf_loader_prepare,
gdk_pixbuf_loader_update,
if (priv->context == NULL)
{
- /* Defense against broken loaders; DO NOT take this as a GError
- * example
- */
- if (error && *error == NULL)
- {
- g_warning ("Bug! loader '%s' didn't set an error on failure",
- priv->image_module->module_name);
- g_set_error (error,
- GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_FAILED,
- _("Internal error: Image loader module '%s'"
- " failed to begin loading an image, but didn't"
- " give a reason for the failure"),
- priv->image_module->module_name);
-
- }
-
+ gdk_pixbuf_loader_ensure_error (loader, error);
return 0;
}
g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), FALSE);
g_return_val_if_fail (buf != NULL, FALSE);
- g_return_val_if_fail (count >= 0, FALSE);
+ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
priv = loader->priv;
/* we expect it's not to be closed */
g_return_val_if_fail (priv->closed == FALSE, FALSE);
- if (priv->image_module == NULL)
+ if (count > 0 && priv->image_module == NULL)
{
gint eaten;
eaten = gdk_pixbuf_loader_eat_header_write (loader, buf, count, error);
if (eaten <= 0)
- return FALSE;
+ goto fail;
count -= eaten;
buf += eaten;
if (count > 0 && priv->image_module->load_increment)
{
- gboolean retval;
- retval = priv->image_module->load_increment (priv->context, buf, count,
- error);
- if (!retval && error && *error == NULL)
- {
- /* Fix up busted image loader */
- g_warning ("Bug! loader '%s' didn't set an error on failure",
- priv->image_module->module_name);
- g_set_error (error,
- GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_FAILED,
- _("Internal error: Image loader module '%s'"
- " failed to begin loading an image, but didn't"
- " give a reason for the failure"),
- priv->image_module->module_name);
- }
-
- return retval;
+ if (!priv->image_module->load_increment (priv->context, buf, count,
+ error))
+ goto fail;
}
return TRUE;
+
+ fail:
+ gdk_pixbuf_loader_ensure_error (loader, error);
+ gdk_pixbuf_loader_close (loader, NULL);
+
+ return FALSE;
}
/**
* that can't be reliably identified by looking at the data, or if
* the user manually forces a specific type.
*
+ * The list of supported image formats depends on what image loaders
+ * are installed, but typically "png", "jpeg", "gif", "tiff" and
+ * "xpm" are among the supported formats. To obtain the full list of
+ * supported image formats, call gdk_pixbuf_format_get_name() on each
+ * of the #GdkPixbufFormat structs returned by gdk_pixbuf_get_formats().
+ *
* Return value: A newly-created pixbuf loader.
**/
GdkPixbufLoader *
gdk_pixbuf_loader_new_with_type (const char *image_type,
GError **error)
{
+ GdkPixbufLoader *retval;
+ GError *tmp;
+ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+
+ retval = g_object_new (GDK_TYPE_PIXBUF_LOADER, NULL);
+
+ tmp = NULL;
+ gdk_pixbuf_loader_load_module (retval, image_type, &tmp);
+ if (tmp != NULL)
+ {
+ g_propagate_error (error, tmp);
+ gdk_pixbuf_loader_close (retval, NULL);
+ g_object_unref (retval);
+ return NULL;
+ }
+
+ return retval;
+}
+
+/**
+ * gdk_pixbuf_loader_new_with_mime_type:
+ * @mime_type: the mime type to be loaded
+ * @error: return location for an allocated #GError, or %NULL to ignore errors
+ *
+ * Creates a new pixbuf loader object that always attempts to parse
+ * image data as if it were an image of mime type @mime_type, instead of
+ * identifying the type automatically. Useful if you want an error if
+ * the image isn't the expected mime type, for loading image formats
+ * that can't be reliably identified by looking at the data, or if
+ * the user manually forces a specific mime type.
+ *
+ * The list of supported mime types depends on what image loaders
+ * are installed, but typically "image/png", "image/jpeg", "image/gif",
+ * "image/tiff" and "image/x-xpixmap" are among the supported mime types.
+ * To obtain the full list of supported mime types, call
+ * gdk_pixbuf_format_get_mime_types() on each of the #GdkPixbufFormat
+ * structs returned by gdk_pixbuf_get_formats().
+ *
+ * Return value: A newly-created pixbuf loader.
+ * Since: 2.4
+ **/
+GdkPixbufLoader *
+gdk_pixbuf_loader_new_with_mime_type (const char *mime_type,
+ GError **error)
+{
+ const char * image_type = NULL;
+ char ** mimes;
+
GdkPixbufLoader *retval;
GError *tmp;
+ GSList * formats;
+ GdkPixbufFormat *info;
+ int i, j, length;
+
+ formats = gdk_pixbuf_get_formats ();
+ length = g_slist_length (formats);
+
+ for (i = 0; i < length && image_type == NULL; i++) {
+ info = (GdkPixbufFormat *)g_slist_nth_data (formats, i);
+ mimes = info->mime_types;
+
+ for (j = 0; mimes[j] != NULL; j++)
+ if (g_ascii_strcasecmp (mimes[j], mime_type) == 0) {
+ image_type = info->name;
+ break;
+ }
+ }
+
+ g_slist_free (formats);
+
retval = g_object_new (GDK_TYPE_PIXBUF_LOADER, NULL);
tmp = NULL;
- gdk_pixbuf_loader_load_module(retval, image_type, &tmp);
+ gdk_pixbuf_loader_load_module (retval, image_type, &tmp);
if (tmp != NULL)
{
g_propagate_error (error, tmp);
+ gdk_pixbuf_loader_close (retval, NULL);
g_object_unref (retval);
return NULL;
}
g_return_val_if_fail (loader != NULL, TRUE);
g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), TRUE);
+ g_return_val_if_fail (error == NULL || *error == NULL, TRUE);
priv = loader->priv;
- /* we expect it's not closed */
- g_return_val_if_fail (priv->closed == FALSE, TRUE);
+ if (priv->closed)
+ return TRUE;
- /* We have less the 128 bytes in the image. Flush it, and keep going. */
+ /* We have less the LOADER_HEADER_SIZE bytes in the image.
+ * Flush it, and keep going.
+ */
if (priv->image_module == NULL)
{
GError *tmp = NULL;
if (priv->image_module && priv->image_module->stop_load && priv->context)
{
- if (!priv->image_module->stop_load (priv->context, error))
- retval = FALSE;
+ GError *tmp = NULL;
+ if (!priv->image_module->stop_load (priv->context, &tmp) || tmp)
+ {
+ /* don't call gdk_pixbuf_loader_ensure_error()
+ * here, since we might not get an error in the
+ * gdk_pixbuf_get_file_info() case
+ */
+ if (tmp)
+ g_propagate_error (error, tmp);
+ retval = FALSE;
+ }
}
priv->closed = TRUE;
+ if (priv->image_module && priv->holds_threadlock) {
+ _gdk_pixbuf_unlock (priv->image_module);
+ priv->holds_threadlock = FALSE;
+ }
if (priv->needs_scale)
{
- GdkPixbuf *tmp, *pixbuf;
-
- tmp = gdk_pixbuf_animation_get_static_image (priv->animation);
- g_object_ref (tmp);
- pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, tmp->has_alpha, 8, priv->width, priv->height);
- g_object_unref (priv->animation);
- priv->animation = gdk_pixbuf_non_anim_new (pixbuf);
- g_object_unref (pixbuf);
+
g_signal_emit (loader, pixbuf_loader_signals[AREA_PREPARED], 0);
- gdk_pixbuf_scale (tmp, pixbuf, 0, 0, priv->width, priv->height, 0, 0,
- (double) priv->width / tmp->width,
- (double) priv->height / tmp->height,
- GDK_INTERP_BILINEAR);
- g_object_unref (tmp);
-
g_signal_emit (loader, pixbuf_loader_signals[AREA_UPDATED], 0,
0, 0, priv->width, priv->height);
}
*
* Returns: A #GdkPixbufFormat or %NULL. The return value is owned
* by GdkPixbuf and should not be freed.
+ *
+ * Since: 2.2
*/
GdkPixbufFormat *
gdk_pixbuf_loader_get_format (GdkPixbufLoader *loader)
}
-
+#define __GDK_PIXBUF_LOADER_C__
+#include "gdk-pixbuf-aliasdef.c"
projects / ~andy / gtk / blobdiff