gdk_pixbuf2 1.0.3-x86-mingw32 → 1.1.0-x86-mingw32

data/ext/gdk_pixbuf2/rbgdk-pixdata.c

@@ -1,23 +1,34 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
-/************************************************
-
-  rbgdk-pixdata.c -
-
-  $Author: ggc $
-  $Date: 2007/07/13 16:07:28 $
-
-  Copyright (C) 2002,2003 Masao Mutoh
-************************************************/
-#include "rbgdk-pixbuf.h"
+/*
+ *  Copyright (C) 2011  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002,2003 Masao Mutoh
+ *
+ *  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 2.1 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, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *  MA  02110-1301  USA
+ */
+
+#include "rbgdk-pixbuf2private.h"
 
 #define GDK_TYPE_PIXDATA (gdk_pixdata_get_type())
-#define _SELF(s) ((GdkPixdata*)(RVAL2BOXED(s, GDK_TYPE_PIXDATA)))
-#define PIXDATA2RVAL(pix) (BOXED2RVAL(pix, GDK_TYPE_PIXDATA))
+#define RG_TARGET_NAMESPACE cPixdata
+#define _SELF(s) (RVAL2GDKPIXDATA(s))
 
 static ID id_pixdata;
 
 /*****************************************/
-GdkPixdata*
+static GdkPixdata *
 gdk_pixdata_copy(const GdkPixdata* src)
 {
   GdkPixdata* data;
@@ -27,8 +38,8 @@ gdk_pixdata_copy(const GdkPixdata* src)
   return data;
 }
 
-GType
-gdk_pixdata_get_type (void)
+static GType
+gdk_pixdata_get_type(void)
 {
   static GType our_type = 0;
   if (our_type == 0)
@@ -39,11 +50,11 @@ gdk_pixdata_get_type (void)
 }
 /*****************************************/
 static VALUE
-pixdata_s_from_pixbuf(VALUE self, VALUE pixbuf, VALUE use_rle)
+rg_s_from_pixbuf(G_GNUC_UNUSED VALUE self, VALUE pixbuf, VALUE use_rle)
 {
     GdkPixdata pixdata;
-    gpointer rle_data = gdk_pixdata_from_pixbuf(&pixdata, RVAL2GOBJ(pixbuf), RVAL2CBOOL(use_rle));
-    VALUE ret = PIXDATA2RVAL(&pixdata);
+    gpointer rle_data = gdk_pixdata_from_pixbuf(&pixdata, RVAL2GDKPIXBUF(pixbuf), RVAL2CBOOL(use_rle));
+    VALUE ret = GDKPIXDATA2RVAL(&pixdata);
     if (use_rle){
         /* need to manage the returned value */
         rb_ivar_set(ret, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, rle_data));
@@ -52,7 +63,7 @@ pixdata_s_from_pixbuf(VALUE self, VALUE pixbuf, VALUE use_rle)
 }
 
 static VALUE
-pixdata_to_pixbuf(VALUE self, VALUE copy_pixels)
+rg_to_pixbuf(VALUE self, VALUE copy_pixels)
 {
     GError* error = NULL;
     GdkPixbuf* ret = gdk_pixbuf_from_pixdata(_SELF(self), RVAL2CBOOL(copy_pixels), &error);
@@ -62,7 +73,7 @@ pixdata_to_pixbuf(VALUE self, VALUE copy_pixels)
 }
 
 static VALUE
-pixdata_serialize(VALUE self)
+rg_serialize(VALUE self)
 {
     guint stream_length;
     guint i;
@@ -75,32 +86,26 @@ pixdata_serialize(VALUE self)
 }
 
 static VALUE
