<MACRO>
<NAME>GDK_TYPE_PIXBUF_ANIMATION</NAME>
#define GDK_TYPE_PIXBUF_ANIMATION              (gdk_pixbuf_animation_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_ANIMATION</NAME>
#define GDK_PIXBUF_ANIMATION(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_ANIMATION, GdkPixbufAnimation))
</MACRO>
<MACRO>
<NAME>GDK_IS_PIXBUF_ANIMATION</NAME>
#define GDK_IS_PIXBUF_ANIMATION(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_ANIMATION))
</MACRO>
<MACRO>
<NAME>GDK_TYPE_PIXBUF_ANIMATION_ITER</NAME>
#define GDK_TYPE_PIXBUF_ANIMATION_ITER              (gdk_pixbuf_animation_iter_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_ANIMATION_ITER</NAME>
#define GDK_PIXBUF_ANIMATION_ITER(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_ANIMATION_ITER, GdkPixbufAnimationIter))
</MACRO>
<MACRO>
<NAME>GDK_IS_PIXBUF_ANIMATION_ITER</NAME>
#define GDK_IS_PIXBUF_ANIMATION_ITER(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_ANIMATION_ITER))
</MACRO>
<FUNCTION>
<NAME>gdk_pixbuf_animation_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_new_from_file_utf8</NAME>
<RETURNS>GdkPixbufAnimation *</RETURNS>
const char         *filename, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_new_from_file</NAME>
<RETURNS>GdkPixbufAnimation *</RETURNS>
const char         *filename, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_new_from_stream</NAME>
<RETURNS>GdkPixbufAnimation *</RETURNS>
GInputStream       *stream, GCancellable       *cancellable, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_new_from_stream_async</NAME>
<RETURNS>void</RETURNS>
GInputStream *stream, GCancellable       *cancellable, GAsyncReadyCallback callback, gpointer            user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_new_from_stream_finish</NAME>
<RETURNS>GdkPixbufAnimation *</RETURNS>
GAsyncResult*async_result, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_new_from_resource</NAME>
<RETURNS>GdkPixbufAnimation *</RETURNS>
const char        *resource_path, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_ref</NAME>
<DEPRECATED/>
<RETURNS>GdkPixbufAnimation *</RETURNS>
GdkPixbufAnimation *animation
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_unref</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
GdkPixbufAnimation *animation
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_get_width</NAME>
<RETURNS>int</RETURNS>
GdkPixbufAnimation *animation
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_get_height</NAME>
<RETURNS>int</RETURNS>
GdkPixbufAnimation *animation
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_is_static_image</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbufAnimation *animation
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_get_static_image</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GdkPixbufAnimation *animation
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_get_iter</NAME>
<RETURNS>GdkPixbufAnimationIter *</RETURNS>
GdkPixbufAnimation     *animation, const GTimeVal         *start_time
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_iter_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_iter_get_delay_time</NAME>
<RETURNS>int</RETURNS>
GdkPixbufAnimationIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_iter_get_pixbuf</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GdkPixbufAnimationIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_iter_on_currently_loading_frame</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbufAnimationIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_animation_iter_advance</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbufAnimationIter *iter, const GTimeVal         *current_time
</FUNCTION>
<MACRO>
<NAME>GDK_PIXBUF_ANIMATION_CLASS</NAME>
#define GDK_PIXBUF_ANIMATION_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_ANIMATION, GdkPixbufAnimationClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_PIXBUF_ANIMATION_CLASS</NAME>
#define GDK_IS_PIXBUF_ANIMATION_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_ANIMATION))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_ANIMATION_GET_CLASS</NAME>
#define GDK_PIXBUF_ANIMATION_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_ANIMATION, GdkPixbufAnimationClass))
</MACRO>
<STRUCT>
<NAME>GdkPixbufAnimation</NAME>
struct _GdkPixbufAnimation {
        GObject parent_instance;

};
</STRUCT>
<STRUCT>
<NAME>GdkPixbufAnimationClass</NAME>
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);

};
</STRUCT>
<MACRO>
<NAME>GDK_PIXBUF_ANIMATION_ITER_CLASS</NAME>
#define GDK_PIXBUF_ANIMATION_ITER_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_ANIMATION_ITER, GdkPixbufAnimationIterClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_PIXBUF_ANIMATION_ITER_CLASS</NAME>
#define GDK_IS_PIXBUF_ANIMATION_ITER_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_ANIMATION_ITER))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_ANIMATION_ITER_GET_CLASS</NAME>
#define GDK_PIXBUF_ANIMATION_ITER_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_ANIMATION_ITER, GdkPixbufAnimationIterClass))
</MACRO>
<STRUCT>
<NAME>GdkPixbufAnimationIter</NAME>
struct _GdkPixbufAnimationIter {
        GObject parent_instance;

};
</STRUCT>
<STRUCT>
<NAME>GdkPixbufAnimationIterClass</NAME>
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);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_pixbuf_non_anim_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_non_anim_new</NAME>
<RETURNS>GdkPixbufAnimation *</RETURNS>
GdkPixbuf *pixbuf
</FUNCTION>
<ENUM>
<NAME>GdkPixbufAlphaMode</NAME>
typedef enum
{
        GDK_PIXBUF_ALPHA_BILEVEL,
        GDK_PIXBUF_ALPHA_FULL
} GdkPixbufAlphaMode;
</ENUM>
<ENUM>
<NAME>GdkColorspace</NAME>
typedef enum {
	GDK_COLORSPACE_RGB
} GdkColorspace;
</ENUM>
<MACRO>
<NAME>GDK_TYPE_PIXBUF</NAME>
#define GDK_TYPE_PIXBUF              (gdk_pixbuf_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF</NAME>
#define GDK_PIXBUF(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF, GdkPixbuf))
</MACRO>
<MACRO>
<NAME>GDK_IS_PIXBUF</NAME>
#define GDK_IS_PIXBUF(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF))
</MACRO>
<USER_FUNCTION>
<NAME>GdkPixbufDestroyNotify</NAME>
<RETURNS>void</RETURNS>
guchar *pixels, gpointer data
</USER_FUNCTION>
<MACRO>
<NAME>GDK_PIXBUF_ERROR</NAME>
#define GDK_PIXBUF_ERROR gdk_pixbuf_error_quark ()
</MACRO>
<ENUM>
<NAME>GdkPixbufError</NAME>
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,
        GDK_PIXBUF_ERROR_INCOMPLETE_ANIMATION
} GdkPixbufError;
</ENUM>
<FUNCTION>
<NAME>gdk_pixbuf_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_ref</NAME>
<DEPRECATED/>
<RETURNS>GdkPixbuf *</RETURNS>
GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_unref</NAME>
<DEPRECATED/>
<RETURNS>void</RETURNS>
GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_colorspace</NAME>
<RETURNS>GdkColorspace</RETURNS>
const GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_n_channels</NAME>
<RETURNS>int</RETURNS>
const GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_has_alpha</NAME>
<RETURNS>gboolean</RETURNS>
const GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_bits_per_sample</NAME>
<RETURNS>int</RETURNS>
const GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_pixels</NAME>
<RETURNS>guchar *</RETURNS>
const GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_width</NAME>
<RETURNS>int</RETURNS>
const GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_height</NAME>
<RETURNS>int</RETURNS>
const GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_rowstride</NAME>
<RETURNS>int</RETURNS>
const GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_byte_length</NAME>
<RETURNS>gsize</RETURNS>
const GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_pixels_with_length</NAME>
<RETURNS>guchar *</RETURNS>
const GdkPixbuf *pixbuf, guint           *length
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_read_pixels</NAME>
<RETURNS>const guint8 *</RETURNS>
const GdkPixbuf  *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_read_pixel_bytes</NAME>
<RETURNS>GBytes *</RETURNS>
const GdkPixbuf  *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample, int width, int height
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_calculate_rowstride</NAME>
<RETURNS>gint</RETURNS>
GdkColorspace colorspace, gboolean      has_alpha, int           bits_per_sample, int           width, int           height
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_copy</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_subpixbuf</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GdkPixbuf *src_pixbuf, int        src_x, int        src_y, int        width, int        height
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_file_utf8</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const char *filename, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_file_at_size_utf8</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const char *filename, int         width, int         height, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_file_at_scale_utf8</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const char *filename, int         width, int         height, gboolean    preserve_aspect_ratio, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_file</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const char *filename, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_file_at_size</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const char *filename, int         width, int         height, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_file_at_scale</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const char *filename, int         width, int         height, gboolean    preserve_aspect_ratio, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_resource</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const char *resource_path, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_resource_at_scale</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const char *resource_path, int         width, int         height, gboolean    preserve_aspect_ratio, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_data</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
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
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_bytes</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GBytes *data, GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample, int width, int height, int rowstride
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_xpm_data</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const char **data
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_inline</NAME>
<DEPRECATED/>
<RETURNS>GdkPixbuf *</RETURNS>
gint          data_length, const guint8 *data, gboolean      copy_pixels, GError      **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_fill</NAME>
<RETURNS>void</RETURNS>
GdkPixbuf    *pixbuf, guint32       pixel
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_save</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf  *pixbuf, const char *filename, const char *type, GError    **error, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_savev</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf  *pixbuf, const char *filename, const char *type, char      **option_keys, char      **option_values, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_savev_utf8</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf  *pixbuf, const char *filename, const char *type, char      **option_keys, char      **option_values, GError    **error
</FUNCTION>
<USER_FUNCTION>
<NAME>GdkPixbufSaveFunc</NAME>
<RETURNS>gboolean</RETURNS>
const gchar *buf, gsize count, GError **error, gpointer data
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_save_to_callback</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf  *pixbuf, GdkPixbufSaveFunc save_func, gpointer user_data, const char *type, GError    **error, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_save_to_callbackv</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf  *pixbuf, GdkPixbufSaveFunc save_func, gpointer user_data, const char *type, char      **option_keys, char      **option_values, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_save_to_buffer</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf  *pixbuf, gchar     **buffer, gsize      *buffer_size, const char *type, GError    **error, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_save_to_bufferv</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf  *pixbuf, gchar     **buffer, gsize      *buffer_size, const char *type, char      **option_keys, char      **option_values, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_stream</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GInputStream   *stream, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_stream_async</NAME>
<RETURNS>void</RETURNS>
GInputStream        *stream, GCancellable        *cancellable, GAsyncReadyCallback  callback, gpointer             user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_stream_finish</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GAsyncResult  *async_result, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_stream_at_scale</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GInputStream   *stream, gint            width, gint            height, gboolean        preserve_aspect_ratio, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_new_from_stream_at_scale_async</NAME>
<RETURNS>void</RETURNS>
GInputStream        *stream, gint                 width, gint                 height, gboolean             preserve_aspect_ratio, GCancellable        *cancellable, GAsyncReadyCallback  callback, gpointer             user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_save_to_stream</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf      *pixbuf, GOutputStream  *stream, const char     *type, GCancellable   *cancellable, GError        **error, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_save_to_stream_async</NAME>
<RETURNS>void</RETURNS>
GdkPixbuf           *pixbuf, GOutputStream       *stream, const gchar         *type, GCancellable        *cancellable, GAsyncReadyCallback  callback, gpointer             user_data, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_save_to_stream_finish</NAME>
<RETURNS>gboolean</RETURNS>
GAsyncResult  *async_result, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_save_to_streamv_async</NAME>
<RETURNS>void</RETURNS>
GdkPixbuf           *pixbuf, GOutputStream       *stream, const gchar         *type, gchar              **option_keys, gchar              **option_values, GCancellable        *cancellable, GAsyncReadyCallback  callback, gpointer             user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_save_to_streamv</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf      *pixbuf, GOutputStream  *stream, const char     *type, char          **option_keys, char          **option_values, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_add_alpha</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const GdkPixbuf *pixbuf, gboolean substitute_color, guchar r, guchar g, guchar b
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_copy_area</NAME>
<RETURNS>void</RETURNS>
const GdkPixbuf *src_pixbuf, int src_x, int src_y, int width, int height, GdkPixbuf *dest_pixbuf, int dest_x, int dest_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_saturate_and_pixelate</NAME>
<RETURNS>void</RETURNS>
const GdkPixbuf *src, GdkPixbuf       *dest, gfloat           saturation, gboolean         pixelate
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_apply_embedded_orientation</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GdkPixbuf *src
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_set_option</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf   *pixbuf, const gchar *key, const gchar *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_option</NAME>
<RETURNS>const gchar *</RETURNS>
GdkPixbuf   *pixbuf, const gchar *key
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_remove_option</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf   *pixbuf, const gchar *key
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_options</NAME>
<RETURNS>GHashTable *</RETURNS>
GdkPixbuf   *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_copy_options</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbuf *src_pixbuf, GdkPixbuf *dest_pixbuf
</FUNCTION>
<STRUCT>
<NAME>GdkPixbuf</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_pixbuf_init_modules</NAME>
<RETURNS>gboolean</RETURNS>
const char  *path, GError     **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_formats</NAME>
<RETURNS>GSList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_get_name</NAME>
<RETURNS>gchar *</RETURNS>
GdkPixbufFormat *format
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_get_description</NAME>
<RETURNS>gchar *</RETURNS>
GdkPixbufFormat *format
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_get_mime_types</NAME>
<RETURNS>gchar **</RETURNS>
GdkPixbufFormat *format
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_get_extensions</NAME>
<RETURNS>gchar **</RETURNS>
GdkPixbufFormat *format
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_is_save_option_supported</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbufFormat *format, const gchar     *option_key
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_is_writable</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbufFormat *format
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_is_scalable</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbufFormat *format
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_is_disabled</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbufFormat *format
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_set_disabled</NAME>
<RETURNS>void</RETURNS>
GdkPixbufFormat *format, gboolean         disabled
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_get_license</NAME>
<RETURNS>gchar *</RETURNS>
GdkPixbufFormat *format
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_file_info</NAME>
<RETURNS>GdkPixbufFormat *</RETURNS>
const gchar     *filename, gint            *width, gint            *height
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_file_info_async</NAME>
<RETURNS>void</RETURNS>
const gchar          *filename, GCancellable         *cancellable, GAsyncReadyCallback   callback, gpointer              user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_file_info_finish</NAME>
<RETURNS>GdkPixbufFormat *</RETURNS>
GAsyncResult         *async_result, gint                 *width, gint                 *height, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_copy</NAME>
<RETURNS>GdkPixbufFormat *</RETURNS>
const GdkPixbufFormat *format
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_format_free</NAME>
<RETURNS>void</RETURNS>
GdkPixbufFormat       *format
</FUNCTION>
<USER_FUNCTION>
<NAME>GdkPixbufModuleSizeFunc</NAME>
<RETURNS>void</RETURNS>
gint *width, gint *height, gpointer user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdkPixbufModulePreparedFunc</NAME>
<RETURNS>void</RETURNS>
GdkPixbuf          *pixbuf, GdkPixbufAnimation *anim, gpointer            user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdkPixbufModuleUpdatedFunc</NAME>
<RETURNS>void</RETURNS>
GdkPixbuf *pixbuf, int        x, int        y, int        width, int        height, gpointer   user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GdkPixbufModulePattern</NAME>
struct _GdkPixbufModulePattern {
	char *prefix;
	char *mask;
	int relevance;
};
</STRUCT>
<STRUCT>
<NAME>GdkPixbufModule</NAME>
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 prepared_func,
                                     GdkPixbufModuleUpdatedFunc updated_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);
  
        gboolean (* is_save_option_supported) (const gchar *option_key);

  /*< private >*/
	void (*_reserved1) (void); 
	void (*_reserved2) (void); 
	void (*_reserved3) (void); 
	void (*_reserved4) (void);
};
</STRUCT>
<USER_FUNCTION>
<NAME>GdkPixbufModuleFillVtableFunc</NAME>
<RETURNS>void</RETURNS>
GdkPixbufModule *module
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdkPixbufModuleFillInfoFunc</NAME>
<RETURNS>void</RETURNS>
GdkPixbufFormat *info
</USER_FUNCTION>
<ENUM>
<NAME>GdkPixbufFormatFlags</NAME>
typedef enum /*< skip >*/
{
  GDK_PIXBUF_FORMAT_WRITABLE = 1 << 0,
  GDK_PIXBUF_FORMAT_SCALABLE = 1 << 1,
  GDK_PIXBUF_FORMAT_THREADSAFE = 1 << 2
} GdkPixbufFormatFlags;
</ENUM>
<STRUCT>
<NAME>GdkPixbufFormat</NAME>
struct _GdkPixbufFormat {
  gchar *name;
  GdkPixbufModulePattern *signature;
  gchar *domain;
  gchar *description;
  gchar **mime_types;
  gchar **extensions;
  guint32 flags;
  gboolean disabled;
  gchar *license;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_PIXBUF_LOADER</NAME>
#define GDK_TYPE_PIXBUF_LOADER		   (gdk_pixbuf_loader_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_LOADER</NAME>
#define GDK_PIXBUF_LOADER(obj)		   (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_PIXBUF_LOADER, GdkPixbufLoader))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_LOADER_CLASS</NAME>
#define GDK_PIXBUF_LOADER_CLASS(klass)	   (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_LOADER, GdkPixbufLoaderClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_PIXBUF_LOADER</NAME>
#define GDK_IS_PIXBUF_LOADER(obj)	   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_PIXBUF_LOADER))
</MACRO>
<MACRO>
<NAME>GDK_IS_PIXBUF_LOADER_CLASS</NAME>
#define GDK_IS_PIXBUF_LOADER_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_LOADER))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_LOADER_GET_CLASS</NAME>
#define GDK_PIXBUF_LOADER_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_LOADER, GdkPixbufLoaderClass))
</MACRO>
<STRUCT>
<NAME>GdkPixbufLoader</NAME>
struct _GdkPixbufLoader
{
  GObject parent_instance;
  
