Initial commit0.0.0

11 files changed, 1759 insertions, 0 deletions

diff --git a/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-animation.h b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-animation.h
new file mode 100644
index 0000000..8213e94
--- /dev/null
+++ b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-animation.h
@@ -0,0 +1,195 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
+/* GdkPixbuf library - Animation support
+ *
+ * Copyright (C) 1999 The Free Software Foundation
+ *
+ * Authors: Mark Crichton <crichton@gimp.org>
+ *          Miguel de Icaza <miguel@gnu.org>
+ *          Federico Mena-Quintero <federico@gimp.org>
+ *          Havoc Pennington <hp@redhat.com>
+ *
+ * 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 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#if defined(GDK_PIXBUF_DISABLE_SINGLE_INCLUDES) && !defined (GDK_PIXBUF_H_INSIDE) && !defined (GDK_PIXBUF_COMPILATION)
+#error "Only <gdk-pixbuf/gdk-pixbuf.h> can be included directly."
+#endif
+
+#ifndef GDK_PIXBUF_ANIMATION_H
+#define GDK_PIXBUF_ANIMATION_H
+
+#include <glib-object.h>
+#include <gdk-pixbuf/gdk-pixbuf-core.h>
+
+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 ())
+#define GDK_PIXBUF_ANIMATION(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_ANIMATION, GdkPixbufAnimation))
+#define GDK_IS_PIXBUF_ANIMATION(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_ANIMATION))
+
+#define GDK_TYPE_PIXBUF_ANIMATION_ITER              (gdk_pixbuf_animation_iter_get_type ())
+#define GDK_PIXBUF_ANIMATION_ITER(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_ANIMATION_ITER, GdkPixbufAnimationIter))
+#define GDK_IS_PIXBUF_ANIMATION_ITER(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_ANIMATION_ITER))
+
+GType               gdk_pixbuf_animation_get_type        (void) G_GNUC_CONST;
+
+#ifndef __GTK_DOC_IGNORE__
+#ifdef G_OS_WIN32
+#define gdk_pixbuf_animation_new_from_file gdk_pixbuf_animation_new_from_file_utf8
+#endif
+#endif
+
+GdkPixbufAnimation *gdk_pixbuf_animation_new_from_file   (const char         *filename,
+                                                          GError            **error);
+
+#ifndef GDK_PIXBUF_DISABLE_DEPRECATED
+G_DEPRECATED_FOR(g_object_ref)
+GdkPixbufAnimation *gdk_pixbuf_animation_ref             (GdkPixbufAnimation *animation);
+G_DEPRECATED_FOR(g_object_unref)
+void                gdk_pixbuf_animation_unref           (GdkPixbufAnimation *animation);
+#endif
+
+int                 gdk_pixbuf_animation_get_width       (GdkPixbufAnimation *animation);
+int                 gdk_pixbuf_animation_get_height      (GdkPixbufAnimation *animation);
+gboolean            gdk_pixbuf_animation_is_static_image  (GdkPixbufAnimation *animation);
+GdkPixbuf          *gdk_pixbuf_animation_get_static_image (GdkPixbufAnimation *animation);
+
+GdkPixbufAnimationIter *gdk_pixbuf_animation_get_iter                        (GdkPixbufAnimation     *animation,
+                                                                              const GTimeVal         *start_time);
+GType                   gdk_pixbuf_animation_iter_get_type                   (void) G_GNUC_CONST;
+int                     gdk_pixbuf_animation_iter_get_delay_time             (GdkPixbufAnimationIter *iter);
+GdkPixbuf              *gdk_pixbuf_animation_iter_get_pixbuf                 (GdkPixbufAnimationIter *iter);
+gboolean                gdk_pixbuf_animation_iter_on_currently_loading_frame (GdkPixbufAnimationIter *iter);
+gboolean                gdk_pixbuf_animation_iter_advance                    (GdkPixbufAnimationIter *iter,
+                                                                              const GTimeVal         *current_time);
+
+
+#ifdef GDK_PIXBUF_ENABLE_BACKEND
+
+
+
+/**
+ * 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))
+#define GDK_IS_PIXBUF_ANIMATION_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_ANIMATION))
+#define GDK_PIXBUF_ANIMATION_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_ANIMATION, GdkPixbufAnimationClass))
+
+/* Private part of the GdkPixbufAnimation structure */
+struct _GdkPixbufAnimation {
+        GObject parent_instance;
+
+};
+
+struct _GdkPixbufAnimationClass {
+        GObjectClass parent_class;
+
+        /*< public >*/
+
+        gboolean                (*is_static_image)  (GdkPixbufAnimation *anim);
+
+        GdkPixbuf*              (*get_static_image) (GdkPixbufAnimation *anim);
+        
+        void                    (*get_size) (GdkPixbufAnimation *anim,
+                                             int                 *width,
+                                             int                 *height);
+        
+        GdkPixbufAnimationIter* (*get_iter) (GdkPixbufAnimation *anim,
+                                             const GTimeVal     *start_time);
+
+};
+
+
+
+/**
+ * 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))
+#define GDK_IS_PIXBUF_ANIMATION_ITER_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_ANIMATION_ITER))
+#define GDK_PIXBUF_ANIMATION_ITER_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_ANIMATION_ITER, GdkPixbufAnimationIterClass))
+
+struct _GdkPixbufAnimationIter {
+        GObject parent_instance;
+
+};
+
+struct _GdkPixbufAnimationIterClass {
+        GObjectClass parent_class;
+
+        /*< public >*/
+
+        int        (*get_delay_time)   (GdkPixbufAnimationIter *iter);
+
+        GdkPixbuf* (*get_pixbuf)       (GdkPixbufAnimationIter *iter);
+
+        gboolean   (*on_currently_loading_frame) (GdkPixbufAnimationIter *iter);
+
+        gboolean   (*advance)          (GdkPixbufAnimationIter *iter,
+                                        const GTimeVal         *current_time);
+};
+      
+
+GType               gdk_pixbuf_non_anim_get_type (void) G_GNUC_CONST;
+GdkPixbufAnimation* gdk_pixbuf_non_anim_new (GdkPixbuf *pixbuf);
+
+#endif /* GDK_PIXBUF_ENABLE_BACKEND */
+
+G_END_DECLS
+
+#endif /* GDK_PIXBUF_ANIMATION_H */
diff --git a/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-core.h b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-core.h
new file mode 100644
index 0000000..d777286
--- /dev/null
+++ b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-core.h
@@ -0,0 +1,481 @@
+/* GdkPixbuf library - GdkPixbuf data structure
+ *
+ * Copyright (C) 2003 The Free Software Foundation
+ *
+ * Authors: Mark Crichton <crichton@gimp.org>
+ *          Miguel de Icaza <miguel@gnu.org>
+ *          Federico Mena-Quintero <federico@gimp.org>
+ *          Havoc Pennington <hp@redhat.com>
+ *
+ * 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 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#if defined(GDK_PIXBUF_DISABLE_SINGLE_INCLUDES) && !defined (GDK_PIXBUF_H_INSIDE) && !defined (GDK_PIXBUF_COMPILATION)
+#error "Only <gdk-pixbuf/gdk-pixbuf.h> can be included directly."
+#endif
+
+#ifndef GDK_PIXBUF_CORE_H
+#define GDK_PIXBUF_CORE_H
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+/**
+ * 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;
+
+/**
+ * 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 {
+	GDK_COLORSPACE_RGB
+} 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 ())
+#define GDK_PIXBUF(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF, GdkPixbuf))
+#define GDK_IS_PIXBUF(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF))
+
+
+/**
+ * GdkPixbufDestroyNotify:
+ * @pixels: (array) (element-type guint8): The pixel array of the pixbuf
+ *   that is being finalized.
+ * @data: (closure): 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,
+        /* no mem to load image */
+        GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+        /* bad option passed to save routine */
+        GDK_PIXBUF_ERROR_BAD_OPTION,
+        /* unsupported image type (sort of an ENOSYS) */
+        GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
+        /* unsupported operation (load, save) for image type */
+        GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION,
+        GDK_PIXBUF_ERROR_FAILED
+} GdkPixbufError;
+
+GQuark gdk_pixbuf_error_quark (void);
+
+
+
+GType gdk_pixbuf_get_type (void) G_GNUC_CONST;
+
+/* Reference counting */
+
+#ifndef GDK_PIXBUF_DISABLE_DEPRECATED
+G_DEPRECATED_FOR(g_object_ref)
+GdkPixbuf *gdk_pixbuf_ref      (GdkPixbuf *pixbuf);
+G_DEPRECATED_FOR(g_object_unref)
+void       gdk_pixbuf_unref    (GdkPixbuf *pixbuf);
+#endif
+
+/* GdkPixbuf accessors */
+
+GdkColorspace gdk_pixbuf_get_colorspace      (const GdkPixbuf *pixbuf);
+int           gdk_pixbuf_get_n_channels      (const GdkPixbuf *pixbuf);
+gboolean      gdk_pixbuf_get_has_alpha       (const GdkPixbuf *pixbuf);
+int           gdk_pixbuf_get_bits_per_sample (const GdkPixbuf *pixbuf);
+guchar       *gdk_pixbuf_get_pixels          (const GdkPixbuf *pixbuf);
+int           gdk_pixbuf_get_width           (const GdkPixbuf *pixbuf);
+int           gdk_pixbuf_get_height          (const GdkPixbuf *pixbuf);
+int           gdk_pixbuf_get_rowstride       (const GdkPixbuf *pixbuf);
+gsize         gdk_pixbuf_get_byte_length     (const GdkPixbuf *pixbuf);
+
+guchar       *gdk_pixbuf_get_pixels_with_length (const GdkPixbuf *pixbuf,
+                                                 guint           *length);
+
+
+
+
+/* Create a blank pixbuf with an optimal rowstride and a new buffer */
+GdkPixbuf *gdk_pixbuf_new (GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample,
+			   int width, int height);
+
+/* Copy a pixbuf */
+
+GdkPixbuf *gdk_pixbuf_copy (const GdkPixbuf *pixbuf);
+
+/* Create a pixbuf which points to the pixels of another pixbuf */
+GdkPixbuf *gdk_pixbuf_new_subpixbuf (GdkPixbuf *src_pixbuf,
+                                     int        src_x,
+                                     int        src_y,
+                                     int        width,
+                                     int        height);
+
+/* Simple loading */
+
+#ifndef __GTK_DOC_IGNORE__
+#ifdef G_OS_WIN32
+/* DLL ABI stability hack. */
+#define gdk_pixbuf_new_from_file gdk_pixbuf_new_from_file_utf8
+#define gdk_pixbuf_new_from_file_at_size gdk_pixbuf_new_from_file_at_size_utf8
+#define gdk_pixbuf_new_from_file_at_scale gdk_pixbuf_new_from_file_at_scale_utf8
+#endif
+#endif
+
+GdkPixbuf *gdk_pixbuf_new_from_file (const char *filename,
+                                     GError    **error);
+GdkPixbuf *gdk_pixbuf_new_from_file_at_size (const char *filename,
+					     int         width, 
+					     int         height,
+					     GError    **error);
+GdkPixbuf *gdk_pixbuf_new_from_file_at_scale (const char *filename,
+					      int         width, 
+					      int         height,
+					      gboolean    preserve_aspect_ratio,
+					      GError    **error);
+GdkPixbuf *gdk_pixbuf_new_from_resource (const char *resource_path,
+					 GError    **error);
+GdkPixbuf *gdk_pixbuf_new_from_resource_at_scale (const char *resource_path,
+						  int         width,
+						  int         height,
+						  gboolean    preserve_aspect_ratio,
+						  GError    **error);
+
+GdkPixbuf *gdk_pixbuf_new_from_data (const guchar *data,
+				     GdkColorspace colorspace,
+				     gboolean has_alpha,
+				     int bits_per_sample,
+				     int width, int height,
+				     int rowstride,
+				     GdkPixbufDestroyNotify destroy_fn,
+				     gpointer destroy_fn_data);
+
+GdkPixbuf *gdk_pixbuf_new_from_xpm_data (const char **data);
+GdkPixbuf* gdk_pixbuf_new_from_inline	(gint          data_length,
+					 const guint8 *data,
+					 gboolean      copy_pixels,
+					 GError      **error);
+       
+/* Mutations */
+void       gdk_pixbuf_fill              (GdkPixbuf    *pixbuf,
+                                         guint32       pixel);
+
+/* Saving */
+
+#ifndef __GTK_DOC_IGNORE__
+#ifdef G_OS_WIN32
+/* DLL ABI stability hack. */
+#define gdk_pixbuf_save gdk_pixbuf_save_utf8
+#define gdk_pixbuf_savev gdk_pixbuf_savev_utf8
+#endif
+#endif
+
+gboolean gdk_pixbuf_save           (GdkPixbuf  *pixbuf, 
+                                    const char *filename, 
+                                    const char *type, 
+                                    GError    **error,
+                                    ...) G_GNUC_NULL_TERMINATED;
+
+gboolean gdk_pixbuf_savev          (GdkPixbuf  *pixbuf, 
+                                    const char *filename, 
+                                    const char *type,
+                                    char      **option_keys,
+                                    char      **option_values,
+                                    GError    **error);
+
+/* Saving to a callback function */
+
+
+/**
+ * GdkPixbufSaveFunc:
+ * @buf: (array length=count) (element-type guint8): 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,
+					 gpointer data);
+
+gboolean gdk_pixbuf_save_to_callback    (GdkPixbuf  *pixbuf,
+					 GdkPixbufSaveFunc save_func,
+					 gpointer user_data,
+					 const char *type, 
+					 GError    **error,
+					 ...) G_GNUC_NULL_TERMINATED;
+
+gboolean gdk_pixbuf_save_to_callbackv   (GdkPixbuf  *pixbuf, 
+					 GdkPixbufSaveFunc save_func,
+					 gpointer user_data,
+					 const char *type,
+					 char      **option_keys,
+					 char      **option_values,
+					 GError    **error);
+
+/* Saving into a newly allocated char array */
+
+gboolean gdk_pixbuf_save_to_buffer      (GdkPixbuf  *pixbuf,
+					 gchar     **buffer,
+					 gsize      *buffer_size,
+					 const char *type, 
+					 GError    **error,
+					 ...) G_GNUC_NULL_TERMINATED;
+
+gboolean gdk_pixbuf_save_to_bufferv     (GdkPixbuf  *pixbuf,
+					 gchar     **buffer,
+					 gsize      *buffer_size,
+					 const char *type, 
+					 char      **option_keys,
+					 char      **option_values,
+					 GError    **error);
+
+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,
+                                                  gboolean        preserve_aspect_ratio,
+						  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,
+					 GCancellable   *cancellable,
+                                         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);
+
+/* Copy an area of a pixbuf onto another one */
+void gdk_pixbuf_copy_area (const GdkPixbuf *src_pixbuf,
+			   int src_x, int src_y,
+			   int width, int height,
+			   GdkPixbuf *dest_pixbuf,
+			   int dest_x, int dest_y);
+
+/* Brighten/darken and optionally make it pixelated-looking */
+void gdk_pixbuf_saturate_and_pixelate (const GdkPixbuf *src,
+                                       GdkPixbuf       *dest,
+                                       gfloat           saturation,
+                                       gboolean         pixelate);
+
+/* Transform an image to agree with its embedded orientation option / tag */
+GdkPixbuf *gdk_pixbuf_apply_embedded_orientation (GdkPixbuf *src);
+
+const gchar * gdk_pixbuf_get_option (GdkPixbuf   *pixbuf,
+                                              const gchar *key);
+
+
+G_END_DECLS
+
+
+#endif /* GDK_PIXBUF_CORE_H */
diff --git a/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-enum-types.h b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-enum-types.h
new file mode 100644
index 0000000..3f7e3cd
--- /dev/null
+++ b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-enum-types.h
@@ -0,0 +1,33 @@
+
+/* Generated data (by glib-mkenums) */
+
+#if defined(GDK_PIXBUF_DISABLE_SINGLE_INCLUDES) && !defined (GDK_PIXBUF_H_INSIDE) && !defined (GDK_PIXBUF_COMPILATION)
+#error "Only <gdk-pixbuf/gdk-pixbuf.h> can be included directly."
+#endif
+
+#ifndef __GDK_PIXBUF_ENUM_TYPES_H__
+#define __GDK_PIXBUF_ENUM_TYPES_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/* enumerations from "gdk-pixbuf-core.h" */
+GType gdk_pixbuf_alpha_mode_get_type (void) G_GNUC_CONST;
+#define GDK_TYPE_PIXBUF_ALPHA_MODE (gdk_pixbuf_alpha_mode_get_type ())
+GType gdk_colorspace_get_type (void) G_GNUC_CONST;
+#define GDK_TYPE_COLORSPACE (gdk_colorspace_get_type ())
+GType gdk_pixbuf_error_get_type (void) G_GNUC_CONST;
+#define GDK_TYPE_PIXBUF_ERROR (gdk_pixbuf_error_get_type ())
+
+/* enumerations from "gdk-pixbuf-transform.h" */
+GType gdk_interp_type_get_type (void) G_GNUC_CONST;
+#define GDK_TYPE_INTERP_TYPE (gdk_interp_type_get_type ())
+GType gdk_pixbuf_rotation_get_type (void) G_GNUC_CONST;
+#define GDK_TYPE_PIXBUF_ROTATION (gdk_pixbuf_rotation_get_type ())
+G_END_DECLS
+
+#endif /* __GDK_PIXBUF_ENUM_TYPES_H__ */
+
+/* Generated data ends here */
+
diff --git a/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-features.h b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-features.h
new file mode 100644
index 0000000..4cf8294
--- /dev/null
+++ b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-features.h
@@ -0,0 +1,120 @@
+#if defined(GDK_PIXBUF_DISABLE_SINGLE_INCLUDES) && !defined (GDK_PIXBUF_H_INSIDE) && !defined (GDK_PIXBUF_COMPILATION)
+#error "Only <gdk-pixbuf/gdk-pixbuf.h> can be included directly."
+#endif
+
+#ifndef GDK_PIXBUF_FEATURES_H
+#define GDK_PIXBUF_FEATURES_H 1
+
+#include <glib.h>
+
+/**
+ * SECTION:initialization_versions
+ * @Short_description: 
+Library version numbers.
+ * @Title: Initialization and Versions
+ * 
+ * These macros and variables let you check the version of &gdk-pixbuf;
+ * you're linking against.
+ */
+
+/**
+ * GDK_PIXBUF_MAJOR:
+ * 
+ * Major version of &gdk-pixbuf; library, that is the first "0" in
+ * "0.8.0" for example.
+ */
+/**
+ * GDK_PIXBUF_MINOR:
+ * 
+ * Minor version of &gdk-pixbuf; library, that is the "8" in
+ * "0.8.0" for example.
+ */
+/**
+ * GDK_PIXBUF_MICRO:
+ * 
+ * Micro version of &gdk-pixbuf; library, that is the last "0" in
+ * "0.8.0" for example.
+ */
+/**
+ * GDK_PIXBUF_VERSION:
+ * 
+ * Contains the full version of the &gdk-pixbuf; header as a string.
+ * This is the version being compiled against; contrast with
+ * #gdk_pixbuf_version.
+ */
+
+#define GDK_PIXBUF_MAJOR (2)
+#define GDK_PIXBUF_MINOR (26)
+#define GDK_PIXBUF_MICRO (2)
+#define GDK_PIXBUF_VERSION "2.26.2"
+
+/* We prefix variable declarations so they can
+ * properly get exported/imported from Windows DLLs.
+ */
+#ifdef G_PLATFORM_WIN32
+#  ifdef GDK_PIXBUF_STATIC_COMPILATION
+#    define GDK_PIXBUF_VAR extern
+#  else /* !GDK_PIXBUF_STATIC_COMPILATION */
+#    ifdef GDK_PIXBUF_C_COMPILATION
+#      ifdef DLL_EXPORT
+#        define GDK_PIXBUF_VAR __declspec(dllexport)
+#      else /* !DLL_EXPORT */
+#        define GDK_PIXBUF_VAR extern
+#      endif /* !DLL_EXPORT */
+#    else /* !GDK_PIXBUF_C_COMPILATION */
+#      define GDK_PIXBUF_VAR extern __declspec(dllimport)
+#    endif /* !GDK_PIXBUF_C_COMPILATION */
+#  endif /* !GDK_PIXBUF_STATIC_COMPILATION */
+#else /* !G_PLATFORM_WIN32 */
+#  define GDK_PIXBUF_VAR extern
+#endif /* !G_PLATFORM_WIN32 */
+
+/**
+ * gdk_pixbuf_major_version:
+ * 
+ * The major version number of the &gdk-pixbuf; library.  (e.g. in 
+ * &gdk-pixbuf; version 1.2.5 this is 1.) 
+ * 
+ * 
+ * This variable is in the library, so represents the
+ * &gdk-pixbuf; library you have linked against. Contrast with the
+ * #GDK_PIXBUF_MAJOR macro, which represents the major version of the
+ * &gdk-pixbuf; headers you have included.
+ */
+/**
+ * gdk_pixbuf_minor_version:
+ * 
+ * The minor version number of the &gdk-pixbuf; library.  (e.g. in 
+ * &gdk-pixbuf; version 1.2.5 this is 2.) 
+ * 
+ * 
+ * This variable is in the library, so represents the
+ * &gdk-pixbuf; library you have linked against. Contrast with the
+ * #GDK_PIXBUF_MINOR macro, which represents the minor version of the
+ * &gdk-pixbuf; headers you have included.
+ */
+/**
+ * gdk_pixbuf_micro_version:
+ * 
+ * The micro version number of the &gdk-pixbuf; library.  (e.g. in 
+ * &gdk-pixbuf; version 1.2.5 this is 5.) 
+ * 
+ * 
+ * This variable is in the library, so represents the
+ * &gdk-pixbuf; library you have linked against. Contrast with the
+ * #GDK_PIXBUF_MICRO macro, which represents the micro version of the
+ * &gdk-pixbuf; headers you have included.
+ */
+/**
+ * gdk_pixbuf_version:
+ * 
+ * Contains the full version of the &gdk-pixbuf; library as a string.
+ * This is the version currently in use by a running program.
+ */
+
+GDK_PIXBUF_VAR const guint gdk_pixbuf_major_version;
+GDK_PIXBUF_VAR const guint gdk_pixbuf_minor_version;
+GDK_PIXBUF_VAR const guint gdk_pixbuf_micro_version;
+GDK_PIXBUF_VAR const char *gdk_pixbuf_version;
+
+#endif /* GDK_PIXBUF_FEATURES_H */
diff --git a/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-io.h b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-io.h
new file mode 100644
index 0000000..41a99e4
--- /dev/null
+++ b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-io.h
@@ -0,0 +1,346 @@
+/* GdkPixbuf library - Io handling.  This is an internal header for 
+ * GdkPixbuf. You should never use it unless you are doing development for 
+ * GdkPixbuf itself.
+ *
+ * Copyright (C) 1999 The Free Software Foundation
+ *
+ * Authors: Mark Crichton <crichton@gimp.org>
+ *          Miguel de Icaza <miguel@gnu.org>
+ *          Federico Mena-Quintero <federico@gimp.org>
+ *          Jonathan Blandford <jrb@redhat.com>
+ *          Michael Fulbright <drmike@redhat.com>
+ *
+ * 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 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#if defined(GDK_PIXBUF_DISABLE_SINGLE_INCLUDES) && !defined (GDK_PIXBUF_H_INSIDE) && !defined (GDK_PIXBUF_COMPILATION)
+#error "Only <gdk-pixbuf/gdk-pixbuf.h> can be included directly."
+#endif
+
+#ifndef GDK_PIXBUF_IO_H
+#define GDK_PIXBUF_IO_H
+
+#include <stdio.h>
+#include <glib.h>
+#include <gmodule.h>
+#include <gdk-pixbuf/gdk-pixbuf-core.h>
+#include <gdk-pixbuf/gdk-pixbuf-animation.h>
+
+G_BEGIN_DECLS
+
+typedef struct _GdkPixbufFormat GdkPixbufFormat;
+ 
+GType gdk_pixbuf_format_get_type (void) G_GNUC_CONST;
+
+GSList    *gdk_pixbuf_get_formats            (void);
+gchar     *gdk_pixbuf_format_get_name        (GdkPixbufFormat *format);
+gchar     *gdk_pixbuf_format_get_description (GdkPixbufFormat *format);
+gchar    **gdk_pixbuf_format_get_mime_types  (GdkPixbufFormat *format);
+gchar    **gdk_pixbuf_format_get_extensions  (GdkPixbufFormat *format);
+gboolean   gdk_pixbuf_format_is_writable     (GdkPixbufFormat *format);
+gboolean   gdk_pixbuf_format_is_scalable     (GdkPixbufFormat *format);
+gboolean   gdk_pixbuf_format_is_disabled     (GdkPixbufFormat *format);
+void       gdk_pixbuf_format_set_disabled    (GdkPixbufFormat *format,
+					      gboolean         disabled);
+gchar     *gdk_pixbuf_format_get_license     (GdkPixbufFormat *format);
+
+GdkPixbufFormat *gdk_pixbuf_get_file_info    (const gchar     *filename,
+					      gint            *width, 
+					      gint            *height);
+
+GdkPixbufFormat *gdk_pixbuf_format_copy (const GdkPixbufFormat *format);
+void             gdk_pixbuf_format_free (GdkPixbufFormat       *format);
+
+#ifdef GDK_PIXBUF_ENABLE_BACKEND
+
+
+
+/**
+ * GdkPixbufModuleSizeFunc:
+ * @width: pointer to a location containing the current image width
+ * @height: pointer to a location containing the current image height
+ * @user_data: the loader.
+ * 
+ * Defines the type of the function that gets called once the size 
+ * of the loaded image is known.
+ * 
+ * The function is expected to set @width and @height to the desired
+ * size to which the image should be scaled. If a module has no efficient 
+ * way to achieve the desired scaling during the loading of the image, it may
+ * either ignore the size request, or only approximate it -- &gdk-pixbuf; will
+ * then perform the required scaling on the completely loaded image. 
+ * 
+ * If the function sets @width or @height to zero, the module should interpret
+ * this as a hint that it will be closed soon and shouldn't allocate further 
+ * resources. This convention is used to implement gdk_pixbuf_get_file_info()
+ * efficiently.
+ * 
+ * Since: 2.2
+ */
+typedef void (* GdkPixbufModuleSizeFunc)           (gint *width, 
+						    gint *height, 
+						    gpointer user_data);
+
+/**
+ * GdkPixbufModulePreparedFunc:
+ * @pixbuf: the #GdkPixbuf that is currently being loaded.
+ * @anim: if an animation is being loaded, the #GdkPixbufAnimation, else %NULL.
+ * @user_data: the loader.
+ * 
+ * Defines the type of the function that gets called once the initial 
+ * setup of @pixbuf is done.
+ * 
+ * #GdkPixbufLoader uses a function of this type to emit the 
+ * "<link linkend="GdkPixbufLoader-area-prepared">area_prepared</link>"
+ * signal.
+ * 
+ * Since: 2.2
+ */
+typedef void (* GdkPixbufModulePreparedFunc) (GdkPixbuf          *pixbuf,
+					      GdkPixbufAnimation *anim,
+					      gpointer            user_data);
+
+/**
+ * GdkPixbufModuleUpdatedFunc:
+ * @pixbuf: the #GdkPixbuf that is currently being loaded.
+ * @x: the X origin of the updated area.
+ * @y: the Y origin of the updated area.
+ * @width: the width of the updated area.
+ * @height: the height of the updated area.
+ * @user_data: the loader.
+ * 
+ * Defines the type of the function that gets called every time a region
+ * of @pixbuf is updated.
+ * 
+ * #GdkPixbufLoader uses a function of this type to emit the 
+ * "<link linkend="GdkPixbufLoader-area-updated">area_updated</link>"
+ * signal.
+ * 
+ * Since: 2.2
+ */
+typedef void (* GdkPixbufModuleUpdatedFunc)  (GdkPixbuf *pixbuf,
+					      int        x,
+					      int        y,
+					      int        width,
+					      int        height,
+					      gpointer   user_data);
+
+/**
+ * GdkPixbufModulePattern:
+ * @prefix: the prefix for this pattern
+ * @mask: mask containing bytes which modify how the prefix is matched against
+ *  test data
+ * @relevance: relevance of this pattern
+ * 
+ * The signature of a module is a set of prefixes. Prefixes are encoded as
+ * pairs of ordinary strings, where the second string, called the mask, if 
+ * not %NULL, must be of the same length as the first one and may contain 
+ * ' ', '!', 'x', 'z', and 'n' to indicate bytes that must be matched, 
+ * not matched, "don't-care"-bytes, zeros and non-zeros. 
+ * Each prefix has an associated integer that describes the relevance of 
+ * the prefix, with 0 meaning a mismatch and 100 a "perfect match".
+ * 
+ * Starting with &gdk-pixbuf; 2.8, the first byte of the mask may be '*', 
+ * indicating an unanchored pattern that matches not only at the beginning, 
+ * but also in the middle. Versions prior to 2.8 will interpret the '*'
+ * like an 'x'. 
+ * 
+ * The signature of a module is stored as an array of 
+ * #GdkPixbufModulePattern<!-- -->s. The array is terminated by a pattern
+ * where the @prefix is %NULL.
+ * 
+ * 
+ * <informalexample><programlisting>
+ * GdkPixbufModulePattern *signature[] = {
+ *   { "abcdx", " !x z", 100 },
+ *   { "bla", NULL,  90 },
+ *   { NULL, NULL, 0 }
+ * };
+ * </programlisting>
+ * The example matches e.g. "auud\0" with relevance 100, and "blau" with 
+ * relevance 90.</informalexample>
+ * 
+ * Since: 2.2
+ */
+typedef struct _GdkPixbufModulePattern GdkPixbufModulePattern;
+struct _GdkPixbufModulePattern {
+	char *prefix;
+	char *mask;
+	int relevance;
+};
+
+/**
+ * GdkPixbufModule:
+ * @module_name: the name of the module, usually the same as the
+ *  usual file extension for images of this type, eg. "xpm", "jpeg" or "png".
+ * @module_path: the path from which the module is loaded.
+ * @module: the loaded #GModule.
+ * @info: a #GdkPixbufFormat holding information about the module.
+ * @load: loads an image from a file.
+ * @load_xpm_data: loads an image from data in memory.
+ * @begin_load: begins an incremental load.
+ * @stop_load: stops an incremental load.
+ * @load_increment: continues an incremental load.
+ * @load_animation: loads an animation from a file.
+ * @save: saves a #GdkPixbuf to a file.
+ * @save_to_callback: saves a #GdkPixbuf by calling the given #GdkPixbufSaveFunc.
+ * 
+ * A #GdkPixbufModule contains the necessary functions to load and save 
+ * images in a certain file format. 
+ * 
+ * A #GdkPixbufModule can be loaded dynamically from a #GModule.
+ * Each loadable module must contain a #GdkPixbufModuleFillVtableFunc function 
+ * named <function>fill_vtable</function>, which will get called when the module
+ * is loaded and must set the function pointers of the #GdkPixbufModule. 
+ */
+typedef struct _GdkPixbufModule GdkPixbufModule;
+struct _GdkPixbufModule {
+	char *module_name;
+	char *module_path;
+	GModule *module;
+	GdkPixbufFormat *info;
+	
+        GdkPixbuf *(* load) (FILE    *f,
+                             GError **error);
+        GdkPixbuf *(* load_xpm_data) (const char **data);
+
+        /* Incremental loading */
+
+        gpointer (* begin_load)     (GdkPixbufModuleSizeFunc size_func,
+                                     GdkPixbufModulePreparedFunc prepare_func,
+                                     GdkPixbufModuleUpdatedFunc update_func,
+                                     gpointer user_data,
+                                     GError **error);
+        gboolean (* stop_load)      (gpointer context,
+                                     GError **error);
+        gboolean (* load_increment) (gpointer      context,
+                                     const guchar *buf,
+                                     guint         size,
+                                     GError      **error);
+
+	/* Animation loading */
+	GdkPixbufAnimation *(* load_animation) (FILE    *f,
+                                                GError **error);
+
+        /* Saving */
+        gboolean (* save) (FILE      *f,
+                           GdkPixbuf *pixbuf,
+                           gchar    **param_keys,
+                           gchar    **param_values,
+                           GError   **error);
+
+        gboolean (*save_to_callback) (GdkPixbufSaveFunc save_func,
+				      gpointer user_data,
+				      GdkPixbuf *pixbuf,
+				      gchar **option_keys,
+				      gchar **option_values,
+				      GError **error);
+  
+  /*< private >*/
+	void (*_reserved1) (void); 
+	void (*_reserved2) (void); 
+	void (*_reserved3) (void); 
+	void (*_reserved4) (void); 
+	void (*_reserved5) (void); 
+
+};
+
+/**
+ * GdkPixbufModuleFillVtableFunc:
+ * @module: a #GdkPixbufModule.
+ * 
+ * Defines the type of the function used to set the vtable of a 
+ * #GdkPixbufModule when it is loaded. 
+ * 
+ * Since: 2.2
+ */
+
+typedef void (* GdkPixbufModuleFillVtableFunc) (GdkPixbufModule *module);
+
+/**
+ * GdkPixbufModuleFillInfoFunc:
+ * @info: a #GdkPixbufFormat.
+ * 
+ * Defines the type of the function used to fill a 
+ * #GdkPixbufFormat structure with information about a module.
+ * 
+ * Since: 2.2
+ */
+typedef void (* GdkPixbufModuleFillInfoFunc) (GdkPixbufFormat *info);
+
+/*  key/value pairs that can be attached by the pixbuf loader  */
+
+gboolean gdk_pixbuf_set_option  (GdkPixbuf   *pixbuf,
+                                 const gchar *key,
+                                 const gchar *value);
+
+/**
+ * GdkPixbufFormatFlags:
+ * @GDK_PIXBUF_FORMAT_WRITABLE: the module can write out images in the format.
+ * @GDK_PIXBUF_FORMAT_SCALABLE: the image format is scalable
+ * @GDK_PIXBUF_FORMAT_THREADSAFE: the module is threadsafe. If this flag is not
+ *  set, &gdk-pixbuf; will use a lock to prevent multiple threads from using
+ *  this module at the same time. (Since 2.6)
+ * 
+ * Flags which allow a module to specify further details about the supported
+ * operations.
+ * 
+ * Since: 2.2
+ */
+typedef enum /*< skip >*/
+{
+  GDK_PIXBUF_FORMAT_WRITABLE = 1 << 0,
+  GDK_PIXBUF_FORMAT_SCALABLE = 1 << 1,
+  GDK_PIXBUF_FORMAT_THREADSAFE = 1 << 2
+} GdkPixbufFormatFlags;
+
+/**
+ * GdkPixbufFormat:
+ * @name: the name of the image format.
+ * @signature: the signature of the module.
+ * @domain: the message domain for the @description.
+ * @description: a description of the image format.
+ * @mime_types: a %NULL-terminated array of MIME types for the image format.
+ * @extensions: a %NULL-terminated array of typical filename extensions for the
+ *  image format.
+ * @flags: a combination of #GdkPixbufFormatFlags.
+ * @disabled: a boolean determining whether the loader is disabled.
+ * @license: a string containing license information, typically set to 
+ *  shorthands like "GPL", "LGPL", etc.
+ * 
+ * A #GdkPixbufFormat contains information about the image format accepted by a
+ * module. Only modules should access the fields directly, applications should
+ * use the <function>gdk_pixbuf_format_*</function> functions.
+ * 
+ * Since: 2.2
+ */
+struct _GdkPixbufFormat {
+  gchar *name;
+  GdkPixbufModulePattern *signature;
+  gchar *domain;
+  gchar *description;
+  gchar **mime_types;
+  gchar **extensions;
+  guint32 flags;
+  gboolean disabled;
+  gchar *license;
+};
+
+#endif /* GDK_PIXBUF_ENABLE_BACKEND */
+
+G_END_DECLS
+
+#endif /* GDK_PIXBUF_IO_H */
diff --git a/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-loader.h b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-loader.h
new file mode 100644
index 0000000..f9743ee
--- /dev/null
+++ b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-loader.h
@@ -0,0 +1,107 @@
+/* GdkPixbuf library - Progressive loader object
+ *
+ * Copyright (C) 1999 The Free Software Foundation
+ *
+ * Authors: Mark Crichton <crichton@gimp.org>
+ *          Miguel de Icaza <miguel@gnu.org>
+ *          Federico Mena-Quintero <federico@gimp.org>
+ *          Jonathan Blandford <jrb@redhat.com>
+ *
+ * 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 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#if defined(GDK_PIXBUF_DISABLE_SINGLE_INCLUDES) && !defined (GDK_PIXBUF_H_INSIDE) && !defined (GDK_PIXBUF_COMPILATION)
+#error "Only <gdk-pixbuf/gdk-pixbuf.h> can be included directly."
+#endif
+
+#ifndef GDK_PIXBUF_LOADER_H
+#define GDK_PIXBUF_LOADER_H
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gdk-pixbuf/gdk-pixbuf-core.h>
+#include <gdk-pixbuf/gdk-pixbuf-animation.h>
+#include <gdk-pixbuf/gdk-pixbuf-io.h>
+
+G_BEGIN_DECLS
+
+#define GDK_TYPE_PIXBUF_LOADER		   (gdk_pixbuf_loader_get_type ())
+#define GDK_PIXBUF_LOADER(obj)		   (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_PIXBUF_LOADER, GdkPixbufLoader))
+#define GDK_PIXBUF_LOADER_CLASS(klass)	   (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_LOADER, GdkPixbufLoaderClass))
+#define GDK_IS_PIXBUF_LOADER(obj)	   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_PIXBUF_LOADER))
+#define GDK_IS_PIXBUF_LOADER_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_LOADER))
+#define GDK_PIXBUF_LOADER_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_LOADER, GdkPixbufLoaderClass))
+
+/**
+ * GdkPixbufLoader:
+ * 
+ * The <structname>GdkPixbufLoader</structname> struct contains only private
+ * fields. 
+ */
+typedef struct _GdkPixbufLoader GdkPixbufLoader;
+struct _GdkPixbufLoader
+{
+  GObject parent_instance;
+  
+  /*< private >*/
+  gpointer priv;
+};
+
+typedef struct _GdkPixbufLoaderClass GdkPixbufLoaderClass;
+struct _GdkPixbufLoaderClass
+{
+  GObjectClass parent_class;
+
+  void (*size_prepared)      (GdkPixbufLoader *loader, 
+			      int              width,
+			      int              height);
+
+  void (*area_prepared)      (GdkPixbufLoader *loader);
+
+  /* Last known frame needs a redraw for x, y, width, height */
+  void (*area_updated)       (GdkPixbufLoader *loader,
+                              int              x,
+                              int              y,
+			      int              width,
+			      int              height);
+
+  void (*closed)             (GdkPixbufLoader *loader);
+};
+
+GType                gdk_pixbuf_loader_get_type      (void) G_GNUC_CONST;
+GdkPixbufLoader *    gdk_pixbuf_loader_new           (void);
+GdkPixbufLoader *    gdk_pixbuf_loader_new_with_type (const char *image_type,
+                                                      GError    **error);
+GdkPixbufLoader *    gdk_pixbuf_loader_new_with_mime_type (const char *mime_type,
+							   GError    **error);
+void                 gdk_pixbuf_loader_set_size (GdkPixbufLoader  *loader,
+                                                 int               width,
+						 int               height);
+gboolean             gdk_pixbuf_loader_write         (GdkPixbufLoader *loader,
+						      const guchar    *buf,
+						      gsize            count,
+                                                      GError         **error);
+GdkPixbuf *          gdk_pixbuf_loader_get_pixbuf    (GdkPixbufLoader *loader);
+GdkPixbufAnimation * gdk_pixbuf_loader_get_animation (GdkPixbufLoader *loader);
+gboolean             gdk_pixbuf_loader_close         (GdkPixbufLoader *loader,
+                                                      GError         **error);
+GdkPixbufFormat     *gdk_pixbuf_loader_get_format    (GdkPixbufLoader *loader);
+
+G_END_DECLS
+
+#endif
+
+
diff --git a/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-marshal.h b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-marshal.h
new file mode 100644
index 0000000..0ce70e5
--- /dev/null
+++ b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-marshal.h
@@ -0,0 +1,36 @@
+#if !defined(GDK_PIXBUF_DISABLE_DEPRECATED) || defined(GDK_PIXBUF_COMPILATION)
+

