gdk_pixbuf_init_modules ()

gboolean
gdk_pixbuf_init_modules (const char *path,
                         GError **error);

Initalizes the gdk-pixbuf loader modules referenced by the loaders.cache file present inside that directory.

This is to be used by applications that want to ship certain loaders in a different location from the system ones.

This is needed when the OS or runtime ships a minimal number of loaders so as to reduce the potential attack surface of carefully crafted image files, especially for uncommon file types. Applications that require broader image file types coverage, such as image viewers, would be expected to ship the gdk-pixbuf modules in a separate location, bundled with the application in a separate directory from the OS or runtime- provided modules.

Since: 2.40

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_copy ()

GdkPixbufFormat *
gdk_pixbuf_format_copy (const GdkPixbufFormat *format);

Creates a copy of format

Since: 2.22

gdk_pixbuf_format_free ()

void
gdk_pixbuf_format_free (GdkPixbufFormat *format);

Frees the resources allocated when copying a GdkPixbufFormat using gdk_pixbuf_format_copy()

Since: 2.22

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_save_option_supported ()

gboolean
gdk_pixbuf_format_is_save_option_supported
                               (GdkPixbufFormat *format,
                                const gchar *option_key);

Returns TRUE if the save option specified by option_key is supported when saving a pixbuf using the module implementing format . See gdk_pixbuf_save() for more information about option keys.

Since: 2.36

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

gdk_pixbuf_format_is_scalable ()

gboolean
gdk_pixbuf_format_is_scalable (GdkPixbufFormat *format);

Returns whether this image format is scalable. If a file is in a scalable format, it is preferable to load it at the desired size, rather than loading it at the default size and scaling the resulting pixbuf to the desired size.

Since: 2.6

gdk_pixbuf_format_is_disabled ()

gboolean
gdk_pixbuf_format_is_disabled (GdkPixbufFormat *format);

Returns whether this image format is disabled. See gdk_pixbuf_format_set_disabled().

Since: 2.6

gdk_pixbuf_format_set_disabled ()

void
gdk_pixbuf_format_set_disabled (GdkPixbufFormat *format,
                                gboolean disabled);

Disables or enables an image format. If a format is disabled, gdk-pixbuf won't use the image loader for this format to load images. Applications can use this to avoid using image loaders with an inappropriate license, see gdk_pixbuf_format_get_license().

Since: 2.6

gdk_pixbuf_format_get_license ()

gchar *
gdk_pixbuf_format_get_license (GdkPixbufFormat *format);

Returns information about the license of the image loader for the format. The returned string should be a shorthand for a wellknown license, e.g. "LGPL", "GPL", "QPL", "GPL/QPL", or "other" to indicate some other license. This string should be freed with g_free() when it's no longer needed.

Since: 2.6

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 GdkPixbufFormat

struct GdkPixbufFormat {
  gchar *name;
  GdkPixbufModulePattern *signature;
  gchar *domain;
  gchar *description;
  gchar **mime_types;
  gchar **extensions;
  guint32 flags;
  gboolean disabled;
  gchar *license;
};

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

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

Since: 2.2

struct GdkPixbufModulePattern

struct GdkPixbufModulePattern {
	char *prefix;
	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, called the mask, if not NULL, must be of the same length as the first one and may contain ' ', '!', 'x', 'z', and 'n' to indicate bytes that must be matched, not matched, "don't-care"-bytes, zeros and non-zeros. Each prefix has an associated integer that describes the relevance of the prefix, with 0 meaning a mismatch and 100 a "perfect match".

Starting with gdk-pixbuf 2.8, the first byte of the mask may be '*', indicating an unanchored pattern that matches not only at the beginning, but also in the middle. Versions prior to 2.8 will interpret the '*' like an 'x'.

The signature of a module is stored as an array of 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

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

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.