gdk_pixbuf_set_option ()

gboolean    gdk_pixbuf_set_option           (GdkPixbuf *pixbuf,
                                             const gchar *key,
                                             const gchar *value);

Attaches a key/value pair as an option to a GdkPixbuf. If key already exists in the list of options attached to pixbuf, the new value is ignored and FALSE is returned.

Since 2.2

gdk_pixbuf_get_formats ()

GSList*     gdk_pixbuf_get_formats          (void);

Obtains the available information about the image formats supported by GdkPixbuf.

Since 2.2

gdk_pixbuf_format_get_name ()

gchar*      gdk_pixbuf_format_get_name      (GdkPixbufFormat *format);

Returns the name of the format.

Since 2.2

gdk_pixbuf_format_get_description ()

gchar*      gdk_pixbuf_format_get_description
                                            (GdkPixbufFormat *format);

Returns a description of the format.

Since 2.2

gdk_pixbuf_format_get_mime_types ()

gchar**     gdk_pixbuf_format_get_mime_types
                                            (GdkPixbufFormat *format);

Returns the mime types supported by the format.

Since 2.2

gdk_pixbuf_format_get_extensions ()

gchar**     gdk_pixbuf_format_get_extensions
                                            (GdkPixbufFormat *format);

Returns the filename extensions typically used for files in the given format.

Since 2.2

gdk_pixbuf_format_is_writable ()

gboolean    gdk_pixbuf_format_is_writable   (GdkPixbufFormat *format);

Returns whether pixbufs can be saved in the given format.

Since 2.2

struct GdkPixbufFormat

struct GdkPixbufFormat {

  gchar *name;
  GdkPixbufModulePattern *signature;
  gchar *domain;
  gchar *description;
  gchar **mime_types;
  gchar **extensions;
  guint32 flags;
};

A GdkPixbufFormat contains information about the image format accepted by a module. Only modules should access the fields directly, applications should use the gdk_pixbuf_format_* functions.

Since 2.2

enum GdkPixbufFormatFlags

typedef enum /*< skip >*/
{
  GDK_PIXBUF_FORMAT_WRITABLE = 1 << 0,
} GdkPixbufFormatFlags;

Flags which allow a module to specify further details about the supported operations.

Since 2.2

struct GdkPixbufModulePattern

struct GdkPixbufModulePattern {

	unsigned char *prefix;
	unsigned char *mask;
	int relevance;
};

The signature of a module is a set of prefixes. Prefixes are encoded as pairs of ordinary strings, where the second string, if not NULL, must be of the same length as the first one and may contain ' ', '!', 'x', 'z', and 'n' to indicate bytes that must be matched, not matched, "don't-care"-bytes, zeros and non-zeros. Each prefix has an associated integer that describes the relevance of the prefix, with 0 meaning a mismatch and 100 a "perfect match".

The signature of a module is stored as an array of GdkPixbufModulePatterns. The array is terminated by a pattern where the prefix is NULL.

GdkPixbufModulePattern *signature[] = {
  { "abcdx", " !x z", 100 },
  { "bla", NULL,  90 },
  { NULL, NULL, 0 }
};

Since 2.2

GdkPixbufModuleFillVtableFunc ()

void        (*GdkPixbufModuleFillVtableFunc)
                                            (GdkPixbufModule *module);

Defines the type of the function used to set the vtable of a GdkPixbufModule when it is loaded.

Since 2.2

GdkPixbufModuleFillInfoFunc ()

void        (*GdkPixbufModuleFillInfoFunc)  (GdkPixbufFormat *info);

Defines the type of the function used to fill a GdkPixbufFormat structure with information about a module.

Since 2.2

GdkPixbufModuleSizeFunc ()

void        (*GdkPixbufModuleSizeFunc)      (gint *width,
                                             gint *height,
                                             gpointer user_data);

Defines the type of the function that gets called once the size of the loaded image is known.

The function is expected to set width and height to the desired size to which the image should be scaled. If a module has no efficient way to achieve the desired scaling during the loading of the image, it may either ignore the size request, or only approximate it -- gdk-pixbuf will then perform the required scaling on the completely loaded image.

If the function sets width or height to zero, the module should interpret this as a hint that it will be closed soon and shouldn't allocate further resources. This convention is used to implement gdk_pixbuf_get_file_info() efficiently.

Since 2.2

GdkPixbufModulePreparedFunc ()

void        (*GdkPixbufModulePreparedFunc)  (GdkPixbuf *pixbuf,
                                             GdkPixbufAnimation *anim,
                                             gpointer user_data);

Defines the type of the function that gets called once the initial setup of pixbuf is done.

GdkPixbufLoader uses a function of this type to emit the "area_prepared" signal.

Since 2.2

GdkPixbufModuleUpdatedFunc ()

void        (*GdkPixbufModuleUpdatedFunc)   (GdkPixbuf *pixbuf,
                                             int x,
                                             int y,
                                             int width,
                                             int height,
                                             gpointer user_data);

Defines the type of the function that gets called every time a region of pixbuf is updated.

GdkPixbufLoader uses a function of this type to emit the "area_updated" signal.

Since 2.2

struct 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);
  
};

A GdkPixbufModule contains the necessary functions to load and save images in a certain file format.

A GdkPixbufModule can be loaded dynamically from a GModule. Each loadable module must contain a GdkPixbufModuleFillVtableFunc function named fill_vtable, which will get called when the module is loaded and must set the function pointers of the GdkPixbufModule.

struct GdkPixbufAnimationClass

struct GdkPixbufAnimationClass {

        GObjectClass parent_class;


        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);

};

Modules supporting animations must derive a type from GdkPixbufAnimation, providing suitable implementations of the virtual functions.

struct GdkPixbufAnimationIterClass

struct GdkPixbufAnimationIterClass {

        GObjectClass parent_class;


        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);
};

Modules supporting animations must derive a type from GdkPixbufAnimationIter, providing suitable implementations of the virtual functions.