gdk-sharp 2.12.0.0 Gtk# is thread aware, but not thread safe; See the Gtk# Thread Programming for details.

In memory image handling and representation.

The class is used to represent an image in memory, typically on the client side (this is different from that represents a server-side image). The in-memory representation uses either a three byte RGB representation or a four byte RGBA representation. Pixbufs can be created from a number of sources: image files in an assorted set of file formats (png, tiff, jpg, gif, xpm, pcx, ico, xpm, xbm); Drawables (which can be windows on the X server, or off-screen images in the X server) or in-memory images. A pixbuf can be rendered, scaled or composited into another pixbuf, into a window on the X server, or on a drawable in the X server. Various rendering methods are provided for this purpose. Pixbufs can also be saved to a number of different file formats. An example that composites two images next to each other.


// Compile with: mcs -pkg:gtk-sharp PixmapComposite.cs
// Usage: PixmapComposite.exe image-1.jpg image-2.jpg composite.jpg
using Gdk;
using System;

public class PixmapComposite
{
	public static void Main (string [] args)
	{
		// Check arguments, this takes three.
		if (args.Length < 3)
			throw new Exception ("USAGE: image1Filename image2Filename "
				+ "compositeFilename");

		// Figure out the output type
		string type = "jpeg";

		if (args [2].ToLower ().EndsWith (".jpg"))
			type = "jpeg";
		else if (args [2].ToLower ().EndsWith (".png"))
			type = "png";
		else
			throw new Exception ("Only JPG and PNG images are supported for "
				+ "the composite image");

		// Init the system
		Gdk.Global.InitCheck(ref args);

		// Load the images
		Pixbuf image1 = new Pixbuf (args [0]);
		Pixbuf image2 = new Pixbuf (args [1]);

		// Create the composite image
		Colorspace colorspace = image1.Colorspace;
		bool hasAlpha	      = image1.HasAlpha;
		int bitsPerSample     = image1.BitsPerSample;
		Pixbuf composite      = new Pixbuf (colorspace,
			hasAlpha,
			bitsPerSample,
			image1.Width + image2.Width,
			image1.Height);
		
		// Composite the images on the central one
		image1.Composite (composite,
			0, 0, image1.Width, image1.Height,
			0.0, 0.0, 1.0, 1.0,
			InterpType.Hyper,
			255);
		image2.Composite (composite,
			image1.Width, 0, image2.Width, image2.Height,
			image1.Width, 0.0, 1.0, 1.0,
			InterpType.Hyper,
			255);
		
		// Write out the image as a JPG
		composite.Save (args [2], type);
	}
}

GLib.Object Method Gdk.Pixbuf

Creates a Pixbuf from a Pixdata

Source Gdk.Pixdata Whether to make a private copy of the data The return value is an initialized Pixbuf class This creates a Pixbuf from a class that implements the Gdk.Pixdata interface. Method Gdk.Pixbuf

Adds an alpha channel to the Pixbuf

Whether to set a color to zero opacity. If this is , then the (r, g, b) arguments will be ignored. Red value to substitute Green value to substitute Blue value to substitute A new pixbuf with an alpha channel. 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). If is , then the color specified by (, , ) will be assigned zero opacity. That is, if you pass (255, 255, 255) for the substitute color, all white pixels will become fully transparent. The original image is not modified, a copy of the image is made and returned. Method Gdk.Pixbuf

Scaling with checkboard rendering

The width of destination image The height of destination image The interpolation type for the transformation. Overall alpha for source image (0..255) The size of checks in the checkboard (must be a power of two) The color of check at upper left The color of the other check The new Pixbuf, or if not enough memory could be allocated for it. Creates a new Pixbuf by scaling to x and compositing the result with a checkboard of colors and . The colors must be in RGB format. Method Gdk.Pixbuf

Scales a Pixbuf