-pixdata_s_deserialize(VALUE self, VALUE stream)
+rg_s_deserialize(VALUE self, VALUE rbstream)
 {
     GdkPixdata pixdata;
-    gboolean ret;
-    guint8 *gstream;
-    GError* error = NULL;
-    gint i, len;
+    long n;
+    guint8 *stream = RVAL2GUINT8S(rbstream, n);
+    GError *error = NULL;
 
-    len = RARRAY_LEN(stream);
-    gstream = g_new(guint8, len);
-    //   gstream = ALLOCA_N(guint8, len);
-    for (i = 0; i < len; i++){
-        gstream[i] = (guint8)NUM2UINT(RARRAY_PTR(stream)[i]);
-    }
-    ret = gdk_pixdata_deserialize(&pixdata, len, gstream, &error);
+    /* TODO: Should we really be creating a new array here?  As far as I can
+       tell, the data is copied. */
+    if (!gdk_pixdata_deserialize(&pixdata, n, stream, &error))
+        RAISE_GERROR(error);
 
     /* need to manage the returned value */
-    rb_ivar_set(ret, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, gstream));
+    rb_ivar_set(self, id_pixdata, Data_Wrap_Struct(rb_cData, NULL, g_free, stream));
 
-    if (ret != TRUE) RAISE_GERROR(error);
-
-    return PIXDATA2RVAL(&pixdata);
+    return GDKPIXDATA2RVAL(&pixdata);
 }
 
 static VALUE