+#ifndef ___gdk_pixbuf_marshal_MARSHAL_H__

+#define ___gdk_pixbuf_marshal_MARSHAL_H__

+

+#include	<glib-object.h>

+

+G_BEGIN_DECLS

+

+/* VOID:VOID (./gdk-pixbuf-marshal.list:25) */

+#define _gdk_pixbuf_marshal_VOID__VOID	g_cclosure_marshal_VOID__VOID

+

+/* VOID:INT,INT (./gdk-pixbuf-marshal.list:26) */

+extern void _gdk_pixbuf_marshal_VOID__INT_INT (GClosure     *closure,

+                                               GValue       *return_value,

+                                               guint         n_param_values,

+                                               const GValue *param_values,

+                                               gpointer      invocation_hint,

+                                               gpointer      marshal_data);

+

+/* VOID:INT,INT,INT,INT (./gdk-pixbuf-marshal.list:27) */

+extern void _gdk_pixbuf_marshal_VOID__INT_INT_INT_INT (GClosure     *closure,

+                                                       GValue       *return_value,

+                                                       guint         n_param_values,

+                                                       const GValue *param_values,

+                                                       gpointer      invocation_hint,

+                                                       gpointer      marshal_data);

+

+/* VOID:POINTER (./gdk-pixbuf-marshal.list:28) */