The width of destination image The height of destination image The interpolation type for the transformation A new Pixbuf object, or if no memory is available for the transformation. Create a new GdkPixbuf containing a copy of src scaled to x . It leaves the current Pixbuf unaffected. should be if you want maximum speed (but when scaling down is usually unusably ugly). The default should be which offers reasonable quality and speed. You can scale a sub-portion of the Pixbuf by creating a sub-pixbuf using a Pixbuf constructor. For more complicated scale/compositions see and Method System.Void

Scale and Compose a Pixbuf with control over the checks

The destination Pixbuf to render to. The left coordinate for region to render The top coordinate for region to render The width of the region to render The height of the region to render The offset in the X direction (currently rounded to an integer) The offset in the Y direction (currently rounded to an integer) The scale factor in the X direction The scale factor in the Y direction The interpolation type for the transformation. Overall alpha for source image (0..255) The X offset for the checkboard (origin of checkboard is at -check_x, -check_y) The Y offset for the checkboard The size of checks in the checkboard (must be a power of two) The color of check at upper left The color of the other check Creates a transformation of the Pixbuf by scaling by and then translating by and , then composites the rectangle ( ,, , ) of the resulting image with a checkboard of the colors and and renders it onto the destination image. The and encode the color in 32-bit RGB format. Method Gdk.Pixbuf Source . A colormap (if src does not have one set) (A Source X coordinate within drawable. Source Y coordinate within drawable. Destination X coordinate in pixbuf, or 0 if dest is . Destination Y coordinate in pixbuf, or 0 if dest is . Width in pixels of region to get. Height in pixels of region to get.

Gets an image from a Gdk.Image

The value of the Pixbuf (the same one that was passed) or on error. See the remarks below for details on the possible ways on which this function might fail. Transfers image data from a and converts it to an RGB(A) representation inside a . In other words, copies image data from the Image (which might be potentially shared using shared memory between the client and the server) to a client-side RGB(A) buffer (the Pixbuf). This allows you to efficiently read individual pixels on the client side. If the has no colormap ( returns ), then a suitable colormap must be specified. Typically a or a pixmap created by passing a to the constructor will already have a colormap associated with it. If the has a colormap, the argument will be ignored. If the is a bitmap (1 bit per pixel pixmap), then a colormap is not required; pixels with a value of 1 are assumed to be white, and pixels with a value of 0 are assumed to be black. For taking screenshots, the property returns the correct colormap to use. If the specified destination pixbuf is , then this function will create an RGB Pixbuf with 8 bits per channel and no alpha, with the same size specified by the width and height arguments. In this case, the and arguments must be specified as 0. If the specified destination pixbuf is not and it contains alpha information, then the filled pixels will be set to full opacity (alpha = 255). If the specified is a pixmap, then the requested source rectangle must be completely contained within the pixmap, otherwise the function will return . For pixmaps only (not for windows) passing -1 for or is allowed, to mean the full width or height of the pixmap. If the specified is a window, and the window is off the screen, then there is no image data in the obscured/offscreen regions to be placed in the pixbuf. The contents of portions of the corresponding to the offscreen region are undefined. If the window you are obtaining data from is partially obscured by other windows, then the contents of the Pixbuf areas corresponding to the obscured regions are undefined. If the target image is not mapped (typically because it's iconified/minimized or not on the current workspace), then will be returned. If memory can't be allocated for the return value, will be returned instead. (In short, there are several ways this function can fail, and if it fails it returns ; so check the return value.) Method System.Void

Renders the image into a Drawable

Destination drawable. GC used for rendering. Source X coordinate within pixbuf. Source Y coordinate within pixbuf. Destination X coordinate within drawable. Destination Y coordinate within drawable. Width of region to render, in pixels, or -1 to use pixbuf width Height of region to render, in pixels, or -1 to use pixbuf height Dithering mode for GdkRGB. X offset for dither. Y offset for dither. Renders a rectangular portion of the Pixbuf into the while using the specified . This is done using GdkRGB, so the specified drawable must have the visual and colormap. Note that this function will ignore the opacity information for images with an alpha channel; the GC must already have the clipping mask set if you want transparent regions to show through. For an explanation of dither offsets, see the GdkRGB documentation. In brief, the dither offset is important when re-rendering partial regions of an image to a rendered version of the full image, or for when the offsets to a base position change, as in scrolling. The dither matrix has to be shifted for consistent visual results. If you do not have any of these cases, the dither offsets can be both zero. Method Gdk.Pixbuf Destination pixbuf, or if a new pixbuf should be created.. A colormap (if src does not have one set) (A Source X coordinate within drawable. Source Y coordinate within drawable. Destination X coordinate in pixbuf, or 0 if dest is . Destination Y coordinate in pixbuf, or 0 if dest is . Width in pixels of region to get. Height in pixels of region to get.

Gets image from a Gdk.Drawable

The value of the Pixbuf (the same one that was passed) or on error. See the remarks below for details on the possible ways on which this function might fail. Transfers image data from a and converts it to an RGB(A) representation inside a . In other words, copies image data from a server-side drawable to a client-side RGB(A) buffer. This allows you to efficiently read individual pixels on the client side. If the has no colormap ( returns ), then a suitable colormap must be specified. Typically a or a pixmap created by passing a to the constructor will already have a colormap associated with it. If the has a colormap, the argument will be ignored. If the is a bitmap (1 bit per pixel pixmap), then a colormap is not required; pixels with a value of 1 are assumed to be white, and pixels with a value of 0 are assumed to be black. For taking screenshots, the property returns the correct colormap to use. If the specified destination pixbuf is , then this function will create an RGB Pixbuf with 8 bits per channel and no alpha, with the same size specified by the width and height arguments. In this case, the and arguments must be specified as 0. If the specified destination pixbuf is not and it contains alpha information, then the filled pixels will be set to full opacity (alpha = 255). If the specified is a pixmap, then the requested source rectangle must be completely contained within the pixmap, otherwise the function will return . For pixmaps only (not for windows) passing -1 for or is allowed, to mean the full width or height of the pixmap. If the specified is a window, and the window is off the screen, then there is no image data in the obscured/offscreen regions to be placed in the pixbuf. The contents of portions of the corresponding to the offscreen region are undefined. If the window you are obtaining data from is partially obscured by other windows, then the contents of the Pixbuf areas corresponding to the obscured regions are undefined. If the target drawable is not mapped (typically because it's iconified/minimized or not on the current workspace), then will be returned. If memory can't be allocated for the return value, will be returned instead. (In short, there are several ways this function can fail, and if it fails it returns ; so check the return value.) This function calls internally and converts the resulting image to a , so the documentation for is also relevant. Method Gdk.Pixbuf

Copies the Pixbuf

A copy of the data in the Pixbuf, or on failure Method System.Void

Render pixbuf alpha channel as a bi-level clip mask to a

The destination, a 1-bit-depth . Source X coordinate. Source Y coordinate. Destination X coordinate. Destination Y coordinate. The width of the region to modify, or -1 to use . The height of the region to reder or -1 to use Value below this will be painted as zero; all other values will be painted as one. This function is designed to threshold and render the alpha values from a rectangular of this into the destination which can then be used as a clipping mask for a . Method System.Void

Scale and Compose a Pixbuf

Scale transformation.

The destination Pixbuf where the results are rendered The left coordinate for region to render The top coordinate for region to render The width of the region to render The height of the region to render The offset in the X direction (currently rounded to an integer) The offset in the Y direction (currently rounded to an integer) The scale factor in the X direction The scale factor in the Y direction The interpolation type for the transformation. Creates a transformation of the Pixbuf by scaling to and then translating by and , then renders the rectangle (, , , ) of the resulting image onto the destination image replacing the previous contents. Try to use , this function is the industrial-strength power tool you can fall back to if is not powerful enough. Method System.Void

Copies a region from one Pixbuf to another

Source X coordinate within src_pixbuf. Source Y coordinate within src_pixbuf Width of the area to copy. Height of the area to copy. Destination Pixbuf. X coordinate within dest_pixbuf. Y coordinate within dest_pixbuf. Copies a rectangular area from src_pixbuf to dest_pixbuf. Conversion of pixbuf formats is done automatically. Method System.Void

Fills a pixbuf with a single color

RGBA value for the pixel to set (0xffffffff is opaque white, 0x00000000 transparent black) 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 does not have an alpha channel. Method System.String

Looks up an option in the Pixbuf

the key to lookup The value associated with the Looks up key in the list of options that may have been attached to the pixbuf when it was loaded. Method System.Void

Saturation and pixelation of a Pixbuf

Target Pixbuf where the resulting image is stored saturation factor whether to pixelation will take place Modifies saturation and optionally pixelates the Pixbuf, placing the result in . may be the same Pixbuf with no ill effects. If is 1.0 then saturation is not changed. If it's less than 1.0, saturation is reduced (the image is darkened); if greater than 1.0, saturation is increased (the image is brightened). If is , 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. Method System.Void

Obsolete; do not use. Use instead.

A A A A A A A A A A A A Renders a rectangular portion of a pixbuf to a drawable. The destination drawable must have a colormap. All windows have a colormap, however, pixmaps only have colormap by default if they were created with a non-NULL window argument. Otherwise a colormap must be set on them with . On older X servers, rendering pixbufs with an alpha channel involves round trips to the X server, and may be somewhat slow. Constructor

Internal constructor

Pointer to the C object. This is an internal constructor, and should not be used by user code. Constructor

Constructor

The colorspace () Whether the image should have transparency information. Number of bits per color sample. Width of image in pixels. Height of image in pixels. Creates a new 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. Constructor

Creates Pixbuf from image file.

Filename with the image Creates a new pixbuf by loading an image from a file. The file format is detected automatically (multiple formats are supported: JPG, PNG, TIFF, XPM, XBM). If the file is not found, a will be thrown. Constructor

Creates a sub-Pixbuf from an existing one.

The containing . X coord in src_pixbuf Y coord in src_pixbuf Width of region in src_pixbuf Height of region in src_pixbuf Creates a new pixbuf which represents a sub-region of . The new pixbuf shares its pixels with the original pixbuf, so writing to one affects both. The new pixbuf holds a reference to , so will not be finalized until the new pixbuf is finalized. Property System.Int32

Number of bits per color sample in a pixbuf.

The number of bits per color sample in the pixbuf None. GLib.Property("bits-per-sample") Property System.Int32

Height of the image

The height in pixels of the image See also the , and for more information about the layout of the image. GLib.Property("height") Property System.Boolean

Returns whether the Pixbuf contains an alpha channel

if the image contains an Alpha channel, otherwise. The Pixbuf object handles images in either the RGB format, or the RGBA format. The alpha channel value is a value between 0 and 255 and controls the opacity of a given pixel. GLib.Property("has-alpha") Property System.Int32

The width of the image

The width in pixels of the image This is the width of the image in pixels. See the property as well. GLib.Property("width") Property System.Int32

The number of channels on a Pixbuf

Returns the number of channels on a Pixbuf The possible values are 3 (for RGB encoding) and 4 (for RGB with an alpha transparency channel encoding). GLib.Property("n-channels") Property System.Int32

Rowstride of the Pixbuf

The rowstride property for the Pixbuf Queries the rowstride of a pixbuf. The rowstring is the number of bytes occupied by a row of pixels. Sometimes for alignment purposes, the rowstride might be bigger than the actual width of the image. Applications that manually process data from the image would scan lines by adding the value of the Rowstride. GLib.Property("rowstride") Property Gdk.Colorspace

The colorspace for this Pixbuf

The colorspace used by this Pixbuf Currently Pixbuf only support the RGB colorspace. GLib.Property("colorspace") Method Gdk.Pixbuf

Generates a new Pixbuf object from a .

A A A A A A A A A Constructor

Construct a pixbuf from a serialized structure.

The length in bytes of the data to be read. The raw data representing the serialized structure. If true, the "data" parameter will be copied and the copy will be used for the Pixbuf. If false, the data will be used as is and the Pixbuf will be dependent on it. None Method System.Int32

To be added

a Constructor

Constructor for images embedded in an assembly

The that contains the image. If the value is , the image will be looked up on the calling assembly. The name given as the resource in the assembly This method is used to construct a from an embedded resource in an assembly. Typically this is used when application developers want to distribute images in a single executable. If the assembly parameter is , the image will be looked up on the calling assembly. For example:


Gdk.Pixbuf p = new Pixbuf (null, "image.jpg");

Compile with:


mcs -resource:image.jpg sample.cs

Constructor

Constructor for images embedded in an assembly when a specific size is required.

The that contains the image. If the value is , the image will be looked up on the calling assembly. The name given as the resource in the assembly The required width for the pixbuf The required height for the pixbuf This method is used to construct a from an embedded resource in an assembly with a specific size. Typically this is used when application developers want to distribute images in a single executable. If the assembly parameter is , the image will be looked up on the calling assembly. For example:


Gdk.Pixbuf p = new Pixbuf (null, "image.jpg", 10, 10);

Compile with:


mcs -resource:image.jpg sample.cs

Method Gdk.Pixbuf

Loads a pixbuf from a resource file.

the name of the resource a This loads a pixbuf from a resource in the calling assembly. This is equivalent to using the constructor with a assembly. Constructor

Makes a new Pixbuf object from a .

a containing the image Useful for creating a Pixbuf from an image file that resides in a stream.


/* buffer containing an image */
System.Byte[] buffer = new System.Byte[256];

/* create a memory stream to the buffer */
System.IO.MemoryStream memorystream = new System.IO.MemoryStream(buffer);    

/* create a pixbuf from the stream as if it was a file */
Gdk.Pixbuf pb = new Gdk.Pixbuf(memorystream);

Constructor

Makes a new Pixbuf object from a with a given size.

a containing the image a specifying the required width a specifying the required height Useful for creating a Pixbuf with a specific size from an image file that resides in a stream.


/* buffer containing an image */
System.Byte[] buffer = new System.Byte[256];

/* create a memory stream to the buffer */
System.IO.MemoryStream memorystream = new System.IO.MemoryStream(buffer);    

/* create a pixbuf from the stream as if it was a file */
Gdk.Pixbuf pb = new Gdk.Pixbuf(memorystream, 10, 10);

Constructor

Makes a new Pixbuf object from a containing an encoded image.

a containing the image in one of the formats recognized by Pixbuf (png, tiff, jpeg, etc). Useful for creating a Pixbuf from an image file in memory.


/* buffer containing an image */
System.Byte[] buffer = new System.Byte[256];  

/* create a pixbuf from the buffer as if it was a file */
Gdk.Pixbuf pb = new Gdk.Pixbuf(buffer);

Constructor

Makes a new Pixbuf object from a with a given size.

a containing the image a specifying the required width a specifying the required height Useful for creating a Pixbuf with a specific size from an image file in memory.


/* buffer containing an image */
System.Byte[] buffer = new System.Byte[256];  

/* create a pixbuf from the buffer as if it was a file */
Gdk.Pixbuf pb = new Gdk.Pixbuf(buffer, 10, 10);

Constructor

Public constructor; creates a new from an in-memory RGB or RGBA buffer.

The data that contains the image in RGB or RGBA format. The for the image data. Whether the data contains an alpha channel (RGBA format). Currently only 8 is supported (1 byte per channel). Width of the image in pixels. Height of the image in pixels. The rowstride is the number of bytes consumed by a single row in the image. A routine to invoke when the reference count to this image reaches zero. The image must be in RGB format or RGBA format, where each channel takes one byte. For performance reasons sometimes images have some padding at the end of each row, this is done to ensure that access to the data is aligned. The argument is the size in bytes of each row. If no padding is added the is just: * (3 + ). Constructor

Construct a pixbuf from a serialized structure

The length in bytes of the data to be read. A serialized structure, generated with . If true, the "data" parameter will be copied and the copy will be used for the Pixbuf. If false, the data will be used as is and the Pixbuf will be dependent on it. None Constructor

Public constructor.

a Property GLib.GType

GType Property.

a Returns the native value for . Constructor

Internal constructor

a This is a constructor used by derivative types of that would have their own GLib.GType assigned to it. This is not typically used by C# code. System.Obsolete Property Gdk.PixbufFormat[]

To be added

a Property System.IntPtr

The pixels contained by this Pixbuf object.

a , pointer to the underlying C data Method System.Boolean

Saves pixbuf to a file.

Name of the file where the image will be saved The file type to save (one of "ani", "bmp", "gif", "ico", "jpeg", "pcx", "png", "pnm", "ras", "tga", "tiff" "wbmp", "xpm" or "xbm") Options that are passed to the save module. Values for each key A Method System.Boolean

Saves pixbuf to a file.

a , name of the file to save a , file format to save in ("jpeg" and "png" are supported). a The Gtk+ version of this call supports a text string of arguments, which Gtk# currently does not include. (TODO: explain the difference between Save and Savev, in light of this API difference.) Method Gdk.PixbufFormat

To be added

a a a a To be added Method System.Void

To be added

To be added Method Gdk.Pixbuf

To be added

a To be added Method System.Void

Creates pixmap and mask bitmaps for a given alpha threshold.

a a a , threshold value for opacity. This is merely a convenience function; applications that need to render pixbufs with dither offsets or to given drawables should use or and . The pixmap that is created is created for the colormap returned by . You normally will want to instead use the actual colormap for a widget, and use , If the pixbuf does not have an alpha channel, then will be set to . Method System.Void

Creates pixmap and mask bitmaps for a given alpha threshold using a specified colormap.

a a a a , threshold value for opacity. This is merely a convenience function; applications that need to render pixbufs with dither offsets or to given drawables should use or and . The pixmap that is created uses the specified by . This colormap must match the colormap of the window where the pixmap will eventually be used or an error will result. If the pixbuf does not have an alpha channel, then will be set to . Constructor

To be added

a a a To be added Method System.Byte[]

Saves to a buffer.

an image type, such as png, jpeg, or ico an array of option keys. an array of option values. a >The and should contain key/value pairs. See for more details. Throws a if the save is not successful. Method System.Byte[]

Saves to a buffer.

an image type, such as png, jpeg, or ico a Throws a if the save is not successful. Method System.Void

Save using a callback delegate.

a an image type, such as png, jpeg, or ico Throws a if the save is not successful. Method System.Void

Save using a callback delegate.

a an image type, such as png, jpeg, or ico an array of option keys an array of option values The and should contain key/value pairs. See for more details. Throws a if the save is not successful. Method Gdk.Pixbuf

Creates a new Pixbuf object from a .

a a a a a a a a a Method Gdk.Pixbuf

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

The angle to rotate by. A . Method Gdk.Pixbuf

Flips a pixbuf horizontally or vertically.

to flip horizontally, to flip vertically. A . Constructor

To be added

a a a a To be added Constructor To be added. To be added. To be added. To be added. To be added. To be added. To be added.

To be added.

To be added. Constructor To be added. To be added.

Constructor for pixbufs that that have embedded images created with the gdk-pixbuf-source program.

This is used to create pixbufs from images that have been embedded using the gdk-pixbuf-csource command line tool. Method System.Object

To be added.

To be added. To be added. Method Gdk.Pixbuf

Applies an embedded orientation transform.

Returns a new pixbuf, or the existing one if no transform exists. Constructor The data that contains the image in RGB or RGBA format. The for the image data. Whether the data contains an alpha channel (RGBA format). Currently only 8 is supported (1 byte per channel). Width of the image in pixels. Height of the image in pixels. The rowstride is the number of bytes consumed by a single row in the image.

Public constructor.

The image must be in RGB format or RGBA format, where each channel takes one byte. Constructor The data that contains the image in RGB or RGBA format. Whether the data contains an alpha channel (RGBA format). Currently only 8 is supported (1 byte per channel). Width of the image in pixels. Height of the image in pixels. The rowstride is the number of bytes consumed by a single row in the image.

Public constructor.

The image must be in RGB format or RGBA format, where each channel takes one byte.