-pixdata_to_csource(VALUE self, VALUE name, VALUE dump_type)
+rg_to_csource(VALUE self, VALUE name, VALUE dump_type)
 {
     GString* str = gdk_pixdata_to_csource(_SELF(self), RVAL2CSTR(name), FIX2INT(dump_type));
     VALUE ret = CSTR2RVAL(str->str);
@@ -110,13 +115,13 @@ pixdata_to_csource(VALUE self, VALUE name, VALUE dump_type)
 
 /* GdkPixdata */
 static VALUE
-pixdata_magic(VALUE self)
+rg_magic(VALUE self)
 {
     return UINT2NUM(_SELF(self)->magic);
 }
 
 static VALUE
-pixdata_length(VALUE self)
+rg_length(VALUE self)
 {
     gint32 length = _SELF(self)->length;
 
@@ -126,31 +131,31 @@ pixdata_length(VALUE self)
 }
 
 static VALUE
-pixdata_pixdata_type(VALUE self)
+rg_pixdata_type(VALUE self)
 {
     return UINT2NUM(_SELF(self)->pixdata_type);
 }
 
 static VALUE
-pixdata_rowstride(VALUE self)
+rg_rowstride(VALUE self)
 {
     return INT2NUM(_SELF(self)->rowstride);
 }
 
 static VALUE
-pixdata_width(VALUE self)
+rg_width(VALUE self)
 {
     return INT2NUM(_SELF(self)->width);
 }
 
 static VALUE
-pixdata_height(VALUE self)
+rg_height(VALUE self)
 {
     return INT2NUM(_SELF(self)->height);
 }
 
 static VALUE
-pixdata_pixel_data(VALUE self)
+rg_pixel_data(VALUE self)
 {
     gint i;
     guint8* ret = _SELF(self)->pixel_data;
@@ -163,47 +168,46 @@ pixdata_pixel_data(VALUE self)
     return ary;
 }
 
-
 void
 Init_gdk_pixdata(VALUE mGdk)
 {
-    VALUE pixdata = G_DEF_CLASS(GDK_TYPE_PIXDATA, "Pixdata", mGdk);    
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_PIXDATA, "Pixdata", mGdk);    
 
     id_pixdata = rb_intern("pixdata");
 
-    rb_define_singleton_method(pixdata, "from_pixbuf", pixdata_s_from_pixbuf, 2);
-    rb_define_singleton_method(pixdata, "deserialize", pixdata_s_deserialize, 1);
-    rb_define_method(pixdata, "to_pixbuf", pixdata_to_pixbuf, 1);
-    rb_define_method(pixdata, "serialize", pixdata_serialize, 0);
-    rb_define_method(pixdata, "to_csource", pixdata_to_csource, 2);
-    rb_define_method(pixdata, "magic", pixdata_magic, 0);
-    rb_define_method(pixdata, "length", pixdata_length, 0);
-    rb_define_method(pixdata, "pixdata_type", pixdata_pixdata_type, 0);
-    rb_define_method(pixdata, "rowstride", pixdata_rowstride, 0);
-    rb_define_method(pixdata, "width", pixdata_width, 0);
-    rb_define_method(pixdata, "height", pixdata_height, 0);
-    rb_define_method(pixdata, "pixel_data", pixdata_pixel_data, 0);
-
-    rb_define_const(pixdata, "PIXBUF_MAGIC_NUMBER", INT2NUM(GDK_PIXBUF_MAGIC_NUMBER));
-    rb_define_const(pixdata, "HEADER_LENGTH", INT2NUM(GDK_PIXDATA_HEADER_LENGTH));
+    RG_DEF_SMETHOD(from_pixbuf, 2);
+    RG_DEF_SMETHOD(deserialize, 1);
+    RG_DEF_METHOD(to_pixbuf, 1);
+    RG_DEF_METHOD(serialize, 0);
+    RG_DEF_METHOD(to_csource, 2);
+    RG_DEF_METHOD(magic, 0);
+    RG_DEF_METHOD(length, 0);
+    RG_DEF_METHOD(pixdata_type, 0);
+    RG_DEF_METHOD(rowstride, 0);
+    RG_DEF_METHOD(width, 0);
+    RG_DEF_METHOD(height, 0);
+    RG_DEF_METHOD(pixel_data, 0);
+
+    rb_define_const(RG_TARGET_NAMESPACE, "PIXBUF_MAGIC_NUMBER", INT2NUM(GDK_PIXBUF_MAGIC_NUMBER));
+    rb_define_const(RG_TARGET_NAMESPACE, "HEADER_LENGTH", INT2NUM(GDK_PIXDATA_HEADER_LENGTH));
 
     /* GdkPixdataType */
-    rb_define_const(pixdata, "COLOR_TYPE_RGB", INT2FIX(GDK_PIXDATA_COLOR_TYPE_RGB));
-    rb_define_const(pixdata, "COLOR_TYPE_RGBA", INT2FIX(GDK_PIXDATA_COLOR_TYPE_RGBA));
-    rb_define_const(pixdata, "COLOR_TYPE_MASK", INT2FIX(GDK_PIXDATA_COLOR_TYPE_MASK));
-    rb_define_const(pixdata, "SAMPLE_WIDTH_8", INT2FIX(GDK_PIXDATA_SAMPLE_WIDTH_8));
-    rb_define_const(pixdata, "SAMPLE_WIDTH_MASK", INT2FIX(GDK_PIXDATA_SAMPLE_WIDTH_MASK));
-    rb_define_const(pixdata, "ENCODING_RAW", INT2FIX(GDK_PIXDATA_ENCODING_RAW));
-    rb_define_const(pixdata, "ENCODING_RLE", INT2FIX(GDK_PIXDATA_ENCODING_RLE));
-    rb_define_const(pixdata, "ENCODING_MASK", INT2FIX(GDK_PIXDATA_ENCODING_MASK));
+    rb_define_const(RG_TARGET_NAMESPACE, "COLOR_TYPE_RGB", INT2FIX(GDK_PIXDATA_COLOR_TYPE_RGB));
+    rb_define_const(RG_TARGET_NAMESPACE, "COLOR_TYPE_RGBA", INT2FIX(GDK_PIXDATA_COLOR_TYPE_RGBA));
+    rb_define_const(RG_TARGET_NAMESPACE, "COLOR_TYPE_MASK", INT2FIX(GDK_PIXDATA_COLOR_TYPE_MASK));
+    rb_define_const(RG_TARGET_NAMESPACE, "SAMPLE_WIDTH_8", INT2FIX(GDK_PIXDATA_SAMPLE_WIDTH_8));
+    rb_define_const(RG_TARGET_NAMESPACE, "SAMPLE_WIDTH_MASK", INT2FIX(GDK_PIXDATA_SAMPLE_WIDTH_MASK));
+    rb_define_const(RG_TARGET_NAMESPACE, "ENCODING_RAW", INT2FIX(GDK_PIXDATA_ENCODING_RAW));
+    rb_define_const(RG_TARGET_NAMESPACE, "ENCODING_RLE", INT2FIX(GDK_PIXDATA_ENCODING_RLE));
+    rb_define_const(RG_TARGET_NAMESPACE, "ENCODING_MASK", INT2FIX(GDK_PIXDATA_ENCODING_MASK));
 
     /* GdkPixdataDumpType */
-    rb_define_const(pixdata, "DUMP_PIXDATA_STREAM", INT2FIX(GDK_PIXDATA_DUMP_PIXDATA_STREAM));
-    rb_define_const(pixdata, "DUMP_PIXDATA_STRUCT", INT2FIX(GDK_PIXDATA_DUMP_PIXDATA_STRUCT));
-    rb_define_const(pixdata, "DUMP_MACROS", INT2FIX(GDK_PIXDATA_DUMP_MACROS));
-    rb_define_const(pixdata, "DUMP_GTYPES", INT2FIX(GDK_PIXDATA_DUMP_GTYPES));
-    rb_define_const(pixdata, "DUMP_CTYPES", INT2FIX(GDK_PIXDATA_DUMP_CTYPES));
-    rb_define_const(pixdata, "DUMP_STATIC", INT2FIX(GDK_PIXDATA_DUMP_STATIC));
-    rb_define_const(pixdata, "DUMP_CONST", INT2FIX(GDK_PIXDATA_DUMP_CONST));
-    rb_define_const(pixdata, "DUMP_RLE_DECODER", INT2FIX(GDK_PIXDATA_DUMP_RLE_DECODER));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_PIXDATA_STREAM", INT2FIX(GDK_PIXDATA_DUMP_PIXDATA_STREAM));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_PIXDATA_STRUCT", INT2FIX(GDK_PIXDATA_DUMP_PIXDATA_STRUCT));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_MACROS", INT2FIX(GDK_PIXDATA_DUMP_MACROS));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_GTYPES", INT2FIX(GDK_PIXDATA_DUMP_GTYPES));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_CTYPES", INT2FIX(GDK_PIXDATA_DUMP_CTYPES));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_STATIC", INT2FIX(GDK_PIXDATA_DUMP_STATIC));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_CONST", INT2FIX(GDK_PIXDATA_DUMP_CONST));
+    rb_define_const(RG_TARGET_NAMESPACE, "DUMP_RLE_DECODER", INT2FIX(GDK_PIXDATA_DUMP_RLE_DECODER));
 }