  /*< private >*/
  gpointer priv;
};
</STRUCT>
<STRUCT>
<NAME>GdkPixbufLoaderClass</NAME>
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);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_pixbuf_loader_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_loader_new</NAME>
<RETURNS>GdkPixbufLoader *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_loader_new_with_type</NAME>
<RETURNS>GdkPixbufLoader *</RETURNS>
const char *image_type, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_loader_new_with_mime_type</NAME>
<RETURNS>GdkPixbufLoader *</RETURNS>
const char *mime_type, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_loader_set_size</NAME>
<RETURNS>void</RETURNS>
GdkPixbufLoader  *loader, int               width, int               height
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_loader_write</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbufLoader *loader, const guchar    *buf, gsize            count, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_loader_write_bytes</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbufLoader *loader, GBytes          *buffer, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_loader_get_pixbuf</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GdkPixbufLoader *loader
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_loader_get_animation</NAME>
<RETURNS>GdkPixbufAnimation *</RETURNS>
GdkPixbufLoader *loader
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_loader_close</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbufLoader *loader, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_loader_get_format</NAME>
<RETURNS>GdkPixbufFormat *</RETURNS>
GdkPixbufLoader *loader
</FUNCTION>
<MACRO>
<NAME>GDK_PIXBUF_CHECK_VERSION</NAME>
#define GDK_PIXBUF_CHECK_VERSION(major, minor, micro) \
	(GDK_PIXBUF_MAJOR > (major) || \
	(GDK_PIXBUF_MAJOR == (major) && GDK_PIXBUF_MINOR > (minor)) || \
	(GDK_PIXBUF_MAJOR == (major) && GDK_PIXBUF_MINOR == (minor) && \
	 GDK_PIXBUF_MICRO >= (micro)))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_0</NAME>
