2003-02-12 02:57:20 +01:00
<Type Name= "Pixbuf" FullName= "Gdk.Pixbuf" >
2005-05-23 22:41:51 +02:00
<TypeSignature Language= "C#" Maintainer= "miguel" Value= "public class Pixbuf : GLib.Object" />
2003-02-12 02:57:20 +01:00
<AssemblyInfo >
<AssemblyName > gdk-sharp</AssemblyName>
2003-12-04 22:09:30 +01:00
<AssemblyPublicKey >
</AssemblyPublicKey>
2005-12-10 00:12:49 +01:00
<AssemblyVersion > 2.8.0.0</AssemblyVersion>
2003-02-12 02:57:20 +01:00
</AssemblyInfo>
2003-02-23 08:26:30 +01:00
<ThreadSafetyStatement > Gtk# is thread aware, but not thread safe; See the <link location= "node:gtk-sharp/programming/threads" > Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
2003-02-12 02:57:20 +01:00
<Docs >
2003-04-24 00:38:12 +02:00
<summary > In memory image handling and representation.</summary>
2003-02-18 02:33:14 +01:00
<remarks >
2003-02-20 04:56:51 +01:00
<para >
2004-06-25 17:55:40 +02:00
The <see cref= "T:Gdk.Pixbuf" /> class is used to represent an image in
2003-02-20 04:56:51 +01:00
memory. The in-memory representation uses either a three
byte RGB representation or a four byte RGBA representation.
</para>
<para >
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.
</para>
<para >
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.
</para>
<para >
Pixbufs can also be saved to a number of different file
formats.
</para>
2005-09-29 20:47:42 +02:00
<para > An example that composites two images next to each other.
<example >
<code lang= "C#" >
// 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);
}
}
</code>
</example> </para>
2003-02-18 02:33:14 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
<Base >
<BaseTypeName > GLib.Object</BaseTypeName>
</Base>
<Interfaces >
</Interfaces>
<Members >
<Member MemberName= "FromPixdata" >
<MemberSignature Language= "C#" Value= "public static Gdk.Pixbuf FromPixdata (Gdk.Pixdata pixdata, bool copy_pixels);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "pixdata" Type= "Gdk.Pixdata" />
<Parameter Name= "copy_pixels" Type= "System.Boolean" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary >
Creates a Pixbuf from a Pixdata
</summary>
<param name= "pixdata" > Source Gdk.Pixdata</param>
<param name= "copy_pixels" > Whether to make a private copy of the data</param>
<returns >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
The return value is an initialized Pixbuf class
</para>
2003-02-23 08:26:30 +01:00
</returns>
2003-02-20 04:56:51 +01:00
<remarks >
This creates a Pixbuf from a class that implements the
Gdk.Pixdata interface.
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "AddAlpha" >
<MemberSignature Language= "C#" Value= "public Gdk.Pixbuf AddAlpha (bool substitute_color, byte r, byte g, byte b);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "substitute_color" Type= "System.Boolean" />
<Parameter Name= "r" Type= "System.Byte" />
<Parameter Name= "g" Type= "System.Byte" />
<Parameter Name= "b" Type= "System.Byte" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Adds an alpha channel to the Pixbuf</summary>
<param name= "substitute_color" > Whether to set a color to zero
2003-02-23 08:26:30 +01:00
opacity. If this is <see langword= "false" /> , then the (r, g, b) arguments will be ignored.</param>
2003-02-18 02:33:14 +01:00
<param name= "r" > Red value to substitute</param>
<param name= "g" > Green value to substitute</param>
<param name= "b" > Blue value to substitute</param>
2003-02-23 08:26:30 +01:00
<returns >
<para > A new pixbuf with an alpha channel.</para>
</returns>
2003-02-18 02:33:14 +01:00
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
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).
</para>
2003-02-23 08:26:30 +01:00
<para >
If <paramref name= "substitute_color" /> is <see langword= "true" /> , then the color specified by (<paramref name= "r" /> , <paramref name= "g" /> , <paramref name= "b" /> )
2003-02-18 02:33:14 +01:00
will be assigned zero opacity. That is, if you pass (255,
255, 255) for the substitute color, all white pixels will
become fully transparent.
</para>
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
The original image is not modified, a copy of the image is
made and returned.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "CompositeColorSimple" >
<MemberSignature Language= "C#" Value= "public Gdk.Pixbuf CompositeColorSimple (int dest_width, int dest_height, Gdk.InterpType interp_type, int overall_alpha, int check_size, uint color1, uint color2);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "dest_width" Type= "System.Int32" />
<Parameter Name= "dest_height" Type= "System.Int32" />
<Parameter Name= "interp_type" Type= "Gdk.InterpType" />
<Parameter Name= "overall_alpha" Type= "System.Int32" />
<Parameter Name= "check_size" Type= "System.Int32" />
<Parameter Name= "color1" Type= "System.UInt32" />
<Parameter Name= "color2" Type= "System.UInt32" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Scaling with checkboard rendering</summary>
<param name= "dest_width" > The width of destination image</param>
<param name= "dest_height" > The height of destination image</param>
<param name= "interp_type" > The interpolation type for the transformation.</param>
<param name= "overall_alpha" > Overall alpha for source image (0..255)</param>
<param name= "check_size" > The size of checks in the checkboard (must be a power of two)</param>
<param name= "color1" > The color of check at upper left</param>
<param name= "color2" > The color of the other check</param>
<returns >
2003-02-23 08:26:30 +01:00
<para >
The new Pixbuf, or <see langword= "null" /> if not enough
2003-02-18 02:33:14 +01:00
memory could be allocated for it.
</para>
2003-02-23 08:26:30 +01:00
</returns>
2003-02-18 02:33:14 +01:00
<remarks >
2003-02-23 08:26:30 +01:00
<para >
Creates a new Pixbuf by scaling <paramref name= "src" /> to
<paramref name= "dest_width" /> x
<paramref name= "dest_height" /> and compositing the result with a checkboard
of colors <paramref name= "color1" /> and <paramref name= "color2" /> .
2003-02-18 02:33:14 +01:00
</para>
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
The colors must be in RGB format.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "ScaleSimple" >
<MemberSignature Language= "C#" Value= "public Gdk.Pixbuf ScaleSimple (int dest_width, int dest_height, Gdk.InterpType interp_type);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "dest_width" Type= "System.Int32" />
<Parameter Name= "dest_height" Type= "System.Int32" />
<Parameter Name= "interp_type" Type= "Gdk.InterpType" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Scales a Pixbuf</summary>
<param name= "dest_width" > The width of destination image</param>
<param name= "dest_height" > The height of destination image</param>
<param name= "interp_type" > The interpolation type for the transformation</param>
<returns >
2003-02-23 08:26:30 +01:00
<para >
A new Pixbuf object, or <see langword= "null" /> if no
2003-02-18 02:33:14 +01:00
memory is available for the transformation.
</para>
2003-02-23 08:26:30 +01:00
</returns>
2003-02-18 02:33:14 +01:00
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
Create a new GdkPixbuf containing a copy of src scaled to
2003-02-23 08:26:30 +01:00
<paramref name= "dest_width" /> x <paramref name= "dest_height" /> . It leaves the current Pixbuf
unaffected. <paramref name= "interp_type" /> should be <see cref= "F:Gdk.InterpType.Nearest" /> if you want maximum
speed (but when scaling down <see cref= "F:Gdk.InterpType.Nearest" /> is usually unusably
ugly). The default <paramref name= "interp_type" /> should
be <see cref= "F:Gdk.InterpType.Bilinear" /> which offers
2003-02-18 02:33:14 +01:00
reasonable quality and speed.
</para>
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
You can scale a sub-portion of the Pixbuf by creating a
sub-pixbuf using a Pixbuf constructor.
</para>
2003-02-23 08:26:30 +01:00
<para >
For more complicated scale/compositions see <see cref= "M:Gdk.Pixbuf.Scale" /> and <see cref= "M:Gdk.Pixbuf.Composite" /> </para>
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "CompositeColor" >
<MemberSignature Language= "C#" Value= "public void CompositeColor (Gdk.Pixbuf dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, Gdk.InterpType interp_type, int overall_alpha, int check_x, int check_y, int check_size, uint color1, uint color2);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "dest" Type= "Gdk.Pixbuf" />
<Parameter Name= "dest_x" Type= "System.Int32" />
<Parameter Name= "dest_y" Type= "System.Int32" />
<Parameter Name= "dest_width" Type= "System.Int32" />
<Parameter Name= "dest_height" Type= "System.Int32" />
<Parameter Name= "offset_x" Type= "System.Double" />
<Parameter Name= "offset_y" Type= "System.Double" />
<Parameter Name= "scale_x" Type= "System.Double" />
<Parameter Name= "scale_y" Type= "System.Double" />
<Parameter Name= "interp_type" Type= "Gdk.InterpType" />
<Parameter Name= "overall_alpha" Type= "System.Int32" />
<Parameter Name= "check_x" Type= "System.Int32" />
<Parameter Name= "check_y" Type= "System.Int32" />
<Parameter Name= "check_size" Type= "System.Int32" />
<Parameter Name= "color1" Type= "System.UInt32" />
<Parameter Name= "color2" Type= "System.UInt32" />
</Parameters>
2003-02-19 06:58:40 +01:00
<Docs >
<summary > Scale and Compose a Pixbuf with control over the checks</summary>
<param name= "dest" > The destination Pixbuf to render to.</param>
<param name= "dest_x" > The left coordinate for region to render</param>
<param name= "dest_y" > The top coordinate for region to render</param>
<param name= "dest_width" > The width of the region to render</param>
<param name= "dest_height" > The height of the region to render</param>
<param name= "offset_x" > The offset in the X direction (currently rounded to an integer)</param>
<param name= "offset_y" > The offset in the Y direction (currently rounded to an integer)</param>
<param name= "scale_x" > The scale factor in the X direction</param>
<param name= "scale_y" > The scale factor in the Y direction</param>
<param name= "interp_type" > The interpolation type for the transformation.</param>
<param name= "overall_alpha" > Overall alpha for source image (0..255)</param>
<param name= "check_x" > The X offset for the checkboard (origin of checkboard is at -check_x, -check_y)</param>
<param name= "check_y" > The Y offset for the checkboard</param>
<param name= "check_size" > The size of checks in the checkboard (must be a power of two)</param>
<param name= "color1" > The color of check at upper left</param>
<param name= "color2" > The color of the other check</param>
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-19 06:58:40 +01:00
Creates a transformation of the Pixbuf by scaling by
2003-02-23 08:26:30 +01:00
<paramref name= "scale_x" /> and <paramref name= "scale_y" />
then translating by <paramref name= "offset_x" /> and
<paramref name= "offset_y" /> , then composites the rectangle
(<paramref name= "dest_x" /> ,<paramref name= "dest_y" /> ,
<paramref name= "dest_width" /> , <paramref name= "dest_height" /> ) of the resulting image with a
checkboard of the colors <paramref name= "color1" /> and
<paramref name= "color2" /> and renders it onto the
2003-02-19 06:58:40 +01:00
destination image.
</para>
2003-02-23 08:26:30 +01:00
<para >
The <paramref name= "color1" /> and <paramref name= "color2" /> encode the color in 32-bit RGB format.
2003-02-19 06:58:40 +01:00
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-19 06:58:40 +01:00
</Docs>
</Member>
2003-02-12 02:57:20 +01:00
<Member MemberName= "GetFromImage" >
<MemberSignature Language= "C#" Value= "public Gdk.Pixbuf GetFromImage (Gdk.Image src, Gdk.Colormap cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "src" Type= "Gdk.Image" />
<Parameter Name= "cmap" Type= "Gdk.Colormap" />
<Parameter Name= "src_x" Type= "System.Int32" />
<Parameter Name= "src_y" Type= "System.Int32" />
<Parameter Name= "dest_x" Type= "System.Int32" />
<Parameter Name= "dest_y" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2006-03-02 02:40:08 +01:00
<param name= "src" > Source <see cref= "T:Gdk.Image" /> .</param>
2003-02-23 08:26:30 +01:00
<param name= "cmap" > A colormap (if src does not have one set) (A <see cref= "T:Gdk.Colormap" /> </param>
2003-02-18 02:33:14 +01:00
<param name= "src_x" > Source X coordinate within drawable.</param>
<param name= "src_y" > Source Y coordinate within drawable.</param>
<param name= "dest_x" > Destination X coordinate in pixbuf, or 0
2003-02-23 08:26:30 +01:00
if dest is <see langword= "null" /> .</param>
2003-02-18 02:33:14 +01:00
<param name= "dest_y" > Destination Y coordinate in pixbuf, or 0
2003-02-23 08:26:30 +01:00
if dest is <see langword= "null" /> .</param>
2003-02-18 02:33:14 +01:00
<param name= "width" > Width in pixels of region to get.</param>
<param name= "height" > Height in pixels of region to get.</param>
2005-05-23 22:41:51 +02:00
<summary > Gets an image from a Gdk.Image</summary>
2003-02-18 02:33:14 +01:00
<returns >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
The value of the Pixbuf (the same one that was passed) or
2003-02-23 08:26:30 +01:00
<see langword= "null" /> on error. See the remarks below
2003-02-18 02:33:14 +01:00
for details on the possible ways on which this function
might fail.
</para>
2003-03-26 01:38:24 +01:00
</returns>
2003-02-18 02:33:14 +01:00
<remarks >
2003-02-23 08:26:30 +01:00
<para >
Transfers image data from a <see cref= "T:Gdk.Image" /> and
converts it to an RGB(A) representation inside a <see cref= "T:Gdk.Pixbuf" /> . In other words, copies image data
2003-02-18 02:33:14 +01:00
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.
</para>
2003-02-23 08:26:30 +01:00
<para >
If the <paramref name= "image" /> has no colormap (<see cref= "P:Gdk.Image.Colormap" /> returns <see langword= "null" /> ), then a suitable colormap must be
specified. Typically a <see cref= "T:Gdk.Window" /> or a
pixmap created by passing a <see cref= "T:Gdk.Window" /> to
the <see cref= "T:Gdk.Pixmap" /> constructor will already
have a colormap associated with it. If the <paramref name= "image" /> has a colormap, the <paramref name= "cmap" /> argument will be ignored. If the <paramref name= "image" /> is a bitmap (1 bit per pixel pixmap),
2003-02-18 02:33:14 +01:00
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
2003-02-23 08:26:30 +01:00
assumed to be black. For taking screenshots, the <see cref= "P:Gdk.Colormap.System" /> property returns the
2003-02-18 02:33:14 +01:00
correct colormap to use.
</para>
2003-02-23 08:26:30 +01:00
<para >
If the specified destination pixbuf <paramref name= "dest" /> is <see langword= "null" /> , then this
2003-02-18 02:33:14 +01:00
function will create an RGB Pixbuf with 8 bits per channel
and no alpha, with the same size specified by the width
2003-02-23 08:26:30 +01:00
and height arguments. In this case, the <paramref name= "dest_x" /> and <paramref name= "dest_y" /> arguments
2003-02-18 02:33:14 +01:00
must be specified as 0. If the specified destination
2003-02-23 08:26:30 +01:00
pixbuf is not <see langword= "null" /> and it contains alpha
2003-02-18 02:33:14 +01:00
information, then the filled pixels will be set to full
opacity (alpha = 255).
</para>
2003-02-23 08:26:30 +01:00
<para >
If the specified <paramref name= "image" /> is a pixmap,
2003-02-18 02:33:14 +01:00
then the requested source rectangle must be completely
contained within the pixmap, otherwise the function will
2003-02-23 08:26:30 +01:00
return <see langword= "null" /> . For pixmaps only (not for
windows) passing -1 for <paramref name= "width" /> or
<paramref name= "height" /> is allowed, to mean the full
2003-02-18 02:33:14 +01:00
width or height of the pixmap.
</para>
2003-02-23 08:26:30 +01:00
<para >
If the specified <paramref name= "image" /> is a window,
2003-02-18 02:33:14 +01:00
and the window is off the screen, then there is no image
data in the obscured/offscreen regions to be placed in the
2003-02-23 08:26:30 +01:00
pixbuf. The contents of portions of the <see cref= "T:Gdk.Pixbuf" /> corresponding to the offscreen
2003-02-18 02:33:14 +01:00
region are undefined.
</para>
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
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.
</para>
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
If the target image is not mapped (typically because
it's iconified/minimized or not on the current workspace),
2003-02-23 08:26:30 +01:00
then <see langword= "null" /> will be returned.
2003-02-18 02:33:14 +01:00
</para>
2003-02-23 08:26:30 +01:00
<para >
If memory can't be allocated for the return value, <see langword= "null" /> will be returned instead.
2003-02-18 02:33:14 +01:00
</para>
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
(In short, there are several ways this function can fail,
2003-02-23 08:26:30 +01:00
and if it fails it returns <see langword= "null" /> ; so
2003-02-18 02:33:14 +01:00
check the return value.)
</para>
2003-03-26 01:38:24 +01:00
</remarks>
</Docs>
2003-02-12 02:57:20 +01:00
</Member>
<Member MemberName= "RenderToDrawable" >
<MemberSignature Language= "C#" Value= "public void RenderToDrawable (Gdk.Drawable drawable, Gdk.GC gc, int src_x, int src_y, int dest_x, int dest_y, int width, int height, Gdk.RgbDither dither, int x_dither, int y_dither);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "drawable" Type= "Gdk.Drawable" />
<Parameter Name= "gc" Type= "Gdk.GC" />
<Parameter Name= "src_x" Type= "System.Int32" />
<Parameter Name= "src_y" Type= "System.Int32" />
<Parameter Name= "dest_x" Type= "System.Int32" />
<Parameter Name= "dest_y" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
<Parameter Name= "dither" Type= "Gdk.RgbDither" />
<Parameter Name= "x_dither" Type= "System.Int32" />
<Parameter Name= "y_dither" Type= "System.Int32" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Renders the image into a Drawable</summary>
<param name= "drawable" > Destination drawable.</param>
<param name= "gc" > GC used for rendering.</param>
<param name= "src_x" > Source X coordinate within pixbuf.</param>
<param name= "src_y" > Source Y coordinate within pixbuf.</param>
<param name= "dest_x" > Destination X coordinate within drawable.</param>
<param name= "dest_y" > Destination Y coordinate within drawable.</param>
<param name= "width" > Width of region to render, in pixels, or -1 to use pixbuf width</param>
<param name= "height" > Height of region to render, in pixels, or -1 to use pixbuf height</param>
<param name= "dither" > Dithering mode for GdkRGB.</param>
<param name= "x_dither" > X offset for dither.</param>
<param name= "y_dither" > Y offset for dither.</param>
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
Renders a rectangular portion of the Pixbuf into the
2003-02-23 08:26:30 +01:00
<paramref name= "drawable" /> while using the specified
<paramref name= "gc" /> . This is done using GdkRGB, so the
specified drawable must have the <see cref= "T:Gdk.RGB" />
2003-02-18 02:33:14 +01:00
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.
</para>
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
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.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "GetFromDrawable" >
<MemberSignature Language= "C#" Value= "public Gdk.Pixbuf GetFromDrawable (Gdk.Drawable src, Gdk.Colormap cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters >
2005-05-23 22:41:51 +02:00
<Parameter Name= "src" Type= "Gdk.Drawable" />
2003-09-17 23:56:59 +02:00
<Parameter Name= "cmap" Type= "Gdk.Colormap" />
<Parameter Name= "src_x" Type= "System.Int32" />
<Parameter Name= "src_y" Type= "System.Int32" />
<Parameter Name= "dest_x" Type= "System.Int32" />
<Parameter Name= "dest_y" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2006-03-02 02:40:08 +01:00
<param name= "src" > Destination pixbuf, or <see langword= "null" /> if a new pixbuf should be created..</param>
2003-02-23 08:26:30 +01:00
<param name= "cmap" > A colormap (if src does not have one set) (A <see cref= "T:Gdk.Colormap" /> </param>
2003-02-18 02:33:14 +01:00
<param name= "src_x" > Source X coordinate within drawable.</param>
<param name= "src_y" > Source Y coordinate within drawable.</param>
<param name= "dest_x" > Destination X coordinate in pixbuf, or 0
2003-02-23 08:26:30 +01:00
if dest is <see langword= "null" /> .</param>
2003-02-18 02:33:14 +01:00
<param name= "dest_y" > Destination Y coordinate in pixbuf, or 0
2003-02-23 08:26:30 +01:00
if dest is <see langword= "null" /> .</param>
2003-02-18 02:33:14 +01:00
<param name= "width" > Width in pixels of region to get.</param>
<param name= "height" > Height in pixels of region to get.</param>
2005-05-23 22:41:51 +02:00
<summary > Gets image from a Gdk.Drawable</summary>
2003-02-18 02:33:14 +01:00
<returns >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
The value of the Pixbuf (the same one that was passed) or
2003-02-23 08:26:30 +01:00
<see langword= "null" /> on error. See the remarks below
2003-02-18 02:33:14 +01:00
for details on the possible ways on which this function
might fail.
</para>
2003-02-23 08:26:30 +01:00
</returns>
2003-02-18 02:33:14 +01:00
<remarks >
2003-02-23 08:26:30 +01:00
<para >
Transfers image data from a <see cref= "T:Gdk.Drawable" />
and converts it to an RGB(A) representation inside a <see cref= "T:Gdk.Pixbuf" /> . In other words, copies image data
2003-02-18 02:33:14 +01:00
from a server-side drawable to a client-side RGB(A)
buffer. This allows you to efficiently read individual
pixels on the client side.
</para>
2003-02-23 08:26:30 +01:00
<para >
If the <paramref name= "drawable" /> has no colormap (<see cref= "P:Gdk.Drawable.Colormap" /> returns <see langword= "null" /> ), then a suitable colormap must be
specified. Typically a <see cref= "T:Gdk.Window" /> or a
pixmap created by passing a <see cref= "T:Gdk.Window" /> to
the <see cref= "T:Gdk.Pixmap" /> constructor will already
have a colormap associated with it. If the <paramref name= "drawable" /> has a colormap, the <paramref name= "cmap" /> argument will be ignored. If the <paramref name= "drawable" /> is a bitmap (1 bit per pixel pixmap),
2003-02-18 02:33:14 +01:00
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
2003-02-23 08:26:30 +01:00
assumed to be black. For taking screenshots, the <see cref= "P:Gdk.Colormap.System" /> property returns the
2003-02-18 02:33:14 +01:00
correct colormap to use.
</para>
2003-02-23 08:26:30 +01:00
<para >
If the specified destination pixbuf <paramref name= "dest" /> is <see langword= "null" /> , then this
2003-02-18 02:33:14 +01:00
function will create an RGB Pixbuf with 8 bits per channel
and no alpha, with the same size specified by the width
2003-02-23 08:26:30 +01:00
and height arguments. In this case, the <paramref name= "dest_x" /> and <paramref name= "dest_y" /> arguments
2003-02-18 02:33:14 +01:00
must be specified as 0. If the specified destination
2003-02-23 08:26:30 +01:00
pixbuf is not <see langword= "null" /> and it contains alpha
2003-02-18 02:33:14 +01:00
information, then the filled pixels will be set to full
opacity (alpha = 255).
</para>
2003-02-23 08:26:30 +01:00
<para >
If the specified <paramref name= "drawable" /> is a pixmap,
2003-02-18 02:33:14 +01:00
then the requested source rectangle must be completely
contained within the pixmap, otherwise the function will
2003-02-23 08:26:30 +01:00
return <see langword= "null" /> . For pixmaps only (not for
windows) passing -1 for <paramref name= "width" /> or
<paramref name= "height" /> is allowed, to mean the full
2003-02-18 02:33:14 +01:00
width or height of the pixmap.
</para>
2003-02-23 08:26:30 +01:00
<para >
If the specified <paramref name= "drawable" /> is a window,
2003-02-18 02:33:14 +01:00
and the window is off the screen, then there is no image
data in the obscured/offscreen regions to be placed in the
2003-02-23 08:26:30 +01:00
pixbuf. The contents of portions of the <see cref= "T:Gdk.Pixbuf" /> corresponding to the offscreen
2003-02-18 02:33:14 +01:00
region are undefined.
</para>
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
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.
</para>
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
If the target drawable is not mapped (typically because
it's iconified/minimized or not on the current workspace),
2003-02-23 08:26:30 +01:00
then <see langword= "null" /> will be returned.
2003-02-18 02:33:14 +01:00
</para>
2003-02-23 08:26:30 +01:00
<para >
If memory can't be allocated for the return value, <see langword= "null" /> will be returned instead.
2003-02-18 02:33:14 +01:00
</para>
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
(In short, there are several ways this function can fail,
2003-02-23 08:26:30 +01:00
and if it fails it returns <see langword= "null" /> ; so
2003-02-18 02:33:14 +01:00
check the return value.)
</para>
2003-02-23 08:26:30 +01:00
<para >
This function calls <see cref= "M:Gdk.Drawable.GetImage(int,int,int,int)" />
internally and converts the resulting image to a <see cref= "T:Gdk.Pixbuf" /> , so the documentation for <see cref= "M:Gdk.Drawable.GetImage(int,int,int,int)" /> is also
2003-02-18 02:33:14 +01:00
relevant.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "Copy" >
<MemberSignature Language= "C#" Value= "public Gdk.Pixbuf Copy ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Copies the Pixbuf</summary>
<returns >
2003-02-23 08:26:30 +01:00
<para >
A copy of the data in the Pixbuf, or <see langword= "null" /> on failure
2003-02-18 02:33:14 +01:00
</para>
2003-02-23 08:26:30 +01:00
</returns>
<remarks />
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "RenderThresholdAlpha" >
2004-12-03 21:42:12 +01:00
<MemberSignature Language= "C#" Value= "public void RenderThresholdAlpha (Gdk.Pixmap bitmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height, int alpha_threshold);" />
2003-02-12 02:57:20 +01:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2004-12-03 21:42:12 +01:00
<Parameter Name= "bitmap" Type= "Gdk.Pixmap" />
2003-09-17 23:56:59 +02:00
<Parameter Name= "src_x" Type= "System.Int32" />
<Parameter Name= "src_y" Type= "System.Int32" />
<Parameter Name= "dest_x" Type= "System.Int32" />
<Parameter Name= "dest_y" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
<Parameter Name= "alpha_threshold" Type= "System.Int32" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2004-12-03 21:42:12 +01:00
<summary > Render pixbuf alpha channel as a bi-level clip mask to a <see cref= "T:Gdk.Pixmap" /> </summary>
<param name= "bitmap" > The destination, a 1-bit-depth <see cref= "T:Gdk.Pixmap" /> .</param>
2004-06-25 17:55:40 +02:00
<param name= "src_x" > Source X coordinate.</param>
<param name= "src_y" > Source Y coordinate.</param>
2004-12-03 21:42:12 +01:00
<param name= "dest_x" > Destination X coordinate.</param>
2004-06-25 17:55:40 +02:00
<param name= "dest_y" > Destination Y coordinate.</param>
<param name= "width" > The width of the region to modify, or -1 to use <see cref= "P:Gdk.Pixbuf.Width" /> .</param>
<param name= "height" > The height of the region to reder or -1 to use <see cref= "P:Gdk.Pixbuf.Height" /> </param>
<param name= "alpha_threshold" > Value below this will be painted as zero; all other values will be painted as one.</param>
<remarks > This function is designed to threshold and render the alpha values from a rectangular of this <see cref= "T:Gdk.Pixbuf" /> into the destination <see cref= "T:Gdk.Bitmask" /> which can then be used as a clipping mask for a <see cref= "T:Gdk.Drawable" /> .</remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "Composite" >
<MemberSignature Language= "C#" Value= "public void Composite (Gdk.Pixbuf dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, Gdk.InterpType interp_type, int overall_alpha);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "dest" Type= "Gdk.Pixbuf" />
<Parameter Name= "dest_x" Type= "System.Int32" />
<Parameter Name= "dest_y" Type= "System.Int32" />
<Parameter Name= "dest_width" Type= "System.Int32" />
<Parameter Name= "dest_height" Type= "System.Int32" />
<Parameter Name= "offset_x" Type= "System.Double" />
<Parameter Name= "offset_y" Type= "System.Double" />
<Parameter Name= "scale_x" Type= "System.Double" />
<Parameter Name= "scale_y" Type= "System.Double" />
<Parameter Name= "interp_type" Type= "Gdk.InterpType" />
<Parameter Name= "overall_alpha" Type= "System.Int32" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Scale and Compose a Pixbuf</summary>
<param name= "dest" > The destination Pixbuf to render to.</param>
<param name= "dest_x" > The left coordinate for region to render</param>
<param name= "dest_y" > The top coordinate for region to render</param>
<param name= "dest_width" > The width of the region to render</param>
<param name= "dest_height" > The height of the region to render</param>
<param name= "offset_x" > The offset in the X direction (currently rounded to an integer)</param>
<param name= "offset_y" > The offset in the Y direction (currently rounded to an integer)</param>
<param name= "scale_x" > The scale factor in the X direction</param>
<param name= "scale_y" > The scale factor in the Y direction</param>
<param name= "interp_type" > The interpolation type for the transformation.</param>
<param name= "overall_alpha" > Overall alpha for source image (0..255)</param>
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
Creates a transformation of the Pixbuf by scaling by
2003-02-23 08:26:30 +01:00
<paramref name= "scale_x" /> and <paramref name= "scale_y" />
then translating by <paramref name= "offset_x" /> and
<paramref name= "offset_y" /> , then composites the rectangle
(<paramref name= "dest_x" /> , <paramref name= "dest_y" /> ,
<paramref name= "dest_width" /> , <paramref name= "dest_height" /> ) of the resulting image onto the
2003-02-18 02:33:14 +01:00
destination image.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "Scale" >
<MemberSignature Language= "C#" Value= "public void Scale (Gdk.Pixbuf dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, Gdk.InterpType interp_type);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "dest" Type= "Gdk.Pixbuf" />
<Parameter Name= "dest_x" Type= "System.Int32" />
<Parameter Name= "dest_y" Type= "System.Int32" />
<Parameter Name= "dest_width" Type= "System.Int32" />
<Parameter Name= "dest_height" Type= "System.Int32" />
<Parameter Name= "offset_x" Type= "System.Double" />
<Parameter Name= "offset_y" Type= "System.Double" />
<Parameter Name= "scale_x" Type= "System.Double" />
<Parameter Name= "scale_y" Type= "System.Double" />
<Parameter Name= "interp_type" Type= "Gdk.InterpType" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Scale transformation.</summary>
<param name= "dest" > The destination Pixbuf where the results
are rendered</param>
<param name= "dest_x" > The left coordinate for region to render</param>
<param name= "dest_y" > The top coordinate for region to render</param>
<param name= "dest_width" > The width of the region to render</param>
<param name= "dest_height" > The height of the region to render</param>
<param name= "offset_x" > The offset in the X direction (currently rounded to an integer)</param>
<param name= "offset_y" > The offset in the Y direction (currently rounded to an integer)</param>
<param name= "scale_x" > The scale factor in the X direction</param>
<param name= "scale_y" > The scale factor in the Y direction</param>
<param name= "interp_type" > The interpolation type for the transformation.</param>
2003-02-23 08:26:30 +01:00
<remarks >
<para >
2003-02-18 02:33:14 +01:00
Creates a transformation of the Pixbuf by scaling to
2003-02-23 08:26:30 +01:00
<paramref name= "scale_x" /> and <paramref name= "scale_y" />
then translating by <paramref name= "offset_x" /> and
<paramref name= "offset_y" /> , then renders the rectangle
(<paramref name= "dest_x" /> , <paramref name= "dest_y" /> ,
<paramref name= "dest_width" /> , <paramref name= "dest_height" /> ) of the resulting image onto the
2003-02-18 02:33:14 +01:00
destination image replacing the previous contents.
</para>
2003-02-23 08:26:30 +01:00
<para >
Try to use <see cref= "M:Gdk.Pixbuf.ScaleSimple" /> , this
2003-02-18 02:33:14 +01:00
function is the industrial-strength power tool you can
2003-02-23 08:26:30 +01:00
fall back to if <see cref= "M:Gdk.Pixbuf.ScaleSimple" /> is
2003-02-18 02:33:14 +01:00
not powerful enough.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "CopyArea" >
<MemberSignature Language= "C#" Value= "public void CopyArea (int src_x, int src_y, int width, int height, Gdk.Pixbuf dest_pixbuf, int dest_x, int dest_y);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "src_x" Type= "System.Int32" />
<Parameter Name= "src_y" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
<Parameter Name= "dest_pixbuf" Type= "Gdk.Pixbuf" />
<Parameter Name= "dest_x" Type= "System.Int32" />
<Parameter Name= "dest_y" Type= "System.Int32" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Copies a region from one Pixbuf to another</summary>
<param name= "src_x" > Source X coordinate within src_pixbuf.</param>
<param name= "src_y" > Source Y coordinate within src_pixbuf</param>
<param name= "width" > Width of the area to copy.</param>
<param name= "height" > Height of the area to copy.</param>
<param name= "dest_pixbuf" > Destination Pixbuf.</param>
<param name= "dest_x" > X coordinate within dest_pixbuf.</param>
<param name= "dest_y" > Y coordinate within dest_pixbuf.</param>
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
Copies a rectangular area from src_pixbuf to
dest_pixbuf. Conversion of pixbuf formats is done
automatically.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "Fill" >
<MemberSignature Language= "C#" Value= "public void Fill (uint pixel);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "pixel" Type= "System.UInt32" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary >
Fills a pixbuf with a single color
</summary>
<param name= "pixel" > RGBA value for the pixel to set (0xffffffff is opaque white, 0x00000000 transparent black)</param>
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
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.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "GetOption" >
<MemberSignature Language= "C#" Value= "public string GetOption (string key);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.String</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "key" Type= "System.String" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Looks up an option in the Pixbuf</summary>
<param name= "key" > the key to lookup</param>
2003-02-23 08:26:30 +01:00
<returns > The value associated with the <paramref name= "key" /> </returns>
2003-02-18 02:33:14 +01:00
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
Looks up key in the list of options that may have been
attached to the pixbuf when it was loaded.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "SaturateAndPixelate" >
<MemberSignature Language= "C#" Value= "public void SaturateAndPixelate (Gdk.Pixbuf dest, float saturation, bool pixelate);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "dest" Type= "Gdk.Pixbuf" />
<Parameter Name= "saturation" Type= "System.Single" />
<Parameter Name= "pixelate" Type= "System.Boolean" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Saturation and pixelation of a Pixbuf</summary>
<param name= "dest" > Target Pixbuf where the resulting image is stored</param>
<param name= "saturation" > saturation factor</param>
<param name= "pixelate" > whether to pixelation will take place</param>
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
Modifies saturation and optionally pixelates the Pixbuf,
2003-02-23 08:26:30 +01:00
placing the result in <paramref name= "dest" /> . <paramref name= "dest" /> may be the same Pixbuf with no ill
effects. If <paramref name= "saturation" /> is 1.0 then
2003-02-18 02:33:14 +01:00
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
2003-02-23 08:26:30 +01:00
brightened). If <paramref name= "pixelate" /> is <see langword= "true" /> , then pixels are faded in a checkerboard
2003-02-18 02:33:14 +01:00
pattern to create a pixelated image. src and dest must
have the same image format, size, and rowstride.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "RenderToDrawableAlpha" >
<MemberSignature Language= "C#" Value= "public void RenderToDrawableAlpha (Gdk.Drawable drawable, int src_x, int src_y, int dest_x, int dest_y, int width, int height, Gdk.PixbufAlphaMode alpha_mode, int alpha_threshold, Gdk.RgbDither dither, int x_dither, int y_dither);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "drawable" Type= "Gdk.Drawable" />
<Parameter Name= "src_x" Type= "System.Int32" />
<Parameter Name= "src_y" Type= "System.Int32" />
<Parameter Name= "dest_x" Type= "System.Int32" />
<Parameter Name= "dest_y" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
<Parameter Name= "alpha_mode" Type= "Gdk.PixbufAlphaMode" />
<Parameter Name= "alpha_threshold" Type= "System.Int32" />
<Parameter Name= "dither" Type= "Gdk.RgbDither" />
<Parameter Name= "x_dither" Type= "System.Int32" />
<Parameter Name= "y_dither" Type= "System.Int32" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2004-10-28 21:26:15 +02:00
<summary > Obsolete; do not use. Use <see cref= "M:Gdk.Drawable.DrawPixbuf" /> instead.</summary>
<param name= "drawable" > A <see cref= "T:Gdk.Drawable" /> </param>
<param name= "src_x" > A <see cref= "T:System.Int32" /> </param>
<param name= "src_y" > A <see cref= "T:System.Int32" /> </param>
<param name= "dest_x" > A <see cref= "T:System.Int32" /> </param>
<param name= "dest_y" > A <see cref= "T:System.Int32" /> </param>
<param name= "width" > A <see cref= "T:System.Int32" /> </param>
<param name= "height" > A <see cref= "T:System.Int32" /> </param>
<param name= "alpha_mode" > A <see cref= "T:Gdk.PixbufAlphaMode" /> </param>
<param name= "alpha_threshold" > A <see cref= "T:System.Int32" /> </param>
<param name= "dither" > A <see cref= "T:Gdk.RgbDither" /> </param>
<param name= "x_dither" > A <see cref= "T:System.Int32" /> </param>
<param name= "y_dither" > A <see cref= "T:System.Int32" /> </param>
2004-09-25 15:52:01 +02:00
<remarks > 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.
2004-10-28 21:26:15 +02:00
Otherwise a colormap must be set on them with <see cref= "P:Gdk.Drawable.Colormap" /> .
2004-09-25 15:52:01 +02:00
On older X servers, rendering pixbufs with an alpha channel involves round trips
to the X server, and may be somewhat slow.
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "public Pixbuf (IntPtr raw);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "raw" Type= "System.IntPtr" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Internal constructor</summary>
<param name= "raw" > Pointer to the C object.</param>
<remarks >
2003-02-23 08:26:30 +01:00
<para > This is an internal constructor, and should not be used by user code.</para>
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "public Pixbuf (Gdk.Colorspace colorspace, bool has_alpha, int bits_per_sample, int width, int height);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "colorspace" Type= "Gdk.Colorspace" />
<Parameter Name= "has_alpha" Type= "System.Boolean" />
<Parameter Name= "bits_per_sample" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Constructor</summary>
2003-02-23 08:26:30 +01:00
<param name= "colorspace" > The colorspace (<see cref= "T:Gdk.Colorspace" /> )</param>
2003-02-18 02:33:14 +01:00
<param name= "has_alpha" > Whether the image should have transparency information.</param>
<param name= "bits_per_sample" > Number of bits per color sample.</param>
<param name= "width" > Width of image in pixels.</param>
<param name= "height" > Height of image in pixels.</param>
<remarks >
2003-02-23 08:26:30 +01:00
<para >
Creates a new <see cref= "T:Gdk.Pixbuf" /> structure and allocates a buffer
2003-02-18 02:33:14 +01:00
for it. The buffer has an optimal rowstride. Note that the
buffer is not cleared; you will have to fill it completely
yourself.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "public Pixbuf (string filename);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "filename" Type= "System.String" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Creates Pixbuf from image file.</summary>
<param name= "filename" > Filename with the image</param>
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
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
2003-02-23 08:26:30 +01:00
found, a <see cref= "T:GLib.GException" /> will be thrown.
2003-02-18 02:33:14 +01:00
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "public Pixbuf (Gdk.Pixbuf src_pixbuf, int src_x, int src_y, int width, int height);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "src_pixbuf" Type= "Gdk.Pixbuf" />
<Parameter Name= "src_x" Type= "System.Int32" />
<Parameter Name= "src_y" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
</Parameters>
2003-02-12 02:57:20 +01:00
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Creates a sub-Pixbuf from an existing one.</summary>
2003-02-23 08:26:30 +01:00
<param name= "src_pixbuf" > The containing <see cref= "T:Gdk.Pixbuf" /> .</param>
2003-02-18 02:33:14 +01:00
<param name= "src_x" > X coord in src_pixbuf</param>
<param name= "src_y" > Y coord in src_pixbuf</param>
<param name= "width" > Width of region in src_pixbuf</param>
<param name= "height" > Height of region in src_pixbuf</param>
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
Creates a new pixbuf which represents a sub-region of
2003-02-23 08:26:30 +01:00
<paramref name= "src_pixbuf" /> . The new pixbuf shares its
2003-02-18 02:33:14 +01:00
pixels with the original pixbuf, so writing to one affects
2003-02-23 08:26:30 +01:00
both. The new pixbuf holds a reference to <paramref name= "src_pixbuf" /> , so <paramref name= "src_pixbuf" /> will
2003-02-18 02:33:14 +01:00
not be finalized until the new pixbuf is finalized.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
</Member>
<Member MemberName= "BitsPerSample" >
<MemberSignature Language= "C#" Value= "public int BitsPerSample { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > System.Int32</ReturnType>
</ReturnValue>
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Number of bits per color sample in a pixbuf.</summary>
2005-05-23 22:41:51 +02:00
<value > The number of bits per color sample in the pixbuf</value>
2003-02-18 02:33:14 +01:00
<remarks > None.</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
2005-06-16 20:56:42 +02:00
<Attributes >
2005-05-23 22:41:51 +02:00
<Attribute >
2005-12-10 00:12:49 +01:00
<AttributeName > GLib.Property(Name="bits-per-sample")</AttributeName>
2005-05-23 22:41:51 +02:00
</Attribute>
2005-06-16 20:56:42 +02:00
</Attributes>
</Member>
2003-02-12 02:57:20 +01:00
<Member MemberName= "Height" >
<MemberSignature Language= "C#" Value= "public int Height { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > System.Int32</ReturnType>
</ReturnValue>
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Height of the image</summary>
2005-05-23 22:41:51 +02:00
<value >
2003-02-23 08:26:30 +01:00
<para > The height in pixels of the image</para>
2005-05-23 22:41:51 +02:00
</value>
2003-02-20 04:56:51 +01:00
<remarks >
2003-02-23 08:26:30 +01:00
<para >
See also the <see cref= "P:Gdk.Pixbuf.Width" /> , <see cref= "P:Gdk.Pixbuf.Rowstride" /> and <see cref= "P:Gdk.Pixbuf.NChannels" /> for more information about
2003-02-20 04:56:51 +01:00
the layout of the image.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
2005-06-16 20:56:42 +02:00
<Attributes >
2005-05-23 22:41:51 +02:00
<Attribute >
<AttributeName > GLib.Property(Name="height")</AttributeName>
</Attribute>
2005-06-16 20:56:42 +02:00
</Attributes>
</Member>
2003-02-12 02:57:20 +01:00
<Member MemberName= "HasAlpha" >
<MemberSignature Language= "C#" Value= "public bool HasAlpha { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > System.Boolean</ReturnType>
</ReturnValue>
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Returns whether the Pixbuf contains an alpha channel</summary>
2005-05-23 22:41:51 +02:00
<value >
2003-02-23 08:26:30 +01:00
<see langword= "true" /> if the image contains an Alpha
2005-05-23 22:41:51 +02:00
channel, <see langword= "false" /> otherwise.</value>
2003-02-18 02:33:14 +01:00
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
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.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
2005-06-16 20:56:42 +02:00
<Attributes >
2005-05-23 22:41:51 +02:00
<Attribute >
2005-12-10 00:12:49 +01:00
<AttributeName > GLib.Property(Name="has-alpha")</AttributeName>
2005-05-23 22:41:51 +02:00
</Attribute>
2005-06-16 20:56:42 +02:00
</Attributes>
</Member>
2003-02-12 02:57:20 +01:00
<Member MemberName= "Width" >
<MemberSignature Language= "C#" Value= "public int Width { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > System.Int32</ReturnType>
</ReturnValue>
<Docs >
2003-02-18 02:33:14 +01:00
<summary > The width of the image</summary>
2005-05-23 22:41:51 +02:00
<value >
2003-02-23 08:26:30 +01:00
<para > The width in pixels of the image</para>
2005-05-23 22:41:51 +02:00
</value>
2003-02-20 04:56:51 +01:00
<remarks >
2003-02-23 08:26:30 +01:00
<para >
This is the width of the image in pixels. See the <see cref= "P:Gdk.Pixbuf.Rowstride" /> property as well.
2003-02-20 04:56:51 +01:00
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
2005-06-16 20:56:42 +02:00
<Attributes >
2005-05-23 22:41:51 +02:00
<Attribute >
<AttributeName > GLib.Property(Name="width")</AttributeName>
</Attribute>
2005-06-16 20:56:42 +02:00
</Attributes>
</Member>
2003-02-12 02:57:20 +01:00
<Member MemberName= "NChannels" >
<MemberSignature Language= "C#" Value= "public int NChannels { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > System.Int32</ReturnType>
</ReturnValue>
<Docs >
2003-02-18 02:33:14 +01:00
<summary > The number of channels on a Pixbuf</summary>
2005-05-23 22:41:51 +02:00
<value > Returns the number of channels on a Pixbuf</value>
2003-02-18 02:33:14 +01:00
<remarks >
2003-02-20 04:56:51 +01:00
The possible values are 3 (for RGB encoding) and 4 (for RGB
2004-06-25 17:55:40 +02:00
with an alpha transparency channel encoding).
2003-02-18 02:33:14 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
2005-06-16 20:56:42 +02:00
<Attributes >
2005-05-23 22:41:51 +02:00
<Attribute >
2005-12-10 00:12:49 +01:00
<AttributeName > GLib.Property(Name="n-channels")</AttributeName>
2005-05-23 22:41:51 +02:00
</Attribute>
2005-06-16 20:56:42 +02:00
</Attributes>
</Member>
2003-02-12 02:57:20 +01:00
<Member MemberName= "Rowstride" >
<MemberSignature Language= "C#" Value= "public int Rowstride { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > System.Int32</ReturnType>
</ReturnValue>
<Docs >
2003-02-18 02:33:14 +01:00
<summary > Rowstride of the Pixbuf</summary>
2005-05-23 22:41:51 +02:00
<value > The rowstride property for the Pixbuf</value>
2003-02-18 02:33:14 +01:00
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-20 04:56:51 +01:00
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.
2003-02-18 02:33:14 +01:00
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
2005-06-16 20:56:42 +02:00
<Attributes >
2005-05-23 22:41:51 +02:00
<Attribute >
<AttributeName > GLib.Property(Name="rowstride")</AttributeName>
</Attribute>
2005-06-16 20:56:42 +02:00
</Attributes>
</Member>
2003-02-12 02:57:20 +01:00
<Member MemberName= "Colorspace" >
<MemberSignature Language= "C#" Value= "public Gdk.Colorspace Colorspace { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > Gdk.Colorspace</ReturnType>
</ReturnValue>
<Docs >
2003-02-18 02:33:14 +01:00
<summary > The colorspace for this Pixbuf</summary>
2005-05-23 22:41:51 +02:00
<value > The colorspace used by this Pixbuf</value>
2003-02-18 02:33:14 +01:00
<remarks >
2003-02-23 08:26:30 +01:00
<para >
2003-02-18 02:33:14 +01:00
Currently Pixbuf only support the RGB colorspace.
</para>
2003-02-23 08:26:30 +01:00
</remarks>
2003-02-12 02:57:20 +01:00
</Docs>
2005-06-16 20:56:42 +02:00
<Attributes >
2005-05-23 22:41:51 +02:00
<Attribute >
<AttributeName > GLib.Property(Name="colorspace")</AttributeName>
</Attribute>
2005-06-16 20:56:42 +02:00
</Attributes>
</Member>
2003-03-07 02:30:00 +01:00
<Member MemberName= "CreateFromDrawable" >
<MemberSignature Language= "C#" Value= "public Gdk.Pixbuf CreateFromDrawable (Gdk.Drawable src, Gdk.Colormap cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "src" Type= "Gdk.Drawable" />
<Parameter Name= "cmap" Type= "Gdk.Colormap" />
<Parameter Name= "src_x" Type= "System.Int32" />
<Parameter Name= "src_y" Type= "System.Int32" />
<Parameter Name= "dest_x" Type= "System.Int32" />
<Parameter Name= "dest_y" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
</Parameters>
2003-03-07 02:30:00 +01:00
<Docs >
2004-10-28 21:26:15 +02:00
<summary > Generates a new Pixbuf object from a <see cref= "T:Gdk.Drawable" /> .</summary>
<param name= "src" > A <see cref= "T:Gdk.Drawable" /> </param>
<param name= "cmap" > A <see cref= "T:Gdk.Colormap" /> </param>
<param name= "src_x" > A <see cref= "T:System.Int32" /> </param>
<param name= "src_y" > A <see cref= "T:System.Int32" /> </param>
<param name= "dest_x" > A <see cref= "T:System.Int32" /> </param>
<param name= "dest_y" > A <see cref= "T:System.Int32" /> </param>
<param name= "width" > A <see cref= "T:System.Int32" /> </param>
<param name= "height" > A <see cref= "T:System.Int32" /> </param>
<returns > A <see cref= "T:Gdk.Pixbuf" /> </returns>
<remarks />
2003-03-07 02:30:00 +01:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public Pixbuf (int data_length, void* data, bool copy_pixels);" />
2003-03-07 02:30:00 +01:00
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
2003-09-17 23:56:59 +02:00
<Parameter Name= "data_length" Type= "System.Int32" />
<Parameter Name= "data" Type= "System.Void*" />
<Parameter Name= "copy_pixels" Type= "System.Boolean" />
</Parameters>
2003-03-07 02:30:00 +01:00
<Docs >
2004-06-25 17:55:40 +02:00
<summary > Construct a pixbuf from a serialized <see cref= "T:Gdk.Pixdata" /> structure.</summary>
<param name= "data_length" > The length in bytes of the data to be read.</param>
<param name= "data" > The raw data representing the serialized <see cref= "T:Gdk.Pixdata" /> structure.</param>
2004-06-27 01:32:02 +02:00
<param name= "copy_pixels" > 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.</param>
<remarks > None</remarks>
2003-03-07 02:30:00 +01:00
</Docs>
</Member>
2003-07-17 08:38:40 +02:00
<Member MemberName= "ErrorQuark" >
<MemberSignature Language= "C#" Value= "public static int ErrorQuark ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Int32</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
<summary > To be added</summary>
<returns > a <see cref= "T:System.Int32" /> </returns>
2004-10-28 21:26:15 +02:00
<remarks />
2003-07-17 08:38:40 +02:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
2003-12-04 22:09:30 +01:00
<MemberSignature Language= "C#" Value= "public Pixbuf (System.Reflection.Assembly assembly, string resource);" />
2003-07-17 08:38:40 +02:00
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
2003-12-04 22:09:30 +01:00
<Parameter Name= "assembly" Type= "System.Reflection.Assembly" />
<Parameter Name= "resource" Type= "System.String" />
2003-09-17 23:56:59 +02:00
</Parameters>
2003-07-17 08:38:40 +02:00
<Docs >
2005-02-11 23:55:08 +01:00
<summary > Constructor for images embedded in an assembly</summary>
<param name= "assembly" > The <see cref= "T:System.Reflection.Assembly" /> that contains the image.
<para >
If the value is <see langword= "null" /> , the image will be looked up on the calling assembly.</para> </param>
<param name= "resource" > The name given as the resource in the assembly</param>
<remarks >
<para >
This method is used to construct a <see cref= "T:Gdk.Pixbuf" /> from an embedded resource in an assembly.
</para>
<para >
Typically this is used when application developers want to distribute images in a single executable.
</para>
If the assembly parameter is <see langword= "null" /> , the image will be looked up on the calling assembly.
<para >
For example:
</para> <example >
<code lang= "C#" >
Gdk.Pixbuf p = new Pixbuf (null, "image.jpg");
</code>
</example> <para > Compile with:</para> <example >
<code lang= "Compilation" >
2005-05-06 16:24:44 +02:00
mcs -resource:image.jpg sample.cs
</code>
</example> </remarks>
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "public Pixbuf (System.Reflection.Assembly assembly, string resource, int width, int height);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
<Parameter Name= "assembly" Type= "System.Reflection.Assembly" />
<Parameter Name= "resource" Type= "System.String" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
</Parameters>
<Docs >
<summary > Constructor for images embedded in an assembly when a specific size is required.</summary>
<param name= "assembly" > The <see cref= "T:System.Reflection.Assembly" /> that contains the image.
<para >
If the value is <see langword= "null" /> , the image will be looked up on the calling assembly.</para> </param>
<param name= "resource" > The name given as the resource in the assembly</param>
<param name= "width" > The required width for the pixbuf</param>
<param name= "height" > The required height for the pixbuf</param>
<remarks >
<para >
This method is used to construct a <see cref= "T:Gdk.Pixbuf" /> from an embedded resource in an assembly with a specific size.
</para>
<para >
Typically this is used when application developers want to distribute images in a single executable.
</para>
If the assembly parameter is <see langword= "null" /> , the image will be looked up on the calling assembly.
<para >
For example:
</para> <example >
<code lang= "C#" >
Gdk.Pixbuf p = new Pixbuf (null, "image.jpg", 10, 10);
</code>
</example> <para > Compile with:</para> <example >
<code lang= "Compilation" >
2005-02-11 23:55:08 +01:00
mcs -resource:image.jpg sample.cs
</code>
</example> </remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2003-12-04 22:09:30 +01:00
</Docs>
</Member>
<Member MemberName= "LoadFromResource" >
<MemberSignature Language= "C#" Value= "public static Gdk.Pixbuf LoadFromResource (string resource);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "resource" Type= "System.String" />
</Parameters>
<Docs >
2005-04-01 16:54:12 +02:00
<summary > Loads a pixbuf from a resource file.</summary>
<param name= "resource" > the name of the resource</param>
2003-07-17 08:38:40 +02:00
<returns > a <see cref= "T:Gdk.Pixbuf" /> </returns>
2005-04-01 16:54:12 +02:00
<remarks >
This loads a pixbuf from a resource in the calling assembly. This is equivalent to
using the <see cref= "C:Gdk.Pixbuf(System.Reflection.Assembly, System.String)" />
constructor with a <see langword= "null" /> assembly.
</remarks>
2003-07-17 08:38:40 +02:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
2003-12-04 22:09:30 +01:00
<MemberSignature Language= "C#" Value= "public Pixbuf (System.IO.Stream stream);" />
2003-07-17 08:38:40 +02:00
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
2003-12-04 22:09:30 +01:00
<Parameter Name= "stream" Type= "System.IO.Stream" />
2003-09-17 23:56:59 +02:00
</Parameters>
2003-07-17 08:38:40 +02:00
<Docs >
2004-10-28 21:26:15 +02:00
<summary > Makes a new Pixbuf object from a <see cref= "T:System.IO.Stream" /> .</summary>
2005-05-06 16:24:44 +02:00
<param name= "stream" > a <see cref= "T:System.IO.Stream" /> containing the image</param>
<remarks > Useful for creating a Pixbuf from an image file that resides in a stream.
2004-11-04 21:03:15 +01:00
<example >
<code lang= "C#" >
/* 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);
2005-05-06 16:24:44 +02:00
</code>
</example> </remarks>
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "public Pixbuf (System.IO.Stream stream, int width, int height);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
<Parameter Name= "stream" Type= "System.IO.Stream" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
</Parameters>
<Docs >
<summary > Makes a new Pixbuf object from a <see cref= "T:System.IO.Stream" /> with a given size.</summary>
<param name= "stream" > a <see cref= "T:System.IO.Stream" /> containing the image</param>
<param name= "width" > a <see cref= "T:System.Int32" /> specifying the required width</param>
<param name= "height" > a <see cref= "T:System.Int32" /> specifying the required height</param>
<remarks > Useful for creating a Pixbuf with a specific size from an image file that resides in a stream.
<example >
<code lang= "C#" >
/* 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);
</code>
</example> </remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2005-05-06 16:24:44 +02:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public Pixbuf (byte[] buffer);" />
2005-05-06 16:24:44 +02:00
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
<Parameter Name= "buffer" Type= "System.Byte[]" />
</Parameters>
<Docs >
2005-10-21 17:26:09 +02:00
<summary > Makes a new Pixbuf object from a <see cref= "T:System.Byte[]" /> containing an encoded image.</summary>
<param name= "buffer" > a <see cref= "T:System.Byte[]" /> containing the image in one of the formats recognized by Pixbuf (png, tiff, jpeg, etc).</param>
2005-05-06 16:24:44 +02:00
<remarks > Useful for creating a Pixbuf from an image file in memory.
<example >
<code lang= "C#" >
/* 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);
</code>
</example> </remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2005-05-06 16:24:44 +02:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public Pixbuf (byte[] buffer, int width, int height);" />
2005-05-06 16:24:44 +02:00
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
<Parameter Name= "buffer" Type= "System.Byte[]" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
</Parameters>
<Docs >
<summary > Makes a new Pixbuf object from a <see cref= "T:System.Byte[]" /> with a given size.</summary>
<param name= "buffer" > a <see cref= "T:System.Byte[]" /> containing the image</param>
<param name= "width" > a <see cref= "T:System.Int32" /> specifying the required width</param>
<param name= "height" > a <see cref= "T:System.Int32" /> specifying the required height</param>
<remarks > Useful for creating a Pixbuf with a specific size from an image file in memory.
<example >
<code lang= "C#" >
/* 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);
2004-11-04 21:03:15 +01:00
</code>
</example> </remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2003-07-17 08:38:40 +02:00
</Docs>
</Member>
2003-10-28 01:48:23 +01:00
<Member MemberName= ".ctor" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public Pixbuf (byte[] data, Gdk.Colorspace colorspace, bool has_alpha, int bits_per_sample, int width, int height, int rowstride, Gdk.PixbufDestroyNotify destroy_fn);" />
2003-10-28 01:48:23 +01:00
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
2003-12-04 22:09:30 +01:00
<Parameter Name= "data" Type= "System.Byte[]" />
2003-10-28 01:48:23 +01:00
<Parameter Name= "colorspace" Type= "Gdk.Colorspace" />
<Parameter Name= "has_alpha" Type= "System.Boolean" />
<Parameter Name= "bits_per_sample" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
<Parameter Name= "rowstride" Type= "System.Int32" />
<Parameter Name= "destroy_fn" Type= "Gdk.PixbufDestroyNotify" />
</Parameters>
<Docs >
2005-10-21 17:26:09 +02:00
<summary > Public constructor; creates a new <see cref= "T:Gdk.Pixbuf" /> from an in-memory RGB or RGBA buffer.</summary>
<param name= "data" > The data that contains the image in RGB or RGBA format.</param>
<param name= "colorspace" > The <see cref= "T:Gdk.Colorspace" /> for the image data.</param>
<param name= "has_alpha" > Whether the data contains an alpha channel (RGBA format).</param>
<param name= "bits_per_sample" > Currently only 8 is supported (1 byte per channel).</param>
<param name= "width" > Width of the image in pixels.</param>
<param name= "height" > Height of the image in pixels.</param>
<param name= "rowstride" > The rowstride is the number of bytes consumed by a single row in the image.</param>
<param name= "destroy_fn" > A routine to invoke when the reference count to this image reaches zero.</param>
<remarks > The image must be in RGB format or RGBA format, where each channel takes one byte.
<para >
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 <paramref name= "row_stride" /> argument is the size in bytes of each row. If no padding is added the <paramref name= "row_stride" /> is just: <paramref name= "width" /> * (3 + <paramref name= "has_alpha" /> ).
</para> </remarks>
2003-10-28 01:48:23 +01:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public Pixbuf (int data_length, byte[] data, bool copy_pixels);" />
2003-10-28 01:48:23 +01:00
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
<Parameter Name= "data_length" Type= "System.Int32" />
2003-12-04 22:09:30 +01:00
<Parameter Name= "data" Type= "System.Byte[]" />
2003-10-28 01:48:23 +01:00
<Parameter Name= "copy_pixels" Type= "System.Boolean" />
</Parameters>
<Docs >
2004-06-25 17:55:40 +02:00
<summary > Construct a pixbuf from a serialized <see cref= "T:Gdk.Pixdata" /> structure</summary>
2004-06-27 01:32:02 +02:00
<param name= "data_length" > The length in bytes of the data to be read.</param>
<param name= "data" > A serialized <see cref= "T:Gdk.Pixdata" /> structure, generated with <see cref= "M:Gdk.Pixdata.Serialize" /> .</param>
<param name= "copy_pixels" > 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.</param>
<remarks > None</remarks>
2003-10-28 01:48:23 +01:00
</Docs>
</Member>
2003-12-04 22:09:30 +01:00
<Member MemberName= ".ctor" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public Pixbuf (string[] data);" />
2003-12-04 22:09:30 +01:00
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
<Parameter Name= "data" Type= "System.String[]" />
</Parameters>
<Docs >
2004-09-25 15:52:01 +02:00
<summary > Public constructor.</summary>
2003-12-04 22:09:30 +01:00
<param name= "data" > a <see cref= "T:System.String[]" /> </param>
2004-10-28 21:26:15 +02:00
<remarks />
2003-12-04 22:09:30 +01:00
</Docs>
</Member>
2003-12-24 02:35:30 +01:00
<Member MemberName= "GType" >
<MemberSignature Language= "C#" Value= "public static GLib.GType GType { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > GLib.GType</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
2004-06-21 22:14:42 +02:00
<summary > GType Property.</summary>
2005-05-23 22:41:51 +02:00
<value > a <see cref= "T:GLib.GType" /> </value>
2004-06-21 22:14:42 +02:00
<remarks > Returns the native <see cref= "T:GLib.GType" /> value for <see cref= "T:Gdk.Pixbuf" /> .</remarks>
2003-12-24 02:35:30 +01:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "protected Pixbuf (GLib.GType gtype);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
<Parameter Name= "gtype" Type= "GLib.GType" />
</Parameters>
<Docs >
<summary > Internal constructor</summary>
<param name= "gtype" > a <see cref= "T:GLib.GType" /> </param>
<remarks > This is a constructor used by derivative types of <see cref= "T:Gdk.Pixbuf" /> that would have their own GLib.GType assigned to it. This is not typically used by C# code.</remarks>
</Docs>
2005-06-16 20:56:42 +02:00
<Attributes >
2005-05-23 22:41:51 +02:00
<Attribute >
<AttributeName > System.Obsolete(Message=null, IsError=False)</AttributeName>
</Attribute>
2005-06-16 20:56:42 +02:00
</Attributes>
</Member>
2004-02-26 19:46:28 +01:00
<Member MemberName= "Formats" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public static Gdk.PixbufFormat[] Formats { get; };" />
2004-02-26 19:46:28 +01:00
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > Gdk.PixbufFormat[]</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
<summary > To be added</summary>
2005-05-23 22:41:51 +02:00
<value > a <see cref= "T:Gdk.PixbufFormat[]" /> </value>
2004-10-28 21:26:15 +02:00
<remarks />
2004-02-26 19:46:28 +01:00
</Docs>
</Member>
2004-05-27 21:02:19 +02:00
<Member MemberName= "Pixels" >
<MemberSignature Language= "C#" Value= "public IntPtr Pixels { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > System.IntPtr</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
2004-10-11 05:47:28 +02:00
<summary > The pixels contained by this Pixbuf object.</summary>
2005-05-23 22:41:51 +02:00
<value > a <see cref= "T:System.IntPtr" /> , pointer to the underlying C data</value>
2004-10-28 21:26:15 +02:00
<remarks />
2004-05-27 21:02:19 +02:00
</Docs>
</Member>
2004-06-14 22:28:28 +02:00
<Member MemberName= "Savev" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public bool Savev (string filename, string type, string[] option_keys, string[] option_values);" />
2004-06-14 22:28:28 +02:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Boolean</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "filename" Type= "System.String" />
<Parameter Name= "type" Type= "System.String" />
<Parameter Name= "option_keys" Type= "System.String[]" />
<Parameter Name= "option_values" Type= "System.String[]" />
</Parameters>
<Docs >
2004-10-11 05:47:28 +02:00
<summary > Saves pixbuf to a file.</summary>
2004-06-15 05:46:45 +02:00
<param name= "filename" > Name of the file where the image will be saved</param>
<param name= "type" > The file type to save (one of "ani", "bmp", "gif", "ico", "jpeg", "pcx", "png", "pnm", "ras", "tga", "tiff" "wbmp", "xpm" or "xbm")</param>
<param name= "option_keys" > Options that are passed to the save module.</param>
<param name= "option_values" > Values for each key</param>
2004-10-28 21:26:15 +02:00
<returns > A <see cref= "T:System.Boolean" /> </returns>
<remarks />
2004-06-14 22:28:28 +02:00
</Docs>
</Member>
<Member MemberName= "Save" >
<MemberSignature Language= "C#" Value= "public bool Save (string filename, string type);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Boolean</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "filename" Type= "System.String" />
<Parameter Name= "type" Type= "System.String" />
</Parameters>
<Docs >
2004-10-11 05:47:28 +02:00
<summary > Saves pixbuf to a file.</summary>
<param name= "filename" > a <see cref= "T:System.String" /> , name of the file to save</param>
<param name= "type" > a <see cref= "T:System.String" /> , file format to save in ("jpeg" and "png" are supported).</param>
2004-06-14 22:28:28 +02:00
<returns > a <see cref= "T:System.Boolean" /> </returns>
2004-10-11 05:47:28 +02:00
<remarks > 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.)
</remarks>
2004-06-14 22:28:28 +02:00
</Docs>
</Member>
2004-11-05 20:03:16 +01:00
<Member MemberName= "GetFileInfo" >
<MemberSignature Language= "C#" Value= "public static Gdk.PixbufFormat GetFileInfo (string filename, out int width, out int height);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.PixbufFormat</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "filename" Type= "System.String" />
<Parameter Name= "width" Type= "System.Int32&" RefType= "out" />
<Parameter Name= "height" Type= "System.Int32&" RefType= "out" />
</Parameters>
<Docs >
<summary > To be added</summary>
<param name= "filename" > a <see cref= "T:System.String" /> </param>
<param name= "width" > a <see cref= "T:System.Int32" /> </param>
<param name= "height" > a <see cref= "T:System.Int32" /> </param>
<returns > a <see cref= "T:Gdk.PixbufFormat" /> </returns>
<remarks > To be added</remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2004-11-05 20:03:16 +01:00
</Docs>
</Member>
<Member MemberName= "Unref" >
<MemberSignature Language= "C#" Value= "public void Unref ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
<summary > To be added</summary>
<remarks > To be added</remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2004-11-05 20:03:16 +01:00
</Docs>
</Member>
<Member MemberName= "Ref" >
<MemberSignature Language= "C#" Value= "public Gdk.Pixbuf Ref ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
<summary > To be added</summary>
<returns > a <see cref= "T:Gdk.Pixbuf" /> </returns>
<remarks > To be added</remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2004-11-05 20:03:16 +01:00
</Docs>
</Member>
<Member MemberName= "RenderPixmapAndMask" >
2005-04-12 05:39:23 +02:00
<MemberSignature Language= "C#" Value= "public void RenderPixmapAndMask (out Gdk.Pixmap pixmap_return, out Gdk.Pixmap mask_return, int alpha_threshold);" />
2004-11-05 20:03:16 +01:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2005-04-12 05:39:23 +02:00
<Parameter Name= "pixmap_return" Type= "Gdk.Pixmap&" RefType= "out" />
<Parameter Name= "mask_return" Type= "Gdk.Pixmap&" RefType= "out" />
2004-11-05 20:03:16 +01:00
<Parameter Name= "alpha_threshold" Type= "System.Int32" />
</Parameters>
<Docs >
2005-04-12 05:39:23 +02:00
<summary > Creates pixmap and mask bitmaps for a given alpha threshold.</summary>
2004-11-05 20:03:16 +01:00
<param name= "pixmap_return" > a <see cref= "T:Gdk.Pixmap" /> </param>
2004-12-03 21:42:12 +01:00
<param name= "mask_return" > a <see cref= "T:Gdk.Pixmap" /> </param>
2004-12-03 18:30:29 +01:00
<param name= "alpha_threshold" > a <see cref= "T:System.Int32" /> , threshold value for opacity.</param>
<remarks >
2005-04-12 05:39:23 +02:00
<para >
This is merely a convenience function; applications that need to render pixbufs with dither offsets or to
given drawables should use <see cref= "M:Gdk.Pixbuf.RenderToDrawableAlpha" />
or <see cref= "M:Gdk.Pixbuf.RenderToDrawable" /> and <see cref= "M:Gdk.Pixbuf.RenderThresholdAlpha" /> .
</para>
<para >
2004-12-03 18:30:29 +01:00
The pixmap that is created is created for the colormap returned
by <see cref= "M:Gdk.Rgb.GetColormap" /> . You normally will want to instead use
the actual colormap for a widget, and use
<see cref= "M:Gdk.Pixbuf.RenderPixmapAndMaskForColormap" /> ,
2004-12-03 21:42:12 +01:00
If the pixbuf does not have an alpha channel, then <paramref name= "mask_return" /> will be set
2004-12-03 18:30:29 +01:00
to <see langword= "null" /> .
2005-04-12 05:39:23 +02:00
</para>
2004-12-03 18:30:29 +01:00
</remarks>
2004-11-05 20:03:16 +01:00
</Docs>
</Member>
<Member MemberName= "RenderPixmapAndMaskForColormap" >
2005-04-12 05:39:23 +02:00
<MemberSignature Language= "C#" Value= "public void RenderPixmapAndMaskForColormap (Gdk.Colormap colormap, out Gdk.Pixmap pixmap_return, out Gdk.Pixmap mask_return, int alpha_threshold);" />
2004-11-05 20:03:16 +01:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "colormap" Type= "Gdk.Colormap" />
2005-04-12 05:39:23 +02:00
<Parameter Name= "pixmap_return" Type= "Gdk.Pixmap&" RefType= "out" />
<Parameter Name= "mask_return" Type= "Gdk.Pixmap&" RefType= "out" />
2004-11-05 20:03:16 +01:00
<Parameter Name= "alpha_threshold" Type= "System.Int32" />
</Parameters>
<Docs >
2005-04-12 05:39:23 +02:00
<summary > Creates pixmap and mask bitmaps for a given alpha threshold using a specified colormap.</summary>
2004-11-05 20:03:16 +01:00
<param name= "colormap" > a <see cref= "T:Gdk.Colormap" /> </param>
<param name= "pixmap_return" > a <see cref= "T:Gdk.Pixmap" /> </param>
2004-12-03 21:42:12 +01:00
<param name= "mask_return" > a <see cref= "T:Gdk.Pixmap" /> </param>
2005-04-12 05:39:23 +02:00
<param name= "alpha_threshold" > a <see cref= "T:System.Int32" /> , threshold value for opacity.</param>
2004-12-03 18:30:29 +01:00
<remarks >
2005-04-12 05:39:23 +02:00
<para >
This is merely a convenience function; applications that need to render pixbufs with dither offsets or to
given drawables should use <see cref= "M:Gdk.Pixbuf.RenderToDrawableAlpha" /> or <see cref= "M:Gdk.Pixbuf.RenderToDrawable" /> and <see cref= "M:Gdk.Pixbuf.RenderThresholdAlpha" /> .
</para>
<para >
2004-12-03 18:30:29 +01:00
The pixmap that is created uses the <see cref= "T:Gdk.Colormap" /> specified by <paramref name= "colormap" /> .
2005-04-12 05:39:23 +02:00
This colormap must match the colormap of the window where the pixmap will eventually be used or an error will result.
2004-12-03 21:42:12 +01:00
If the pixbuf does not have an alpha channel, then <paramref name= "mask_return" /> will be set
2004-12-03 18:30:29 +01:00
to <see langword= "null" /> .
2005-04-12 05:39:23 +02:00
</para>
2005-04-21 19:10:54 +02:00
</remarks>
2004-11-05 20:03:16 +01:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "public Pixbuf (string filename, int width, int height);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
<Parameter Name= "filename" Type= "System.String" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
</Parameters>
<Docs >
<summary > To be added</summary>
<param name= "filename" > a <see cref= "T:System.String" /> </param>
<param name= "width" > a <see cref= "T:System.Int32" /> </param>
<param name= "height" > a <see cref= "T:System.Int32" /> </param>
<remarks > To be added</remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2004-11-05 20:03:16 +01:00
</Docs>
</Member>
2005-01-25 18:20:55 +01:00
<Member MemberName= "SaveToBuffer" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public byte[] SaveToBuffer (string type, string[] option_keys, string[] option_values);" />
2005-01-25 18:20:55 +01:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Byte[]</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "type" Type= "System.String" />
<Parameter Name= "option_keys" Type= "System.String[]" />
<Parameter Name= "option_values" Type= "System.String[]" />
</Parameters>
<Docs >
<summary > Saves to a buffer.</summary>
<param name= "type" > an image type, such as png, jpeg, or ico</param>
<param name= "option_keys" > an array of option keys.</param>
<param name= "option_values" > an array of option values.</param>
<returns > a <see cref= "T:System.Byte[]" /> </returns>
2005-02-11 23:55:08 +01:00
<remarks > > The <paramref name= "option_keys" /> and <paramref name= "option_values" /> should contain key/value pairs. See <see cref= "M:Gdk.Pixbuf.Save" /> for more details. Throws a <see cref= "T:GLib.GException" /> if the save is not successful.</remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2005-01-25 18:20:55 +01:00
</Docs>
</Member>
<Member MemberName= "SaveToBuffer" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public byte[] SaveToBuffer (string type);" />
2005-01-25 18:20:55 +01:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Byte[]</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "type" Type= "System.String" />
</Parameters>
<Docs >
<summary > Saves to a buffer.</summary>
<param name= "type" > an image type, such as png, jpeg, or ico</param>
<returns > a <see cref= "T:System.Byte[]" /> </returns>
2005-02-11 23:55:08 +01:00
<remarks > Throws a <see cref= "T:GLib.GException" /> if the save is not successful.</remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2005-01-25 18:20:55 +01:00
</Docs>
</Member>
<Member MemberName= "SaveToCallback" >
<MemberSignature Language= "C#" Value= "public void SaveToCallback (Gdk.PixbufSaveFunc save_func, string type);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "save_func" Type= "Gdk.PixbufSaveFunc" />
<Parameter Name= "type" Type= "System.String" />
</Parameters>
<Docs >
<summary > Save using a callback delegate.</summary>
<param name= "save_func" > a <see cref= "T:Gdk.PixbufSaveFunc" /> </param>
<param name= "type" > an image type, such as png, jpeg, or ico</param>
2005-02-11 23:55:08 +01:00
<remarks > Throws a <see cref= "T:GLib.GException" /> if the save is not successful.</remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2005-01-25 18:20:55 +01:00
</Docs>
</Member>
<Member MemberName= "SaveToCallback" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public void SaveToCallback (Gdk.PixbufSaveFunc save_func, string type, string[] option_keys, string[] option_values);" />
2005-01-25 18:20:55 +01:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "save_func" Type= "Gdk.PixbufSaveFunc" />
<Parameter Name= "type" Type= "System.String" />
<Parameter Name= "option_keys" Type= "System.String[]" />
<Parameter Name= "option_values" Type= "System.String[]" />
</Parameters>
<Docs >
<summary > Save using a callback delegate.</summary>
<param name= "save_func" > a <see cref= "T:Gdk.PixbufSaveFunc" /> </param>
<param name= "type" > an image type, such as png, jpeg, or ico</param>
<param name= "option_keys" > an array of option keys</param>
<param name= "option_values" > an array of option values</param>
2005-02-11 23:55:08 +01:00
<remarks > The <paramref name= "option_keys" /> and <paramref name= "option_values" /> should contain key/value pairs. See <see cref= "M:Gdk.Pixbuf.Save" /> for more details. Throws a <see cref= "T:GLib.GException" /> if the save is not successful.</remarks>
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2005-01-25 18:20:55 +01:00
</Docs>
</Member>
2005-03-28 23:57:19 +02:00
<Member MemberName= "FromDrawable" >
<MemberSignature Language= "C#" Value= "public static Gdk.Pixbuf FromDrawable (Gdk.Drawable src, Gdk.Colormap cmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "src" Type= "Gdk.Drawable" />
<Parameter Name= "cmap" Type= "Gdk.Colormap" />
<Parameter Name= "src_x" Type= "System.Int32" />
<Parameter Name= "src_y" Type= "System.Int32" />
<Parameter Name= "dest_x" Type= "System.Int32" />
<Parameter Name= "dest_y" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
</Parameters>
<Docs >
<summary > Creates a new Pixbuf object from a <see cref= "T:Gdk.Drawable" /> .</summary>
<param name= "src" > a <see cref= "T:Gdk.Drawable" /> </param>
<param name= "cmap" > a <see cref= "T:Gdk.Colormap" /> </param>
<param name= "src_x" > a <see cref= "T:System.Int32" /> </param>
<param name= "src_y" > a <see cref= "T:System.Int32" /> </param>
<param name= "dest_x" > a <see cref= "T:System.Int32" /> </param>
<param name= "dest_y" > a <see cref= "T:System.Int32" /> </param>
<param name= "width" > a <see cref= "T:System.Int32" /> </param>
<param name= "height" > a <see cref= "T:System.Int32" /> </param>
<returns > a <see cref= "T:Gdk.Pixbuf" /> </returns>
<remarks />
2005-06-16 20:56:42 +02:00
<since version= "Gtk# 2.4" />
2005-03-28 23:57:19 +02:00
</Docs>
</Member>
2005-04-21 19:10:54 +02:00
<Member MemberName= "RotateSimple" >
<MemberSignature Language= "C#" Value= "public Gdk.Pixbuf RotateSimple (Gdk.PixbufRotation angle);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "angle" Type= "Gdk.PixbufRotation" />
</Parameters>
<Docs >
2006-03-02 02:40:08 +01:00
<summary > Rotates a pixbuf by a multiple of 90 degrees, and returns the result in a new pixbuf.</summary>
<param name= "angle" > The angle to rotate by.</param>
<returns > A <see cref= "T:Gdk.Pixbuf" /> .</returns>
<remarks />
2005-06-16 21:27:40 +02:00
<since version= "Gtk# 2.6" />
2005-04-21 19:10:54 +02:00
</Docs>
</Member>
<Member MemberName= "Flip" >
<MemberSignature Language= "C#" Value= "public Gdk.Pixbuf Flip (bool horizontal);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gdk.Pixbuf</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "horizontal" Type= "System.Boolean" />
</Parameters>
<Docs >
2006-03-02 02:40:08 +01:00
<summary > Flips a pixbuf horizontally or vertically.</summary>
<param name= "horizontal" > <see langword= "true" /> to flip horizontally, <see langword= "false" /> to flip vertically.</param>
<returns > A <see cref= "T:Gdk.Pixbuf" /> .</returns>
<remarks />
2005-06-16 21:27:40 +02:00
<since version= "Gtk# 2.6" />
2005-04-21 19:10:54 +02:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "public Pixbuf (string filename, int width, int height, bool preserve_aspect_ratio);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
<Parameter Name= "filename" Type= "System.String" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
<Parameter Name= "preserve_aspect_ratio" Type= "System.Boolean" />
</Parameters>
<Docs >
<summary > To be added</summary>
<param name= "filename" > a <see cref= "T:System.String" /> </param>
<param name= "width" > a <see cref= "T:System.Int32" /> </param>
<param name= "height" > a <see cref= "T:System.Int32" /> </param>
<param name= "preserve_aspect_ratio" > a <see cref= "T:System.Boolean" /> </param>
<remarks > To be added</remarks>
2005-06-16 21:27:40 +02:00
<since version= "Gtk# 2.6" />
2005-04-21 19:10:54 +02:00
</Docs>
</Member>
2005-06-16 20:56:42 +02:00
<Member MemberName= ".ctor" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public Pixbuf (byte[] data, bool has_alpha, int bits_per_sample, int width, int height, int rowstride, Gdk.PixbufDestroyNotify destroy_fn);" />
<MemberType > Constructor</MemberType>
<Parameters >
<Parameter Name= "data" Type= "System.Byte[]" />
<Parameter Name= "has_alpha" Type= "System.Boolean" />
<Parameter Name= "bits_per_sample" Type= "System.Int32" />
<Parameter Name= "width" Type= "System.Int32" />
<Parameter Name= "height" Type= "System.Int32" />
<Parameter Name= "rowstride" Type= "System.Int32" />
<Parameter Name= "destroy_fn" Type= "Gdk.PixbufDestroyNotify" />
</Parameters>
<Docs >
<param name= "data" > To be added.</param>
<param name= "has_alpha" > To be added.</param>
<param name= "bits_per_sample" > To be added.</param>
<param name= "width" > To be added.</param>
<param name= "height" > To be added.</param>
<param name= "rowstride" > To be added.</param>
<param name= "destroy_fn" > To be added.</param>
<summary > To be added.</summary>
<remarks > To be added.</remarks>
</Docs>
</Member>
2005-06-16 20:56:42 +02:00
<Member MemberName= ".ctor" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public Pixbuf (byte[] data, bool copy_pixels);" />
<MemberType > Constructor</MemberType>
<Parameters >
<Parameter Name= "data" Type= "System.Byte[]" />
<Parameter Name= "copy_pixels" Type= "System.Boolean" />
</Parameters>
<Docs >
<param name= "data" > To be added.</param>
<param name= "copy_pixels" > To be added.</param>
2005-10-21 17:26:09 +02:00
<summary > Constructor for pixbufs that that have embedded images created with the gdk-pixbuf-source program.</summary>
<remarks > This is used to create pixbufs from images that have been embedded using the gdk-pixbuf-csource command line tool. </remarks>
2005-05-23 22:41:51 +02:00
</Docs>
</Member>
2005-06-16 20:56:42 +02:00
<Member MemberName= "Clone" >
2005-05-23 22:41:51 +02:00
<MemberSignature Language= "C#" Value= "public object Clone ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Object</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
<summary > To be added.</summary>
<returns > To be added.</returns>
<remarks > To be added.</remarks>
</Docs>
</Member>
2003-02-12 02:57:20 +01:00
</Members>
2005-11-19 19:56:27 +01:00
</Type>