data/vendor/local/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-animation.h

@@ -38,7 +38,20 @@ G_BEGIN_DECLS
 
 /* Animation support */
 
+/**
+ * GdkPixbufAnimation:
+ * 
+ * An opaque struct representing an animation.
+ */
 typedef struct _GdkPixbufAnimation GdkPixbufAnimation;
+
+
+/**
+ * GdkPixbufAnimationIter:
+ * 
+ * An opaque struct representing an iterator which points to a
+ * certain position in an animation.
+ */
 typedef struct _GdkPixbufAnimationIter GdkPixbufAnimationIter;
 
 #define GDK_TYPE_PIXBUF_ANIMATION              (gdk_pixbuf_animation_get_type ())
@@ -82,6 +95,18 @@ gboolean                gdk_pixbuf_animation_iter_advance                    (Gd
 
 
 
+/**
+ * GdkPixbufAnimationClass:
+ * @parent_class: the parent class
+ * @is_static_image: returns whether the given animation is just a static image.
+ * @get_static_image: returns a static image representing the given animation.
+ * @get_size: fills @width and @height with the frame size of the animation.
+ * @get_iter: returns an iterator for the given animation.
+ * 
+ * Modules supporting animations must derive a type from 
+ * #GdkPixbufAnimation, providing suitable implementations of the 
+ * virtual functions.
+ */
 typedef struct _GdkPixbufAnimationClass GdkPixbufAnimationClass;
 
 #define GDK_PIXBUF_ANIMATION_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_ANIMATION, GdkPixbufAnimationClass))
@@ -114,6 +139,21 @@ struct _GdkPixbufAnimationClass {
 
 
 
+/**
+ * GdkPixbufAnimationIterClass:
+ * @parent_class: the parent class
+ * @get_delay_time: returns the time in milliseconds that the current frame 
+ *  should be shown.
+ * @get_pixbuf: returns the current frame.
+ * @on_currently_loading_frame: returns whether the current frame of @iter is 
+ *  being loaded.
+ * @advance: advances the iterator to @current_time, possibly changing the 
+ *  current frame.
+ * 
+ * Modules supporting animations must derive a type from 
+ * #GdkPixbufAnimationIter, providing suitable implementations of the 
+ * virtual functions.
+ */
 typedef struct _GdkPixbufAnimationIterClass GdkPixbufAnimationIterClass;
 
 #define GDK_PIXBUF_ANIMATION_ITER_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_ANIMATION_ITER, GdkPixbufAnimationIterClass))

data/vendor/local/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-core.h

@@ -36,15 +36,122 @@
 
 G_BEGIN_DECLS
 
-/* Alpha compositing mode */
+/**
+ * SECTION:gdk-pixbuf
+ * @Short_description: Information that describes an image.
+ * @Title: The GdkPixbuf Structure
+ * 
+ * 
+ * The #GdkPixbuf structure contains
+ * information that describes an image in memory.
+ * 
+ * 
+ * <section id="image-data">
+ * <title>Image Data</title>
+ * <para>
+ * Image data in a pixbuf is stored in memory in uncompressed,
+ * packed format.  Rows in the image are stored top to bottom, and
+ * in each row pixels are stored from left to right.  There may be
+ * padding at the end of a row.  The "rowstride" value of a pixbuf,
+ * as returned by gdk_pixbuf_get_rowstride(), indicates the number
+ * of bytes between rows.
+ * 
+ * 
+ * <example id="put-pixel">
+ * <title>put_pixel(<!-- -->) example</title>
+ * <para>
+ * 
+ * The following code illustrates a simple put_pixel(<!-- -->)
+ * function for RGB pixbufs with 8 bits per channel with an alpha
+ * channel.  It is not included in the gdk-pixbuf library for
+ * performance reasons; rather than making several function calls
+ * for each pixel, your own code can take shortcuts.
+ * 
+ * 
+ * <programlisting>
+ * static void
+ * put_pixel (GdkPixbuf *pixbuf, int x, int y, guchar red, guchar green, guchar blue, guchar alpha)
+ * {
+ *   int width, height, rowstride, n_channels;
+ *   guchar *pixels, *p;
+ * 
+ *   n_channels = gdk_pixbuf_get_n_channels (pixbuf);
+ * 
+ *   g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
+ *   g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
+ *   g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
+ *   g_assert (n_channels == 4);
+ * 
+ *   width = gdk_pixbuf_get_width (pixbuf);
+ *   height = gdk_pixbuf_get_height (pixbuf);
+ * 
+ *   g_assert (x >= 0 && x < width);
+ *   g_assert (y >= 0 && y < height);
+ * 
+ *   rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+ *   pixels = gdk_pixbuf_get_pixels (pixbuf);
+ * 
+ *   p = pixels + y * rowstride + x * n_channels;
+ *   p[0] = red;
+ *   p[1] = green;
+ *   p[2] = blue;
+ *   p[3] = alpha;
+ * }
+ * </programlisting>
+ * 
+ * This function will not work for pixbufs with images that are
+ * other than 8 bits per sample or channel, but it will work for
+ * most of the pixbufs that GTK+ uses.
+ * </para>
+ * </example>
+ * 
+ * <note>
+ * If you are doing memcpy() of raw pixbuf data, note that the
+ * last row in the pixbuf may not be as wide as the full
+ * rowstride, but rather just as wide as the pixel data needs to
+ * be.  That is, it is unsafe to do <literal>memcpy (dest,
+ * pixels, rowstride * height)</literal> to copy a whole pixbuf.
+ * Use gdk_pixbuf_copy() instead, or compute the width in bytes
+ * of the last row as <literal>width * ((n_channels *
+ * bits_per_sample + 7) / 8)</literal>.
+ * </note>
+ * </para>
+ * </section>
+ */
+
+
+/**
+ * GdkPixbufAlphaMode:
+ * @GDK_PIXBUF_ALPHA_BILEVEL: A bilevel clipping mask (black and white)
+ *  will be created and used to draw the image.  Pixels below 0.5 opacity
+ *  will be considered fully transparent, and all others will be
+ *  considered fully opaque.
+ * @GDK_PIXBUF_ALPHA_FULL: For now falls back to #GDK_PIXBUF_ALPHA_BILEVEL.
+ *  In the future it will do full alpha compositing.
+ * 
+ * These values can be passed to
+ * gdk_pixbuf_render_to_drawable_alpha() to control how the alpha
+ * channel of an image should be handled.  This function can create a
+ * bilevel clipping mask (black and white) and use it while painting
+ * the image.  In the future, when the X Window System gets an alpha
+ * channel extension, it will be possible to do full alpha
+ * compositing onto arbitrary drawables.  For now both cases fall
+ * back to a bilevel clipping mask.
+ */
 typedef enum
 {
         GDK_PIXBUF_ALPHA_BILEVEL,
         GDK_PIXBUF_ALPHA_FULL
 } GdkPixbufAlphaMode;
 
-/* Color spaces; right now only RGB is supported.
- * Note that these values are encoded in inline pixbufs
+/**
+ * GdkColorspace:
+ * @GDK_COLORSPACE_RGB: Indicates a red/green/blue additive color space.
+ * 
+ * This enumeration defines the color spaces that are supported by
+ * the &gdk-pixbuf; library.  Currently only RGB is supported.
+ */
+/* Note that these values are encoded in inline pixbufs
  * as ints, so don't reorder them
  */
 typedef enum {
@@ -52,6 +159,16 @@ typedef enum {
 } GdkColorspace;
 
 /* All of these are opaque structures */
+
+/**
+ * GdkPixbuf:
+ * 
+ * This is the main structure in the &gdk-pixbuf; library.  It is
+ * used to represent images.  It contains information about the
+ * image's pixel data, its color space, bits per sample, width and
+ * height, and the rowstride (the number of bytes between the start of
+ * one row and the start of the next). 
+ */
 typedef struct _GdkPixbuf GdkPixbuf;
 
 #define GDK_TYPE_PIXBUF              (gdk_pixbuf_get_type ())
@@ -59,11 +176,43 @@ typedef struct _GdkPixbuf GdkPixbuf;
 #define GDK_IS_PIXBUF(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF))
 
 
-/* Handler that must free the pixel array */
+/**
+ * GdkPixbufDestroyNotify:
+ * @pixels: The pixel array of the pixbuf that is being finalized.
+ * @data: User closure data.
+ * 
+ * A function of this type is responsible for freeing the pixel array
+ * of a pixbuf.  The gdk_pixbuf_new_from_data() function lets you
+ * pass in a pre-allocated pixel array so that a pixbuf can be
+ * created from it; in this case you will need to pass in a function
+ * of #GdkPixbufDestroyNotify so that the pixel data can be freed
+ * when the pixbuf is finalized.
+ */
 typedef void (* GdkPixbufDestroyNotify) (guchar *pixels, gpointer data);
 
+/**
+ * GDK_PIXBUF_ERROR:
+ * 
+ * Error domain used for pixbuf operations. Indicates that the error code
+ * will be in the #GdkPixbufError enumeration. See #GError for
+ * information on error domains and error codes.
+ */
 #define GDK_PIXBUF_ERROR gdk_pixbuf_error_quark ()
 
+/**
+ * GdkPixbufError:
+ * @GDK_PIXBUF_ERROR_CORRUPT_IMAGE: An image file was broken somehow.
+ * @GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY: Not enough memory.
+ * @GDK_PIXBUF_ERROR_BAD_OPTION: A bad option was passed to a pixbuf save module.
+ * @GDK_PIXBUF_ERROR_UNKNOWN_TYPE: Unknown image type.
+ * @GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION: Don't know how to perform the
+ *  given operation on the type of image at hand.
+ * @GDK_PIXBUF_ERROR_FAILED: Generic failure code, something went wrong.
+ * 
+ * An error code in the #GDK_PIXBUF_ERROR domain. Many &gdk-pixbuf;
+ * operations can cause errors in this domain, or in the #G_FILE_ERROR
+ * domain.
+ */
 typedef enum {
         /* image data hosed */
         GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
@@ -182,6 +331,25 @@ gboolean gdk_pixbuf_savev          (GdkPixbuf  *pixbuf,
 
 /* Saving to a callback function */
 
+
+/**
+ * GdkPixbufSaveFunc:
+ * @buf: bytes to be written.
+ * @count: number of bytes in @buf. 
+ * @error: (out): A location to return an error.
+ * @data: (closure): user data passed to gdk_pixbuf_save_to_callback(). 
+ * 
+ * Specifies the type of the function passed to
+ * gdk_pixbuf_save_to_callback().  It is called once for each block of
+ * bytes that is "written" by gdk_pixbuf_save_to_callback().  If
+ * successful it should return %TRUE.  If an error occurs it should set
+ * @error and return %FALSE, in which case gdk_pixbuf_save_to_callback()
+ * will fail with the same error.
+ * 
+ * Since: 2.4
+ * Returns: %TRUE if successful, %FALSE (with @error set) if failed.
+ */
+
 typedef gboolean (*GdkPixbufSaveFunc)   (const gchar *buf,
 					 gsize count,
 					 GError **error,
@@ -223,6 +391,14 @@ GdkPixbuf *gdk_pixbuf_new_from_stream   (GInputStream   *stream,
 					 GCancellable   *cancellable,
                                          GError        **error);
 
+void gdk_pixbuf_new_from_stream_async (GInputStream        *stream,
+				       GCancellable        *cancellable,
+				       GAsyncReadyCallback  callback,
+				       gpointer             user_data);
+
+GdkPixbuf *gdk_pixbuf_new_from_stream_finish (GAsyncResult  *async_result,
+					      GError       **error);
+
 GdkPixbuf *gdk_pixbuf_new_from_stream_at_scale   (GInputStream   *stream,
                                                   gint            width,
                                                   gint            height,
@@ -230,6 +406,14 @@ GdkPixbuf *gdk_pixbuf_new_from_stream_at_scale   (GInputStream   *stream,
 						  GCancellable   *cancellable,
                                                   GError        **error);
 
+void gdk_pixbuf_new_from_stream_at_scale_async (GInputStream        *stream,
+						gint                 width,
+						gint                 height,
+						gboolean             preserve_aspect_ratio,
+						GCancellable        *cancellable,
+						GAsyncReadyCallback  callback,
+						gpointer             user_data);
+
 gboolean   gdk_pixbuf_save_to_stream    (GdkPixbuf      *pixbuf,
                                          GOutputStream  *stream,
                                          const char     *type,
@@ -237,6 +421,17 @@ gboolean   gdk_pixbuf_save_to_stream    (GdkPixbuf      *pixbuf,
                                          GError        **error,
                                          ...);
 
+void gdk_pixbuf_save_to_stream_async (GdkPixbuf           *pixbuf,
+				      GOutputStream       *stream,
+				      const gchar         *type,
+				      GCancellable        *cancellable,
+				      GAsyncReadyCallback  callback,
+				      gpointer             user_data,
+				      ...);
+
+gboolean gdk_pixbuf_save_to_stream_finish (GAsyncResult  *async_result,
+					   GError       **error);
+
 /* Adding an alpha channel */
 GdkPixbuf *gdk_pixbuf_add_alpha (const GdkPixbuf *pixbuf, gboolean substitute_color,
 				 guchar r, guchar g, guchar b);
@@ -257,7 +452,7 @@ void gdk_pixbuf_saturate_and_pixelate (const GdkPixbuf *src,
 /* Transform an image to agree with its embedded orientation option / tag */
 GdkPixbuf *gdk_pixbuf_apply_embedded_orientation (GdkPixbuf *src);
 
-G_CONST_RETURN gchar * gdk_pixbuf_get_option (GdkPixbuf   *pixbuf,
+const gchar * gdk_pixbuf_get_option (GdkPixbuf   *pixbuf,
                                               const gchar *key);