+#define _gdk_pixbuf_marshal_VOID__POINTER	g_cclosure_marshal_VOID__POINTER

+

+G_END_DECLS

+

+#endif /* ___gdk_pixbuf_marshal_MARSHAL_H__ */

+

+#endif /* !GDK_PIXBUF_DISABLE_DEPRECATED || GDK_PIXBUF_COMPILATION */
diff --git a/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-simple-anim.h b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-simple-anim.h
new file mode 100644
index 0000000..496688f
--- /dev/null
+++ b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-simple-anim.h
@@ -0,0 +1,66 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */
+/* GdkPixbuf library - Simple frame-based animations
+ *
+ * Copyright (C) 2004 Dom Lachowicz
+ *
+ * Authors: Dom Lachowicz <cinamod@hotmail.com>
+ *
+ * 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 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#if defined(GDK_PIXBUF_DISABLE_SINGLE_INCLUDES) && !defined (GDK_PIXBUF_H_INSIDE) && !defined (GDK_PIXBUF_COMPILATION)
+#error "Only <gdk-pixbuf/gdk-pixbuf.h> can be included directly."
+#endif
+
+#ifndef GDK_PIXBUF_SIMPLE_ANIM_H
+#define GDK_PIXBUF_SIMPLE_ANIM_H
+
+#include <gdk-pixbuf/gdk-pixbuf-animation.h>
+
+G_BEGIN_DECLS
+
+/**
+ * GdkPixbufSimpleAnim:
+ * 
+ * An opaque struct representing a simple animation.
+ */
+typedef struct _GdkPixbufSimpleAnim GdkPixbufSimpleAnim;
+typedef struct _GdkPixbufSimpleAnimClass GdkPixbufSimpleAnimClass;
+
+#define GDK_TYPE_PIXBUF_SIMPLE_ANIM              (gdk_pixbuf_simple_anim_get_type ())
+#define GDK_PIXBUF_SIMPLE_ANIM(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_SIMPLE_ANIM, GdkPixbufSimpleAnim))
+#define GDK_IS_PIXBUF_SIMPLE_ANIM(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_SIMPLE_ANIM))
+
+#define GDK_PIXBUF_SIMPLE_ANIM_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_SIMPLE_ANIM, GdkPixbufSimpleAnimClass))
+#define GDK_IS_PIXBUF_SIMPLE_ANIM_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_SIMPLE_ANIM))
+#define GDK_PIXBUF_SIMPLE_ANIM_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_SIMPLE_ANIM, GdkPixbufSimpleAnimClass))
+
+GType gdk_pixbuf_simple_anim_get_type (void) G_GNUC_CONST;
+GType gdk_pixbuf_simple_anim_iter_get_type (void) G_GNUC_CONST;
+
+GdkPixbufSimpleAnim *gdk_pixbuf_simple_anim_new           (gint   width, 
+                                                           gint   height,
+                                                           gfloat rate);
+void                 gdk_pixbuf_simple_anim_add_frame     (GdkPixbufSimpleAnim *animation,
+                                                           GdkPixbuf           *pixbuf);
+void                 gdk_pixbuf_simple_anim_set_loop      (GdkPixbufSimpleAnim *animation,
+                                                           gboolean             loop);
+gboolean             gdk_pixbuf_simple_anim_get_loop      (GdkPixbufSimpleAnim *animation);
+
+G_END_DECLS
+
+
+#endif  /* GDK_PIXBUF_SIMPLE_ANIM_H */
diff --git a/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-transform.h b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-transform.h
new file mode 100644
index 0000000..d4757ff
--- /dev/null
+++ b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-transform.h
@@ -0,0 +1,160 @@
+/* GdkPixbuf library - transformations
+ *
+ * Copyright (C) 2003 The Free Software Foundation
+ *
+ * Authors: Mark Crichton <crichton@gimp.org>
+ *          Miguel de Icaza <miguel@gnu.org>
+ *          Federico Mena-Quintero <federico@gimp.org>
+ *          Havoc Pennington <hp@redhat.com>
+ *
+ * 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 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#if defined(GDK_PIXBUF_DISABLE_SINGLE_INCLUDES) && !defined (GDK_PIXBUF_H_INSIDE) && !defined (GDK_PIXBUF_COMPILATION)
+#error "Only <gdk-pixbuf/gdk-pixbuf.h> can be included directly."
+#endif
+
+#ifndef GDK_PIXBUF_TRANSFORM_H
+#define GDK_PIXBUF_TRANSFORM_H
+
+#include <glib.h>
+#include <gdk-pixbuf/gdk-pixbuf-core.h>
+
+
+G_BEGIN_DECLS
+
+/* Scaling */
+
+/**
+ * GdkInterpType:
+ * @GDK_INTERP_NEAREST: Nearest neighbor sampling; this is the fastest
+ *  and lowest quality mode. Quality is normally unacceptable when scaling 
+ *  down, but may be OK when scaling up.
+ * @GDK_INTERP_TILES: This is an accurate simulation of the PostScript
+ *  image operator without any interpolation enabled.  Each pixel is
+ *  rendered as a tiny parallelogram of solid color, the edges of which
+ *  are implemented with antialiasing.  It resembles nearest neighbor for
+ *  enlargement, and bilinear for reduction.
+ * @GDK_INTERP_BILINEAR: Best quality/speed balance; use this mode by
+ *  default. Bilinear interpolation.  For enlargement, it is
+ *  equivalent to point-sampling the ideal bilinear-interpolated image.
+ *  For reduction, it is equivalent to laying down small tiles and
+ *  integrating over the coverage area.
+ * @GDK_INTERP_HYPER: This is the slowest and highest quality
+ *  reconstruction function. It is derived from the hyperbolic filters in
+ *  Wolberg's "Digital Image Warping", and is formally defined as the
+ *  hyperbolic-filter sampling the ideal hyperbolic-filter interpolated
+ *  image (the filter is designed to be idempotent for 1:1 pixel mapping).
+ * 
+ *  This enumeration describes the different interpolation modes that
+ *  can be used with the scaling functions. @GDK_INTERP_NEAREST is 
+ *  the fastest scaling method, but has horrible quality when 
+ *  scaling down. @GDK_INTERP_BILINEAR is the best choice if you 
+ *  aren't sure what to choose, it has a good speed/quality balance.
+ * 
+ *  <note>
+ * 	Cubic filtering is missing from the list; hyperbolic
+ * 	interpolation is just as fast and results in higher quality.
+ *  </note>
+ */
+typedef enum {
+	GDK_INTERP_NEAREST,
+	GDK_INTERP_TILES,
+	GDK_INTERP_BILINEAR,
+	GDK_INTERP_HYPER
+} GdkInterpType;
+
+/**
+ * GdkPixbufRotation:
+ * @GDK_PIXBUF_ROTATE_NONE: No rotation.
+ * @GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE: Rotate by 90 degrees.
+ * @GDK_PIXBUF_ROTATE_UPSIDEDOWN: Rotate by 180 degrees.
+ * @GDK_PIXBUF_ROTATE_CLOCKWISE: Rotate by 270 degrees.
+ * 
+ * The possible rotations which can be passed to gdk_pixbuf_rotate_simple().
+ * To make them easier to use, their numerical values are the actual degrees.
+ */
+typedef enum {
+	GDK_PIXBUF_ROTATE_NONE             =   0,
+	GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE =  90,
+	GDK_PIXBUF_ROTATE_UPSIDEDOWN       = 180,
+	GDK_PIXBUF_ROTATE_CLOCKWISE        = 270
+} GdkPixbufRotation;
+
+void gdk_pixbuf_scale           (const GdkPixbuf *src,
+				 GdkPixbuf       *dest,
+				 int              dest_x,
+				 int              dest_y,
+				 int              dest_width,
+				 int              dest_height,
+				 double           offset_x,
+				 double           offset_y,
+				 double           scale_x,
+				 double           scale_y,
+				 GdkInterpType    interp_type);
+void gdk_pixbuf_composite       (const GdkPixbuf *src,
+				 GdkPixbuf       *dest,
+				 int              dest_x,
+				 int              dest_y,
+				 int              dest_width,
+				 int              dest_height,
+				 double           offset_x,
+				 double           offset_y,
+				 double           scale_x,
+				 double           scale_y,
+				 GdkInterpType    interp_type,
+				 int              overall_alpha);
+void gdk_pixbuf_composite_color (const GdkPixbuf *src,
+				 GdkPixbuf       *dest,
+				 int              dest_x,
+				 int              dest_y,
+				 int              dest_width,
+				 int              dest_height,
+				 double           offset_x,
+				 double           offset_y,
+				 double           scale_x,
+				 double           scale_y,
+				 GdkInterpType    interp_type,
+				 int              overall_alpha,
+				 int              check_x,
+				 int              check_y,
+				 int              check_size,
+				 guint32          color1,
+				 guint32          color2);
+
+GdkPixbuf *gdk_pixbuf_scale_simple           (const GdkPixbuf *src,
+					      int              dest_width,
+					      int              dest_height,
+					      GdkInterpType    interp_type);
+
+GdkPixbuf *gdk_pixbuf_composite_color_simple (const GdkPixbuf *src,
+					      int              dest_width,
+					      int              dest_height,
+					      GdkInterpType    interp_type,
+					      int              overall_alpha,
+					      int              check_size,
+					      guint32          color1,
+					      guint32          color2);
+
+GdkPixbuf *gdk_pixbuf_rotate_simple          (const GdkPixbuf   *src,
+				              GdkPixbufRotation  angle);
+GdkPixbuf *gdk_pixbuf_flip                   (const GdkPixbuf   *src,
+				              gboolean           horizontal);
+				     
+G_END_DECLS
+
+
+#endif  /* GDK_PIXBUF_TRANSFORM_H */
diff --git a/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf.h b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf.h
new file mode 100644
index 0000000..9a30131
--- /dev/null
+++ b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf.h
@@ -0,0 +1,45 @@
+/* GdkPixbuf library - Main header file
+ *
+ * Copyright (C) 1999 The Free Software Foundation
+ *
+ * Authors: Mark Crichton <crichton@gimp.org>
+ *          Miguel de Icaza <miguel@gnu.org>
+ *          Federico Mena-Quintero <federico@gimp.org>
+ *          Havoc Pennington <hp@redhat.com>
+ *
+ * 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 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef GDK_PIXBUF_H
+#define GDK_PIXBUF_H
+
+#define GDK_PIXBUF_H_INSIDE
+
+#include <glib.h>
+#include <gdk-pixbuf/gdk-pixbuf-features.h>
+#include <glib-object.h>
+
+#include <gdk-pixbuf/gdk-pixbuf-core.h>
+#include <gdk-pixbuf/gdk-pixbuf-transform.h>
+#include <gdk-pixbuf/gdk-pixbuf-animation.h>
+#include <gdk-pixbuf/gdk-pixbuf-simple-anim.h>
+#include <gdk-pixbuf/gdk-pixbuf-io.h>
+#include <gdk-pixbuf/gdk-pixbuf-loader.h>
+#include <gdk-pixbuf/gdk-pixbuf-enum-types.h>
+
+#undef GDK_PIXBUF_H_INSIDE
+
+#endif  /* GDK_PIXBUF_H */
diff --git a/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixdata.h b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixdata.h
new file mode 100644
index 0000000..c217781
--- /dev/null
+++ b/gtk+-mingw/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixdata.h
@@ -0,0 +1,170 @@
+/* GdkPixbuf library - GdkPixdata - functions for inlined pixbuf handling
+ * Copyright (C) 1999, 2001 Tim Janik
+ *
+ * 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 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., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GDK_PIXDATA_H__
+#define __GDK_PIXDATA_H__
+
+#include        <gdk-pixbuf/gdk-pixbuf.h>
+
+G_BEGIN_DECLS
+
+/**
+ * GDK_PIXBUF_MAGIC_NUMBER:
+ *
+ * Magic number for #GdkPixdata structures.
+ **/
+#define GDK_PIXBUF_MAGIC_NUMBER (0x47646b50)    /* 'GdkP' */
+
+/**
+ * GdkPixdataType:
+ * @GDK_PIXDATA_COLOR_TYPE_RGB:  each pixel has red, green and blue samples.
+ * @GDK_PIXDATA_COLOR_TYPE_RGBA: each pixel has red, green and blue samples 
+ *    and an alpha value.
+ * @GDK_PIXDATA_COLOR_TYPE_MASK: mask for the colortype flags of the enum.
+ * @GDK_PIXDATA_SAMPLE_WIDTH_8: each sample has 8 bits.
+ * @GDK_PIXDATA_SAMPLE_WIDTH_MASK: mask for the sample width flags of the enum.
+ * @GDK_PIXDATA_ENCODING_RAW: the pixel data is in raw form. 
+ * @GDK_PIXDATA_ENCODING_RLE: the pixel data is run-length encoded. Runs may 
+ *    be up to 127 bytes long; their length is stored in a single byte 
+ *    preceding the pixel data for the run. If a run is constant, its length
+ *    byte has the high bit set and the pixel data consists of a single pixel
+ *    which must be repeated. 
+ * @GDK_PIXDATA_ENCODING_MASK: mask for the encoding flags of the enum.
+ *
+ * An enumeration containing three sets of flags for a #GdkPixdata struct: 
+ * one for the used colorspace, one for the width of the samples and one 
+ * for the encoding of the pixel data.  
+ **/
+typedef enum
+{
+  /* colorspace + alpha */
+  GDK_PIXDATA_COLOR_TYPE_RGB    = 0x01,
+  GDK_PIXDATA_COLOR_TYPE_RGBA   = 0x02,
+  GDK_PIXDATA_COLOR_TYPE_MASK   = 0xff,
+  /* width, support 8bits only currently */
+  GDK_PIXDATA_SAMPLE_WIDTH_8    = 0x01 << 16,
+  GDK_PIXDATA_SAMPLE_WIDTH_MASK = 0x0f << 16,
+  /* encoding */
+  GDK_PIXDATA_ENCODING_RAW      = 0x01 << 24,
+  GDK_PIXDATA_ENCODING_RLE      = 0x02 << 24,
+  GDK_PIXDATA_ENCODING_MASK     = 0x0f << 24
+} GdkPixdataType;
+
+/**
+ * GdkPixdata:
+ * @magic: magic number. A valid #GdkPixdata structure must have 
+ *    #GDK_PIXBUF_MAGIC_NUMBER here.
+ * @length: less than 1 to disable length checks, otherwise 
+ *    #GDK_PIXDATA_HEADER_LENGTH + length of @pixel_data. 
+ * @pixdata_type: information about colorspace, sample width and 
+ *    encoding, in a #GdkPixdataType. 
+ * @rowstride: Distance in bytes between rows.
+ * @width: Width of the image in pixels.
+ * @height: Height of the image in pixels.
+ * @pixel_data: (array) (element-type guint8): @width x @height pixels, encoded according to @pixdata_type
+ *   and @rowstride.
+ *
+ * A #GdkPixdata contains pixbuf information in a form suitable for 
+ * serialization and streaming.
+ **/
+typedef struct _GdkPixdata GdkPixdata;
+struct _GdkPixdata
+{
+  guint32 magic;        /* GDK_PIXBUF_MAGIC_NUMBER */
+  gint32  length;       /* <1 to disable length checks, otherwise:
+			 * GDK_PIXDATA_HEADER_LENGTH + pixel_data length
+			 */
+  guint32 pixdata_type; /* GdkPixdataType */
+  guint32 rowstride;
+  guint32 width;
+  guint32 height;
+  guint8 *pixel_data;
+};
+
+/**
+ * GDK_PIXDATA_HEADER_LENGTH:
+ *
+ * The length of a #GdkPixdata structure without the @pixel_data pointer.
+ **/
+#define	GDK_PIXDATA_HEADER_LENGTH	(4 + 4 + 4 + 4 + 4 + 4)
+
+/* the returned stream is plain htonl of GdkPixdata members + pixel_data */
+guint8*		gdk_pixdata_serialize	(const GdkPixdata	*pixdata,
+					 guint			*stream_length_p);
+gboolean	gdk_pixdata_deserialize	(GdkPixdata		*pixdata,
+					 guint			 stream_length,
+					 const guint8		*stream,
+					 GError		       **error);
+gpointer	gdk_pixdata_from_pixbuf	(GdkPixdata		*pixdata,
+					 const GdkPixbuf	*pixbuf,
+					 gboolean		 use_rle);
+GdkPixbuf*	gdk_pixbuf_from_pixdata	(const GdkPixdata	*pixdata,
+					 gboolean		 copy_pixels,
+					 GError		       **error);
+/** 
+ * GdkPixdataDumpType:
+ * @GDK_PIXDATA_DUMP_PIXDATA_STREAM: Generate pixbuf data stream (a single 
+ *    string containing a serialized #GdkPixdata structure in network byte 
+ *    order).
+ * @GDK_PIXDATA_DUMP_PIXDATA_STRUCT: Generate #GdkPixdata structure (needs 
+ *    the #GdkPixdata structure definition from gdk-pixdata.h).
+ * @GDK_PIXDATA_DUMP_MACROS: Generate <function>*_ROWSTRIDE</function>,     
+ *    <function>*_WIDTH</function>, <function>*_HEIGHT</function>,
+ *    <function>*_BYTES_PER_PIXEL</function> and 
+ *    <function>*_RLE_PIXEL_DATA</function> or <function>*_PIXEL_DATA</function>
+ *    macro definitions for the image.
+ * @GDK_PIXDATA_DUMP_GTYPES: Generate GLib data types instead of 
+ *    standard C data types.
+ * @GDK_PIXDATA_DUMP_CTYPES: Generate standard C data types instead of 
+ *    GLib data types.
+ * @GDK_PIXDATA_DUMP_STATIC: Generate static symbols.
+ * @GDK_PIXDATA_DUMP_CONST: Generate const symbols.
+ * @GDK_PIXDATA_DUMP_RLE_DECODER: Provide a <function>*_RUN_LENGTH_DECODE(image_buf, rle_data, size, bpp)</function> 
+ *    macro definition  to  decode  run-length encoded image data.
+ *  
+ * An enumeration which is used by gdk_pixdata_to_csource() to
+ * determine the form of C source to be generated. The three values
+ * @GDK_PIXDATA_DUMP_PIXDATA_STREAM, @GDK_PIXDATA_DUMP_PIXDATA_STRUCT
+ * and @GDK_PIXDATA_DUMP_MACROS are mutually exclusive, as are
+ * @GDK_PIXBUF_DUMP_GTYPES and @GDK_PIXBUF_DUMP_CTYPES. The remaining
+ * elements are optional flags that can be freely added. 
+ **/
+typedef enum
+{
+  /* type of source to save */
+  GDK_PIXDATA_DUMP_PIXDATA_STREAM	= 0,
+  GDK_PIXDATA_DUMP_PIXDATA_STRUCT	= 1,
+  GDK_PIXDATA_DUMP_MACROS		= 2,
+  /* type of variables to use */
+  GDK_PIXDATA_DUMP_GTYPES		= 0,
+  GDK_PIXDATA_DUMP_CTYPES		= 1 << 8,
+  GDK_PIXDATA_DUMP_STATIC		= 1 << 9,
+  GDK_PIXDATA_DUMP_CONST		= 1 << 10,
+  /* save RLE decoder macro? */
+  GDK_PIXDATA_DUMP_RLE_DECODER		= 1 << 16
+} GdkPixdataDumpType;
+  
+
+GString*	gdk_pixdata_to_csource	(GdkPixdata		*pixdata,
+					 const gchar		*name,
+					 GdkPixdataDumpType	 dump_type);
+
+
+G_END_DECLS
+
+#endif /* __GDK_PIXDATA_H__ */