Pixbuf

This is the main structure in the gdk-pixbuf library. It 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 (the number of bytes between the start of one row and the start of the next).

class Pixbuf : ObjectG, IconIF, LoadableIconIF {}

Constructors

this
this(GdkPixbuf* gdkPixbuf, bool ownedRef = false)

Sets our main struct and passes it to the parent class.

this
this(GdkColorspace colorspace, bool hasAlpha, int bitsPerSample, 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.

this
this(Bytes data, GdkColorspace colorspace, bool hasAlpha, int bitsPerSample, int width, int height, int rowstride)

Creates a new GdkPixbuf out of in-memory readonly image data. Currently only RGB images with 8 bits per sample are supported. This is the GBytes variant of gdk_pixbuf_new_from_data().

this
this(char[] data, GdkColorspace colorspace, bool hasAlpha, int bitsPerSample, int width, int height, int rowstride, GdkPixbufDestroyNotify destroyFn, void* destroyFnData)

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

this
this(string filename)

Creates a new pixbuf by loading an image from a file. The file format is detected automatically. If NULL is returned, then error will be set. Possible errors are in the GDK_PIXBUF_ERROR and G_FILE_ERROR domains.

this
this(string filename, int width, int height, bool preserveAspectRatio)

Creates a new pixbuf by loading an image from a file. The file format is detected automatically. If NULL is returned, then error will be set. Possible errors are in the GDK_PIXBUF_ERROR and G_FILE_ERROR domains. The image will be scaled to fit in the requested size, optionally preserving the image's aspect ratio.

this
this(string filename, int width, int height)

Creates a new pixbuf by loading an image from a file. The file format is detected automatically. If NULL is returned, then error will be set. Possible errors are in the GDK_PIXBUF_ERROR and G_FILE_ERROR domains.

this
this(ubyte[] data, bool copyPixels)

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.

this
this(InputStream stream, Cancellable cancellable)

Creates a new pixbuf by loading an image from an input stream.

this
this(InputStream stream, int width, int height, bool preserveAspectRatio, Cancellable cancellable)

Creates a new pixbuf by loading an image from an input stream.

this
this(AsyncResultIF asyncResult)

Finishes an asynchronous pixbuf creation operation started with gdk_pixbuf_new_from_stream_async().

this
this(string[] 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.

Members

Functions

addAlpha
Pixbuf addAlpha(bool substituteColor, char r, char g, char b)

Takes an existing pixbuf and adds an alpha channel to it. If the existing pixbuf already had an alpha channel, the channel values are copied from the original; otherwise, the alpha channel is initialized to 255 (full opacity).

applyEmbeddedOrientation
Pixbuf applyEmbeddedOrientation()

Takes an existing pixbuf and checks for the presence of an associated "orientation" option, which may be provided by the jpeg loader (which reads the exif orientation tag) or the tiff loader (which reads the tiff orientation tag, and compensates it for the partial transforms performed by libtiff). If an orientation option/tag is present, the appropriate transform will be performed so that the pixbuf is oriented correctly.

composite
void composite(Pixbuf dest, int destX, int destY, int destWidth, int destHeight, double offsetX, double offsetY, double scaleX, double scaleY, GdkInterpType interpType, int overallAlpha)

Creates a transformation of the source image src by scaling by scale_x and scale_y then translating by offset_x and offset_y. This gives an image in the coordinates of the destination pixbuf. The rectangle (dest_x, dest_y, dest_width, dest_height) is then alpha blended onto the corresponding rectangle of the original destination image.

compositeColor
void compositeColor(Pixbuf dest, int destX, int destY, int destWidth, int destHeight, double offsetX, double offsetY, double scaleX, double scaleY, GdkInterpType interpType, int overallAlpha, int checkX, int checkY, int checkSize, uint color1, uint color2)

Creates a transformation of the source image src by scaling by scale_x and scale_y then translating by offset_x and offset_y, then alpha blends the rectangle (dest_x ,dest_y, dest_width, dest_height) of the resulting image with a checkboard of the colors color1 and color2 and renders it onto the destination image.

compositeColorSimple
Pixbuf compositeColorSimple(int destWidth, int destHeight, GdkInterpType interpType, int overallAlpha, int checkSize, uint color1, uint color2)

Creates a new GdkPixbuf by scaling src to dest_width x dest_height and alpha blending the result with a checkboard of colors color1 and color2.

copy
Pixbuf copy()

Creates a new GdkPixbuf with a copy of the information in the specified pixbuf. Note that this does not copy the options set on the original GdkPixbuf, use gdk_pixbuf_copy_options() for this.

copyArea
void copyArea(int srcX, int srcY, int width, int height, Pixbuf destPixbuf, int destX, int destY)

Copies a rectangular area from src_pixbuf to dest_pixbuf. Conversion of pixbuf formats is done automatically.

copyOptions
bool copyOptions(Pixbuf destPixbuf)

Copy the key/value pair options attached to a GdkPixbuf to another. This is useful to keep original metadata after having manipulated a file. However be careful to remove metadata which you've already applied, such as the "orientation" option after rotating the image.

fill
void fill(uint pixel)

Clears a pixbuf to the given RGBA value, converting the RGBA value into the pixbuf's pixel format. The alpha will be ignored if the pixbuf doesn't have an alpha channel.

flip
Pixbuf flip(bool horizontal)

Flips a pixbuf horizontally or vertically and returns the result in a new pixbuf.

getBitsPerSample
int getBitsPerSample()

Queries the number of bits per color sample in a pixbuf.

getByteLength
size_t getByteLength()

Returns the length of the pixel data, in bytes.

getColorspace
GdkColorspace getColorspace()

Queries the color space of a pixbuf.

getHasAlpha
bool getHasAlpha()

Queries whether a pixbuf has an alpha channel (opacity information).

getHeight
int getHeight()

Queries the height of a pixbuf.

getNChannels
int getNChannels()

Queries the number of channels of a pixbuf.

getOption
string getOption(string key)

Looks up key in the list of options that may have been attached to the pixbuf when it was loaded, or that may have been attached by another function using gdk_pixbuf_set_option().

getOptions
HashTable getOptions()

Returns a GHashTable with a list of all the options that may have been attached to the pixbuf when it was loaded, or that may have been attached by another function using gdk_pixbuf_set_option().

getPixbufStruct
GdkPixbuf* getPixbufStruct(bool transferOwnership = false)

Get the main Gtk struct

getPixels
char* getPixels()

Queries a pointer to the pixel data of a pixbuf.

getPixelsWithLength
char[] getPixelsWithLength()

Queries a pointer to the pixel data of a pixbuf.

getRowstride
int getRowstride()

Queries the rowstride of a pixbuf, which is the number of bytes between the start of a row and the start of the next row.

getStruct
void* getStruct()

the main Gtk struct as a void*

getWidth
int getWidth()

Queries the width of a pixbuf.

newSubpixbuf
Pixbuf newSubpixbuf(int srcX, int srcY, 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.

readPixelBytes
Bytes readPixelBytes()

Provides a GBytes buffer containing the raw pixel data; the data must not be modified. This function allows skipping the implicit copy that must be made if gdk_pixbuf_get_pixels() is called on a read-only pixbuf.

readPixels
ubyte* readPixels()

Provides a read-only pointer to the raw pixel data; must not be modified. This function allows skipping the implicit copy that must be made if gdk_pixbuf_get_pixels() is called on a read-only pixbuf.

removeOption
bool removeOption(string key)

Remove the key/value pair option attached to a GdkPixbuf

rotateSimple
Pixbuf rotateSimple(GdkPixbufRotation angle)

Rotates a pixbuf by a multiple of 90 degrees, and returns the result in a new pixbuf.

saturateAndPixelate
void saturateAndPixelate(Pixbuf dest, float saturation, bool pixelate)

Modifies saturation and optionally pixelates src, placing the result in dest. src and dest may be the same pixbuf with no ill effects. If saturation is 1.0 then saturation is not changed. If it's less than 1.0, saturation is reduced (the image turns toward grayscale); if greater than 1.0, saturation is increased (the image gets more vivid colors). If pixelate is TRUE, then pixels are faded in a checkerboard pattern to create a pixelated image. src and dest must have the same image format, size, and rowstride.

saveToBuffer
bool saveToBuffer(out ubyte[] buffer, string type, string[] optionKeys, string[] optionValues)

Saves pixbuf to a new buffer in format type, which is currently "jpeg", "tiff", "png", "ico" or "bmp". See gdk_pixbuf_save_to_buffer() for more details.

saveToCallbackv
bool saveToCallbackv(GdkPixbufSaveFunc saveFunc, void* userData, string type, string[] optionKeys, string[] optionValues)

Saves pixbuf to a callback in format type, which is currently "jpeg", "png", "tiff", "ico" or "bmp". If error is set, FALSE will be returned. See gdk_pixbuf_save_to_callback () for more details.

saveToStreamv
bool saveToStreamv(OutputStream stream, string type, string[] optionKeys, string[] optionValues, Cancellable cancellable)

Saves pixbuf to an output stream.

saveToStreamvAsync
void saveToStreamvAsync(OutputStream stream, string type, string[] optionKeys, string[] optionValues, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)

Saves pixbuf to an output stream asynchronously.

savev
bool savev(string filename, string type, string[] optionKeys, string[] optionValues)

Saves pixbuf to a file in type, which is currently "jpeg", "png", "tiff", "ico" or "bmp". If error is set, FALSE will be returned. See gdk_pixbuf_save () for more details.

scale
void scale(Pixbuf dest, int destX, int destY, int destWidth, int destHeight, double offsetX, double offsetY, double scaleX, double scaleY, GdkInterpType interpType)

Creates a transformation of the source image src by scaling by scale_x and scale_y then translating by offset_x and offset_y, then renders the rectangle (dest_x, dest_y, dest_width, dest_height) of the resulting image onto the destination image replacing the previous contents.

scaleSimple
Pixbuf scaleSimple(int destWidth, int destHeight, GdkInterpType interpType)

Create a new GdkPixbuf containing a copy of src scaled to dest_width x dest_height. Leaves src unaffected. interp_type should be GDK_INTERP_NEAREST if you want maximum speed (but when scaling down GDK_INTERP_NEAREST is usually unusably ugly). The default interp_type should be GDK_INTERP_BILINEAR which offers reasonable quality and speed.

setOption
bool setOption(string key, string 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.

Static functions

calculateRowstride
int calculateRowstride(GdkColorspace colorspace, bool hasAlpha, int bitsPerSample, int width, int height)

Calculates the rowstride that an image created with those values would have. This is useful for front-ends and backends that want to sanity check image values without needing to create them.

fromPixdata
Pixbuf fromPixdata(Pixdata pixdata, bool copyPixels)

Converts a GdkPixdata to a GdkPixbuf If copy_pixels is TRUE or if the pixel data is run-length-encoded, the pixel data is copied into newly-allocated memory; otherwise it is reused.

getFileInfo
PixbufFormat getFileInfo(string filename, out int width, out int height)

Parses an image file far enough to determine its format and size.

getFileInfoAsync
void getFileInfoAsync(string filename, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)

Asynchronously parses an image file far enough to determine its format and size.

getFileInfoFinish
PixbufFormat getFileInfoFinish(AsyncResultIF asyncResult, out int width, out int height)

Finishes an asynchronous pixbuf parsing operation started with gdk_pixbuf_get_file_info_async().

getFormats
ListSG getFormats()

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

getType
GType getType()
newFromResource
Pixbuf newFromResource(string resourcePath)

Creates a new pixbuf by loading an image from an resource.

newFromResource
Pixbuf newFromResource(string resourcePath, int width, int height, bool preserveAspectRatio)

Creates a new pixbuf by loading an image from an resource.

newFromStreamAsync
void newFromStreamAsync(InputStream stream, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)

Creates a new pixbuf by asynchronously loading an image from an input stream.

newFromStreamAtScaleAsync
void newFromStreamAtScaleAsync(InputStream stream, int width, int height, bool preserveAspectRatio, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)

Creates a new pixbuf by asynchronously loading an image from an input stream.

saveToStreamFinish
bool saveToStreamFinish(AsyncResultIF asyncResult)

Finishes an asynchronous pixbuf save operation started with gdk_pixbuf_save_to_stream_async().

Variables

gdkPixbuf
GdkPixbuf* gdkPixbuf;

the main Gtk struct