#define GDK_PIXBUF_VERSION_2_0 (G_ENCODE_VERSION (2, 0))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_2</NAME>
#define GDK_PIXBUF_VERSION_2_2 (G_ENCODE_VERSION (2, 2))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_4</NAME>
#define GDK_PIXBUF_VERSION_2_4 (G_ENCODE_VERSION (2, 4))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_6</NAME>
#define GDK_PIXBUF_VERSION_2_6 (G_ENCODE_VERSION (2, 6))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_8</NAME>
#define GDK_PIXBUF_VERSION_2_8 (G_ENCODE_VERSION (2, 8))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_10</NAME>
#define GDK_PIXBUF_VERSION_2_10 (G_ENCODE_VERSION (2, 10))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_12</NAME>
#define GDK_PIXBUF_VERSION_2_12 (G_ENCODE_VERSION (2, 12))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_14</NAME>
#define GDK_PIXBUF_VERSION_2_14 (G_ENCODE_VERSION (2, 14))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_16</NAME>
#define GDK_PIXBUF_VERSION_2_16 (G_ENCODE_VERSION (2, 16))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_18</NAME>
#define GDK_PIXBUF_VERSION_2_18 (G_ENCODE_VERSION (2, 18))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_20</NAME>
#define GDK_PIXBUF_VERSION_2_20 (G_ENCODE_VERSION (2, 20))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_22</NAME>
#define GDK_PIXBUF_VERSION_2_22 (G_ENCODE_VERSION (2, 22))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_24</NAME>
#define GDK_PIXBUF_VERSION_2_24 (G_ENCODE_VERSION (2, 24))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_26</NAME>
#define GDK_PIXBUF_VERSION_2_26 (G_ENCODE_VERSION (2, 26))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_28</NAME>
#define GDK_PIXBUF_VERSION_2_28 (G_ENCODE_VERSION (2, 28))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_30</NAME>
#define GDK_PIXBUF_VERSION_2_30 (G_ENCODE_VERSION (2, 30))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_32</NAME>
#define GDK_PIXBUF_VERSION_2_32 (G_ENCODE_VERSION (2, 32))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_34</NAME>
#define GDK_PIXBUF_VERSION_2_34 (G_ENCODE_VERSION (2, 34))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_36</NAME>
#define GDK_PIXBUF_VERSION_2_36 (G_ENCODE_VERSION (2, 36))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_38</NAME>
#define GDK_PIXBUF_VERSION_2_38 (G_ENCODE_VERSION (2, 38))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_2_40</NAME>
#define GDK_PIXBUF_VERSION_2_40 (G_ENCODE_VERSION (2, 40))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_MIN_REQUIRED</NAME>
#define GDK_PIXBUF_VERSION_MIN_REQUIRED (GDK_PIXBUF_VERSION_CUR_STABLE)
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION_MAX_ALLOWED</NAME>
#define GDK_PIXBUF_VERSION_MAX_ALLOWED  GDK_PIXBUF_VERSION_MIN_REQUIRED
</MACRO>
<MACRO>
<NAME>GDK_TYPE_PIXBUF_SIMPLE_ANIM</NAME>
#define GDK_TYPE_PIXBUF_SIMPLE_ANIM              (gdk_pixbuf_simple_anim_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_SIMPLE_ANIM</NAME>
#define GDK_PIXBUF_SIMPLE_ANIM(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_SIMPLE_ANIM, GdkPixbufSimpleAnim))
</MACRO>
<MACRO>
<NAME>GDK_IS_PIXBUF_SIMPLE_ANIM</NAME>
#define GDK_IS_PIXBUF_SIMPLE_ANIM(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_SIMPLE_ANIM))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_SIMPLE_ANIM_CLASS</NAME>
#define GDK_PIXBUF_SIMPLE_ANIM_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_SIMPLE_ANIM, GdkPixbufSimpleAnimClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_PIXBUF_SIMPLE_ANIM_CLASS</NAME>
#define GDK_IS_PIXBUF_SIMPLE_ANIM_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_SIMPLE_ANIM))
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_SIMPLE_ANIM_GET_CLASS</NAME>
#define GDK_PIXBUF_SIMPLE_ANIM_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_SIMPLE_ANIM, GdkPixbufSimpleAnimClass))
</MACRO>
<FUNCTION>
<NAME>gdk_pixbuf_simple_anim_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_simple_anim_iter_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_simple_anim_new</NAME>
<RETURNS>GdkPixbufSimpleAnim *</RETURNS>
gint   width, gint   height, gfloat rate
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_simple_anim_add_frame</NAME>
<RETURNS>void</RETURNS>
GdkPixbufSimpleAnim *animation, GdkPixbuf           *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_simple_anim_set_loop</NAME>
<RETURNS>void</RETURNS>
GdkPixbufSimpleAnim *animation, gboolean             loop
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_simple_anim_get_loop</NAME>
<RETURNS>gboolean</RETURNS>
GdkPixbufSimpleAnim *animation
</FUNCTION>
<STRUCT>
<NAME>GdkPixbufSimpleAnim</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkPixbufSimpleAnimClass</NAME>
</STRUCT>
<ENUM>
<NAME>GdkInterpType</NAME>
typedef enum {
	GDK_INTERP_NEAREST,
	GDK_INTERP_TILES,
	GDK_INTERP_BILINEAR,
	GDK_INTERP_HYPER
} GdkInterpType;
</ENUM>
<ENUM>
<NAME>GdkPixbufRotation</NAME>
typedef enum {
	GDK_PIXBUF_ROTATE_NONE             =   0,
	GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE =  90,
	GDK_PIXBUF_ROTATE_UPSIDEDOWN       = 180,
	GDK_PIXBUF_ROTATE_CLOCKWISE        = 270
} GdkPixbufRotation;
</ENUM>
<FUNCTION>
<NAME>gdk_pixbuf_scale</NAME>
<RETURNS>void</RETURNS>
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
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_composite</NAME>
<RETURNS>void</RETURNS>
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
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_composite_color</NAME>
<RETURNS>void</RETURNS>
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
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_scale_simple</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const GdkPixbuf *src, int              dest_width, int              dest_height, GdkInterpType    interp_type
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_composite_color_simple</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const GdkPixbuf *src, int              dest_width, int              dest_height, GdkInterpType    interp_type, int              overall_alpha, int              check_size, guint32          color1, guint32          color2
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_rotate_simple</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const GdkPixbuf   *src, GdkPixbufRotation  angle
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_flip</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const GdkPixbuf   *src, gboolean           horizontal
</FUNCTION>
<MACRO>
<NAME>GDK_PIXBUF_MAGIC_NUMBER</NAME>
#define GDK_PIXBUF_MAGIC_NUMBER (0x47646b50)    /* 'GdkP' */
</MACRO>
<ENUM>
<NAME>GdkPixdataType</NAME>
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;
</ENUM>
<STRUCT>
<NAME>GdkPixdata</NAME>
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;
};
</STRUCT>
<MACRO>
<NAME>GDK_PIXDATA_HEADER_LENGTH</NAME>
#define	GDK_PIXDATA_HEADER_LENGTH	(4 + 4 + 4 + 4 + 4 + 4)
</MACRO>
<FUNCTION>
<NAME>gdk_pixdata_serialize</NAME>
<DEPRECATED/>
<RETURNS>guint8 *</RETURNS>
const GdkPixdata	*pixdata, guint			*stream_length_p
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixdata_deserialize</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
GdkPixdata		*pixdata, guint			 stream_length, const guint8		*stream, GError		       **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixdata_from_pixbuf</NAME>
<DEPRECATED/>
<RETURNS>gpointer</RETURNS>
GdkPixdata		*pixdata, const GdkPixbuf	*pixbuf, gboolean		 use_rle
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_from_pixdata</NAME>
<DEPRECATED/>
<RETURNS>GdkPixbuf *</RETURNS>
const GdkPixdata	*pixdata, gboolean		 copy_pixels, GError		       **error
</FUNCTION>
<ENUM>
<NAME>GdkPixdataDumpType</NAME>
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;
</ENUM>
<FUNCTION>
<NAME>gdk_pixdata_to_csource</NAME>
<DEPRECATED/>
<RETURNS>GString *</RETURNS>
GdkPixdata		*pixdata, const gchar		*name, GdkPixdataDumpType	 dump_type
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_alpha_mode_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_PIXBUF_ALPHA_MODE</NAME>
#define GDK_TYPE_PIXBUF_ALPHA_MODE (gdk_pixbuf_alpha_mode_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_colorspace_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_COLORSPACE</NAME>
#define GDK_TYPE_COLORSPACE (gdk_colorspace_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_pixbuf_error_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_PIXBUF_ERROR</NAME>
#define GDK_TYPE_PIXBUF_ERROR (gdk_pixbuf_error_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_interp_type_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_INTERP_TYPE</NAME>
#define GDK_TYPE_INTERP_TYPE (gdk_interp_type_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_pixbuf_rotation_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_PIXBUF_ROTATION</NAME>
#define GDK_TYPE_PIXBUF_ROTATION (gdk_pixbuf_rotation_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_MAJOR</NAME>
#define GDK_PIXBUF_MAJOR (2)
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_MINOR</NAME>
#define GDK_PIXBUF_MINOR (42)
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_MICRO</NAME>
#define GDK_PIXBUF_MICRO (0)
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VERSION</NAME>
#define GDK_PIXBUF_VERSION "2.42.0"
</MACRO>
<MACRO>
<NAME>GDK_PIXBUF_VAR</NAME>
#    define GDK_PIXBUF_VAR extern
</MACRO>
<VARIABLE>
<NAME>gdk_pixbuf_major_version</NAME>
extern const guint gdk_pixbuf_major_version;
</VARIABLE>
<VARIABLE>
<NAME>gdk_pixbuf_minor_version</NAME>
extern const guint gdk_pixbuf_minor_version;
</VARIABLE>
<VARIABLE>
<NAME>gdk_pixbuf_micro_version</NAME>
extern const guint gdk_pixbuf_micro_version;
</VARIABLE>
<VARIABLE>
<NAME>gdk_pixbuf_version</NAME>
extern const char *gdk_pixbuf_version;
</VARIABLE>
