gdk_pixbuf2 2.2.4-x64-mingw32

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

@@ -0,0 +1,108 @@
+/* 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GDK_PIXBUF_LOADER_H
+#define GDK_PIXBUF_LOADER_H
+
+#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
+
+#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 GdkPixbufLoader 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);
+gboolean             gdk_pixbuf_loader_write_bytes   (GdkPixbufLoader *loader,
+                                                      GBytes          *buffer,
+                                                      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
+
+

data/vendor/local/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 */

data/vendor/local/include/gdk-pixbuf-2.0/gdk-pixbuf/gdk-pixbuf-simple-anim.h

@@ -0,0 +1,64 @@
+/* -*- 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GDK_PIXBUF_SIMPLE_ANIM_H
+#define GDK_PIXBUF_SIMPLE_ANIM_H
+
+#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
+
+#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 */

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

@@ -0,0 +1,158 @@
+/* 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GDK_PIXBUF_TRANSFORM_H
+#define GDK_PIXBUF_TRANSFORM_H
+
+#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
+
+#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 */

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

@@ -0,0 +1,43 @@
+/* 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#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 */

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

@@ -0,0 +1,168 @@
+/* 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, see <http://www.gnu.org/licenses/>.
+ */
+#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__ */