Pixbufs are bitmap images in memory.

• A Pixbuf is used to represent images. It contains information about the image's pixel data, its color space, bits per sample, width and height, and the rowstride or number of bytes between rows.
• This module contains functions to scale and crop Pixbufs and to scale and crop a Pixbuf and compose the result with an existing image.
• Pixbufs can be displayed on screen by either creating an Image that from the Pixbuf or by rendering (part of) the Pixbuf into a vanilla widget like DrawWindow using Graphics.UI.Gtk.Gdk.Drawable.drawPixbuf.

 | GObject
 | +----Pixbuf

Create a new image in memory.

• Creates a new pixbuf structure and allocates a buffer for it. Note that the buffer is not cleared initially.
• The boolean flag is true if the pixbuf should have an alpha (transparency) channel. The next integer denotes the bits per color sample, e.g. 8 bits per color for 2^24 colors. The last two integers denote the width and height, respectively.

Load an image synchonously.

• Use this function to load only small images as this call will block.
• If an error occurs, the function will throw an exception that can be caught using e.g. System.Glib.GError.catchGErrorJust and one of the error codes in PixbufError.

Creates a new pixbuf by loading an image from a file. The file format is detected automatically. The image will be scaled to fit in the requested size, preserving the image's aspect ratio.

• If an error occurs, the function will throw an exception that can be caught using e.g. System.Glib.GError.catchGErrorJust and one of the error codes in PixbufError.
• Available since Gtk+ version 2.4

Create a new image from a static pointer.

• Like pixbufNewFromXPMData, this function allows to include images in the final binary program. The method used by this function uses a binary representation and therefore needs less space in the final executable. Save the image you want to include as png and run:

 @echo #include "my_image.h" > my_image.c
 gdk-pixbuf-csource --raw --extern --name=my_image myimage.png >> my_image.c

on it. Write a header file my_image.h containing:

 #include <gdk/gdk.h>
 extern guint8 my_image[];

and save it in the current directory. The created file can be compiled with:

 cc -c my_image.c `pkg-config --cflags gdk-2.0`

into an object file which must be linked into your Haskell program by specifying my_image.o and "-#include my_image.h" on the command line of GHC. Within you application you delcare a pointer to this image:

 foreign label "my_image" myImage :: Ptr InlineImage

Calling pixbufNewFromInline with this pointer will return the image in the object file. Creating the C file with the --raw flag will result in a non-compressed image in the object file. The advantage is that the picture will not be copied when this function is called.

Create a restricted view of an image.

• This function returns a Pixbuf object which shares the image of the original one but only shows a part of it. Modifying either buffer will affect the other.
• This function throw an exception if the requested bounds are invalid.

Create a new image from a String.

• Creates a new pixbuf from a string description.

Queries the number of colors for each pixel.

• This function returns 3 for an RGB image without alpha (transparency) channel, 4 for an RGB image with alpha channel.

Query if the image has an alpha channel.

• The alpha channel determines the opaqueness of the pixel.

Queries the number of bits for each color.

• Each pixel is has a number of cannels for each pixel, each channel has this many bits.

Retrieve the internal array of raw image data.

• Image data in a pixbuf is stored in memory in uncompressed, packed format. Rows in the image are stored top to bottom, and in each row pixels are stored from left to right. There may be padding at the end of a row. The rowstride value of a pixbuf, as returned by pixbufGetRowstride, indicates the number of bytes between rows.
• The returned array is a flat representation of a three dimensional array: x-coordiante, y-coordinate and several channels for each color. The number of channels is usually 3 for plain RGB data or 4 for RGB data with an alpha channel. To read or write a specific pixel use the formula: p = y * rowstride + x * nChannels for the pixel. If the array contains bytes (or Word8s), p+0 is the red value, p+1 green, p+2 blue and p+3 the alpha (transparency) channel if present. If the alpha channel is present, the array can accessed as an array over Word32 to modify a whole pixel at a time. See also pixbufGetBitsPerSample and pixbufGetNChannels.
• Calling this function without explicitly giving it a type will often lead to a compiler error since the type parameter e is underspecified. If this happens the function can be explicitly typed: pbData <- (pixbufGetPixels pb :: IO (PixbufData Int Word8))
• If modifying an image through Haskell's array interface is not fast enough, it is possible to use unsafeRead and unsafeWrite which have the same type signatures as readArray and writeArray. Note that these are internal functions that might change with GHC.

Queries the rowstride of this image.

• Queries the rowstride of a pixbuf, which is the number of bytes between rows. Use this value to caculate the offset to a certain row.

Returns an attribut of an image.

• Looks up if some information was stored under the key when this image was saved.

Save an image to disk.

• The function takes a list of key - value pairs to specify either how an image is saved or to actually save this additional data with the image. JPEG images can be saved with a "quality" parameter; its value should be in the range [0,100]. Text chunks can be attached to PNG images by specifying parameters of the form "tEXt::key", where key is an ASCII string of length 1-79. The values are Unicode strings.
• If an error occurs, the function will throw an exception that can be caught using e.g. System.Glib.GError.catchGErrorJust and one of the error codes in PixbufError.

Fills a Pixbuf with a color.

• The passed-in color is a quadruple consisting of the red, green, blue and alpha component of the pixel. If the Pixbuf does not have an alpha channel, the alpha value is ignored.

Take a screenshot of a Drawable.

• This function creates a Pixbuf and fills it with the image currently in the Drawable (which might be invalid if the window is obscured or minimized). Note that this transfers data from the server to the client on X Windows.
• This function will return a Pixbuf with no alpha channel containing the part of the Drawable specified by the rectangle. The function will return Nothing if the window is not currently visible.