diff options
Diffstat (limited to 'lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf')
11 files changed, 1140 insertions, 0 deletions
diff --git a/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-animation.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-animation.h new file mode 100644 index 00000000..43347de6 --- /dev/null +++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-animation.h @@ -0,0 +1,147 @@ +/* -*- 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. + */ + +#ifndef GDK_PIXBUF_ANIMATION_H +#define GDK_PIXBUF_ANIMATION_H + +#include <glib.h> +#include <glib-object.h> +#include <gdk-pixbuf/gdk-pixbuf-core.h> + +G_BEGIN_DECLS + +/* Animation support */ + +typedef struct _GdkPixbufAnimation GdkPixbufAnimation; +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; + +#ifdef G_OS_WIN32 +#define gdk_pixbuf_animation_new_from_file gdk_pixbuf_animation_new_from_file_utf8 +#endif + +GdkPixbufAnimation *gdk_pixbuf_animation_new_from_file (const char *filename, + GError **error); + +#ifndef GDK_PIXBUF_DISABLE_DEPRECATED +GdkPixbufAnimation *gdk_pixbuf_animation_ref (GdkPixbufAnimation *animation); +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 + + + +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); + +}; + + + +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); +}; + + +GdkPixbufAnimation* gdk_pixbuf_non_anim_new (GdkPixbuf *pixbuf); + +#endif /* GDK_PIXBUF_ENABLE_BACKEND */ + +G_END_DECLS + +#endif /* GDK_PIXBUF_ANIMATION_H */ diff --git a/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-core.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-core.h new file mode 100644 index 00000000..4ae58952 --- /dev/null +++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-core.h @@ -0,0 +1,244 @@ +/* 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. + */ + +#ifndef GDK_PIXBUF_CORE_H +#define GDK_PIXBUF_CORE_H + +#include <glib.h> +#include <glib-object.h> + +G_BEGIN_DECLS + +/* Alpha compositing mode */ +typedef enum +{ + GDK_PIXBUF_ALPHA_BILEVEL, + GDK_PIXBUF_ALPHA_FULL +} GdkPixbufAlphaMode; + +/* Color spaces; right now only RGB is supported. + * Note that these values are encoded in inline pixbufs + * as ints, so don't reorder them + */ +typedef enum { + GDK_COLORSPACE_RGB +} GdkColorspace; + +/* All of these are opaque structures */ +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)) + + +/* Handler that must free the pixel array */ +typedef void (* GdkPixbufDestroyNotify) (guchar *pixels, gpointer data); + +#define GDK_PIXBUF_ERROR gdk_pixbuf_error_quark () + +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 +GdkPixbuf *gdk_pixbuf_ref (GdkPixbuf *pixbuf); +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); + + + +/* 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 */ + +#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 + +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_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 */ + +#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 + +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 */ + +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); + +/* 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); + +G_CONST_RETURN gchar * gdk_pixbuf_get_option (GdkPixbuf *pixbuf, + const gchar *key); + + +G_END_DECLS + + +#endif /* GDK_PIXBUF_CORE_H */ diff --git a/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-enum-types.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-enum-types.h new file mode 100644 index 00000000..f2199cc3 --- /dev/null +++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-enum-types.h @@ -0,0 +1,27 @@ + +/* Generated data (by glib-mkenums) */ + +#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/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-features.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-features.h new file mode 100644 index 00000000..794ba221 --- /dev/null +++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-features.h @@ -0,0 +1,41 @@ +#ifndef GDK_PIXBUF_FEATURES_H +#define GDK_PIXBUF_FEATURES_H 1 + +#define GDK_PIXBUF_MAJOR (2) +#define GDK_PIXBUF_MINOR (12) +#define GDK_PIXBUF_MICRO (12) +#define GDK_PIXBUF_VERSION "2.12.12" + +/* We prefix variable declarations so they can + * properly get exported/imported from Windows DLLs. + */ +#ifndef GDK_PIXBUF_VAR +# ifdef G_PLATFORM_WIN32 +# ifdef GDK_PIXBUF_STATIC_COMPILATION +# define GDK_PIXBUF_VAR extern +# else /* !GDK_PIXBUF_STATIC_COMPILATION */ +# ifdef GDK_PIXBUF_COMPILATION +# ifdef DLL_EXPORT +# define GDK_PIXBUF_VAR __declspec(dllexport) +# else /* !DLL_EXPORT */ +# define GDK_PIXBUF_VAR extern +# endif /* !DLL_EXPORT */ +# else /* !GDK_PIXBUF_COMPILATION */ +# define GDK_PIXBUF_VAR extern __declspec(dllimport) +# endif /* !GDK_PIXBUF_COMPILATION */ +# endif /* !GDK_PIXBUF_STATIC_COMPILATION */ +# else /* !G_PLATFORM_WIN32 */ +# ifndef GDK_PIXBUF_COMPILATION +# define GDK_PIXBUF_VAR extern +# else +# define GDK_PIXBUF_VAR +# endif /* !GDK_PIXBUF_COMPILATION */ +# endif /* !G_PLATFORM_WIN32 */ +#endif /* GDK_PIXBUF_VAR */ + +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 diff --git a/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-io.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-io.h new file mode 100644 index 00000000..3fe9226c --- /dev/null +++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-io.h @@ -0,0 +1,168 @@ +/* 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. + */ + +#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; + +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); + +#ifdef GDK_PIXBUF_ENABLE_BACKEND + + + +typedef void (* GdkPixbufModuleSizeFunc) (gint *width, + gint *height, + gpointer user_data); + +typedef void (* GdkPixbufModulePreparedFunc) (GdkPixbuf *pixbuf, + GdkPixbufAnimation *anim, + gpointer user_data); +typedef void (* GdkPixbufModuleUpdatedFunc) (GdkPixbuf *pixbuf, + int x, + int y, + int width, + int height, + gpointer user_data); + +typedef struct _GdkPixbufModulePattern GdkPixbufModulePattern; +struct _GdkPixbufModulePattern { + char *prefix; + char *mask; + int relevance; +}; + +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); + +}; + +typedef void (* GdkPixbufModuleFillVtableFunc) (GdkPixbufModule *module); +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); + +typedef enum /*< skip >*/ +{ + GDK_PIXBUF_FORMAT_WRITABLE = 1 << 0, + GDK_PIXBUF_FORMAT_SCALABLE = 1 << 1, + GDK_PIXBUF_FORMAT_THREADSAFE = 1 << 2 +} GdkPixbufFormatFlags; + +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/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-loader.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-loader.h new file mode 100644 index 00000000..d9b2b7dc --- /dev/null +++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-loader.h @@ -0,0 +1,98 @@ +/* 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. + */ + +#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)) + + +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/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-marshal.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-marshal.h new file mode 100644 index 00000000..64222c2c --- /dev/null +++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-marshal.h @@ -0,0 +1,34 @@ + +#ifndef ___gdk_pixbuf_marshal_MARSHAL_H__ +#define ___gdk_pixbuf_marshal_MARSHAL_H__ + +#include <glib-object.h> + +G_BEGIN_DECLS + +/* VOID:VOID (/build/buildd-gtk+2.0_2.12.12-1~lenny2-i386-2RfKoO/gtk+2.0-2.12.12/gdk-pixbuf/gdk-pixbuf-marshal.list:25) */ +#define _gdk_pixbuf_marshal_VOID__VOID g_cclosure_marshal_VOID__VOID + +/* VOID:INT,INT,INT,INT (/build/buildd-gtk+2.0_2.12.12-1~lenny2-i386-2RfKoO/gtk+2.0-2.12.12/gdk-pixbuf/gdk-pixbuf-marshal.list:26) */ +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 (/build/buildd-gtk+2.0_2.12.12-1~lenny2-i386-2RfKoO/gtk+2.0-2.12.12/gdk-pixbuf/gdk-pixbuf-marshal.list:27) */ +#define _gdk_pixbuf_marshal_VOID__POINTER g_cclosure_marshal_VOID__POINTER + +/* VOID:INT,INT (/build/buildd-gtk+2.0_2.12.12-1~lenny2-i386-2RfKoO/gtk+2.0-2.12.12/gdk-pixbuf/gdk-pixbuf-marshal.list:28) */ +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); + +G_END_DECLS + +#endif /* ___gdk_pixbuf_marshal_MARSHAL_H__ */ + diff --git a/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-simple-anim.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-simple-anim.h new file mode 100644 index 00000000..d2624042 --- /dev/null +++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-simple-anim.h @@ -0,0 +1,54 @@ +/* -*- 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. + */ + +#ifndef GDK_PIXBUF_SIMPLE_ANIM_H +#define GDK_PIXBUF_SIMPLE_ANIM_H + +#include <gdk-pixbuf/gdk-pixbuf-animation.h> + +G_BEGIN_DECLS + +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); + +G_END_DECLS + + +#endif /* GDK_PIXBUF_SIMPLE_ANIM_H */ diff --git a/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-transform.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-transform.h new file mode 100644 index 00000000..6a1bb1e5 --- /dev/null +++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf-transform.h @@ -0,0 +1,115 @@ +/* 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. + */ + +#ifndef GDK_PIXBUF_TRANSFORM_H +#define GDK_PIXBUF_TRANSFORM_H + +#include <glib.h> +#include <gdk-pixbuf/gdk-pixbuf-core.h> + + +G_BEGIN_DECLS + +/* Scaling */ + +/* Interpolation modes */ +typedef enum { + GDK_INTERP_NEAREST, + GDK_INTERP_TILES, + GDK_INTERP_BILINEAR, + GDK_INTERP_HYPER +} GdkInterpType; + +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/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf.h new file mode 100644 index 00000000..0d77b2bf --- /dev/null +++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixbuf.h @@ -0,0 +1,42 @@ +/* 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 + +#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> + + +#endif /* GDK_PIXBUF_H */ diff --git a/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixdata.h b/lib-x86-32/gtk-2.12.12/usr/include/gtk-2.0/gdk-pixbuf/gdk-pixdata.h new file mode 100644 index 00000000..eb85034b --- /dev/null +++ b/lib-x86-32/gtk-2.12.12/usr/include/gtk-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: @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__ */ |