gdk_pixbuf_new ()

GdkPixbuf *         gdk_pixbuf_new                      (GdkColorspace colorspace,
                                                         gboolean has_alpha,
                                                         int bits_per_sample,
                                                         int width,
                                                         int height);

Creates a new GdkPixbuf structure and allocates a buffer for it. The buffer has an optimal rowstride. Note that the buffer is not cleared; you will have to fill it completely yourself.

gdk_pixbuf_new_from_data ()

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

Creates a new GdkPixbuf out of in-memory image data. Currently only RGB images with 8 bits per sample are supported.

gdk_pixbuf_new_from_xpm_data ()

GdkPixbuf *         gdk_pixbuf_new_from_xpm_data        (const char **data);

Creates a new pixbuf by parsing XPM data in memory. This data is commonly the result of including an XPM file into a program's C source.

gdk_pixbuf_new_from_inline ()

GdkPixbuf*          gdk_pixbuf_new_from_inline          (gint data_length,
                                                         const guint8 *data,
                                                         gboolean copy_pixels,
                                                         GError **error);

Create a GdkPixbuf from a flat representation that is suitable for storing as inline data in a program. This is useful if you want to ship a program with images, but don't want to depend on any external files.

gdk-pixbuf ships with a program called gdk-pixbuf-csource which allows for conversion of GdkPixbufs into such a inline representation. In almost all cases, you should pass the --raw flag to gdk-pixbuf-csource. A sample invocation would be:

1

gdk-pixbuf-csource --raw --name=myimage_inline myimage.png

For the typical case where the inline pixbuf is read-only static data, you don't need to copy the pixel data unless you intend to write to it, so you can pass FALSE for copy_pixels. (If you pass --rle to gdk-pixbuf-csource, a copy will be made even if copy_pixels is FALSE, so using this option is generally a bad idea.)

If you create a pixbuf from const inline data compiled into your program, it's probably safe to ignore errors and disable length checks, since things will always succeed:

1

pixbuf = gdk_pixbuf_new_from_inline (-1, myimage_inline, FALSE, NULL);

For non-const inline data, you could get out of memory. For untrusted inline data located at runtime, you could have corrupt inline data in addition.

gdk_pixbuf_new_subpixbuf ()

GdkPixbuf *         gdk_pixbuf_new_subpixbuf            (GdkPixbuf *src_pixbuf,
                                                         int src_x,
                                                         int src_y,
                                                         int width,
                                                         int height);

Creates a new pixbuf which represents a sub-region of src_pixbuf. The new pixbuf shares its pixels with the original pixbuf, so writing to one affects both. The new pixbuf holds a reference to src_pixbuf, so src_pixbuf will not be finalized until the new pixbuf is finalized.

gdk_pixbuf_copy ()

GdkPixbuf *         gdk_pixbuf_copy                     (const GdkPixbuf *pixbuf);

Creates a new GdkPixbuf with a copy of the information in the specified pixbuf.