|  |  |  | The gdk-pixbuf Library |  | 
|---|
| Image Data in MemoryImage Data in Memory — Creating a pixbuf from image data that is already in memory. | 
#include <gdk-pixbuf/gdk-pixbuf.h> GdkPixbuf* gdk_pixbuf_new (GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample, int width, int height); 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); GdkPixbuf* gdk_pixbuf_new_subpixbuf (GdkPixbuf *src_pixbuf, int src_x, int src_y, int width, int height); GdkPixbuf* gdk_pixbuf_copy (const GdkPixbuf *pixbuf);
    The most basic way to create a pixbuf is to wrap an existing pixel
    buffer with a GdkPixbuf structure.  You can use the
    gdk_pixbuf_new_from_data() function to do this You need to specify
    the destroy notification function that will be called when the
    data buffer needs to be freed; this will happen when a GdkPixbuf
    is finalized by the reference counting functions If you have a
    chunk of static data compiled into your application, you can pass
    in NULL as the destroy notification function so that the data
    will not be freed.
  
    The gdk_pixbuf_new() function can be used as a convenience to
    create a pixbuf with an empty buffer.  This is equivalent to
    allocating a data buffer using malloc()gdk_pixbuf_new_from_data().  The gdk_pixbuf_new() 
    function will compute an optimal rowstride so that rendering can be 
    performed with an efficient algorithm.
  
    As a special case, you can use the gdk_pixbuf_new_from_xpm_data()
    function to create a pixbuf from inline XPM image data.
  
    You can also copy an existing pixbuf with the gdk_pixbuf_copy()
    function.  This is not the same as just doing a g_object_ref()
    on the old pixbuf; the copy function will actually duplicate the
    pixel data in memory and create a new GdkPixbuf structure for it.
  
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.
| colorspace: | Color space for image. | 
| has_alpha: | Whether the image should have transparency information. | 
| bits_per_sample: | Number of bits per color sample. | 
| width: | Width of image in pixels. | 
| height: | Height of image in pixels. | 
| Returns : | A newly-created GdkPixbuf with a reference count of 1, or NULLif not enough memory could be allocated for the image buffer. | 
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.
| data: | Image data in 8-bit/sample packed format. | 
| colorspace: | Colorspace for the image data. | 
| has_alpha: | Whether the data has an opacity channel. | 
| bits_per_sample: | Number of bits per sample. | 
| width: | Width of the image in pixels. | 
| height: | Height of the image in pixels. | 
| rowstride: | Distance in bytes between row starts. | 
| destroy_fn: | Function used to free the data when the pixbuf's reference count
drops to zero, or NULLif the data should not be freed. | 
| destroy_fn_data: | Closure data to pass to the destroy notification function. | 
| Returns : | A newly-created GdkPixbuf structure with a reference count of 1. | 
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.
| data: | Pointer to inline XPM data. | 
| Returns : | A newly-created pixbuf with a reference count of 1. | 
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.
GTK+ 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:
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:
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.
| data_length: | Length in bytes of the dataargument or -1 to 
   disable length checks | 
| data: | Byte data containing a serialized GdkPixdata structure | 
| copy_pixels: | Whether to copy the pixel data, or use direct pointers datafor the resulting pixbuf | 
| error: | GError return location, may be NULLto ignore errors | 
| Returns : | A newly-created GdkPixbuf structure with a reference,
  count of 1, or NULLif an error occurred. | 
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.
| src_pixbuf: | a GdkPixbuf | 
| src_x: | X coord in src_pixbuf | 
| src_y: | Y coord in src_pixbuf | 
| width: | width of region in src_pixbuf | 
| height: | height of region in src_pixbuf | 
| Returns : | a new pixbuf | 
| << File saving | Inline data >> |