gtk3-0.15.10: Binding to the Gtk+ 3 graphical user interface library

Maintainer | gtk2hs-users@lists.sourceforge.net
Stability | provisional
Portability | portable (depends on GHC)
Safe Haskell | None
Language | Haskell98

Graphics.UI.Gtk.Gdk.Pixbuf

Contents

- Class Hierarchy
- Types
- Constructors
- Methods

Description

`Pixbuf`s are bitmap images in memory.

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

Synopsis

- data Pixbuf
- class GObjectClass o => PixbufClass o
- castToPixbuf :: GObjectClass obj => obj -> Pixbuf
- gTypePixbuf :: GType
- toPixbuf :: PixbufClass o => o -> Pixbuf
- data PixbufError
  - = PixbufErrorCorruptImage
  - | PixbufErrorInsufficientMemory
  - | PixbufErrorBadOption
  - | PixbufErrorUnknownType
  - | PixbufErrorUnsupportedOperation
  - | PixbufErrorFailed
  - | PixbufErrorIncompleteAnimation
- data Colorspace = ColorspaceRgb
- pixbufNew :: Colorspace -> Bool -> Int -> Int -> Int -> IO Pixbuf
- pixbufNewFromData :: Ptr CUChar -> Colorspace -> Bool -> Int -> Int -> Int -> Int -> IO Pixbuf
- pixbufNewFromFile :: GlibFilePath fp => fp -> IO Pixbuf
- pixbufNewFromFileAtSize :: GlibString string => string -> Int -> Int -> IO Pixbuf
- pixbufNewFromFileAtScale :: GlibString string => string -> Int -> Int -> Bool -> IO Pixbuf
- pixbufNewFromSurface :: Surface -> Int -> Int -> Int -> Int -> IO Pixbuf
- pixbufNewFromWindow :: DrawWindowClass self => self -> Int -> Int -> Int -> Int -> IO Pixbuf
- pixbufNewFromInline :: Ptr InlineImage -> IO Pixbuf
- data InlineImage
- pixbufNewSubpixbuf :: Pixbuf -> Int -> Int -> Int -> Int -> IO Pixbuf
- pixbufNewFromXPMData :: GlibString string => [string] -> IO Pixbuf
- pixbufGetColorSpace :: Pixbuf -> IO Colorspace
- pixbufGetNChannels :: Pixbuf -> IO Int
- pixbufGetHasAlpha :: Pixbuf -> IO Bool
- pixbufGetBitsPerSample :: Pixbuf -> IO Int
- data PixbufData i e
- pixbufGetPixels :: Storable e => Pixbuf -> IO (PixbufData Int e)
- pixbufGetWidth :: Pixbuf -> IO Int
- pixbufGetHeight :: Pixbuf -> IO Int
- pixbufGetRowstride :: Pixbuf -> IO Int
- pixbufGetOption :: GlibString string => Pixbuf -> string -> IO (Maybe string)
- type ImageFormat = DefaultGlibString
- pixbufGetFormats :: [ImageFormat]
- pixbufSave :: (GlibString string, GlibFilePath fp) => Pixbuf -> fp -> ImageFormat -> [(string, string)] -> IO ()
- pixbufCopy :: Pixbuf -> IO Pixbuf
- data InterpType
  - = InterpNearest
  - | InterpTiles
  - | InterpBilinear
  - | InterpHyper
- pixbufScaleSimple :: Pixbuf -> Int -> Int -> InterpType -> IO Pixbuf
- pixbufScale :: Pixbuf -> Pixbuf -> Int -> Int -> Int -> Int -> Double -> Double -> Double -> Double -> InterpType -> IO ()
- pixbufComposite :: Pixbuf -> Pixbuf -> Int -> Int -> Int -> Int -> Double -> Double -> Double -> Double -> InterpType -> Word8 -> IO ()
- pixbufFlipHorizontally :: Pixbuf -> IO Pixbuf
- pixbufFlipHorazontally :: Pixbuf -> IO Pixbuf
- pixbufFlipVertically :: Pixbuf -> IO Pixbuf
- pixbufRotateSimple :: Pixbuf -> PixbufRotation -> IO Pixbuf
- data PixbufRotation
  - = PixbufRotateNone
  - | PixbufRotateCounterclockwise
  - | PixbufRotateUpsidedown
  - | PixbufRotateClockwise
- pixbufAddAlpha :: Pixbuf -> Maybe (Word8, Word8, Word8) -> IO Pixbuf
- pixbufCopyArea :: Pixbuf -> Int -> Int -> Int -> Int -> Pixbuf -> Int -> Int -> IO ()
- pixbufFill :: Pixbuf -> Word8 -> Word8 -> Word8 -> Word8 -> IO ()

# Class Hierarchy

    | GObject
    | +----Pixbuf

# Types

data Pixbuf Source #

#### Instances

Instances details

Eq Pixbuf Source # |
Instance details Defined in Graphics.UI.Gtk.Types Methods (==) :: Pixbuf -> Pixbuf -> Bool Source # (/=) :: Pixbuf -> Pixbuf -> Bool Source #
Ord Pixbuf Source # |
Instance details Defined in Graphics.UI.Gtk.Types Methods compare :: Pixbuf -> Pixbuf -> Ordering Source # (<) :: Pixbuf -> Pixbuf -> Bool Source # (<=) :: Pixbuf -> Pixbuf -> Bool Source # (>) :: Pixbuf -> Pixbuf -> Bool Source # (>=) :: Pixbuf -> Pixbuf -> Bool Source # max :: Pixbuf -> Pixbuf -> Pixbuf Source # min :: Pixbuf -> Pixbuf -> Pixbuf Source #
GObjectClass Pixbuf Source # |
Instance details Defined in Graphics.UI.Gtk.Types Methods toGObject :: Pixbuf -> GObject Source # unsafeCastGObject :: GObject -> Pixbuf Source #
PixbufClass Pixbuf Source # |
Instance details Defined in Graphics.UI.Gtk.Types

class GObjectClass o => PixbufClass o Source #

#### Instances

Instances details

PixbufClass Pixbuf Source # |
Instance details Defined in Graphics.UI.Gtk.Types

castToPixbuf :: GObjectClass obj => obj -> Pixbuf Source #

gTypePixbuf :: GType Source #

toPixbuf :: PixbufClass o => o -> Pixbuf Source #

data PixbufError Source #

Error codes for loading image files.

Constructors

PixbufErrorCorruptImage |
PixbufErrorInsufficientMemory |
PixbufErrorBadOption |
PixbufErrorUnknownType |
PixbufErrorUnsupportedOperation |
PixbufErrorFailed |
PixbufErrorIncompleteAnimation |

#### Instances

Instances details

Enum PixbufError Source # |

Instance details

Defined in Graphics.UI.Gtk.Gdk.Pixbuf

Methods

succ :: PixbufError -> PixbufError Source #

pred :: PixbufError -> PixbufError Source #

toEnum :: Int -> PixbufError Source #

fromEnum :: PixbufError -> Int Source #

enumFrom :: PixbufError -> [PixbufError] Source #

enumFromThen :: PixbufError -> PixbufError -> [PixbufError] Source #

enumFromTo :: PixbufError -> PixbufError -> [PixbufError] Source #

enumFromThenTo :: PixbufError -> PixbufError -> PixbufError -> [PixbufError] Source #

GErrorClass PixbufError Source # |
Instance details Defined in Graphics.UI.Gtk.Gdk.Pixbuf Methods gerrorDomain :: PixbufError -> GErrorDomain Source #

data Colorspace Source #

Enumerate all supported color spaces.

- Only RGB is supported right now.

Constructors

ColorspaceRgb |

#### Instances

Instances details

Enum Colorspace Source # |

Instance details

Defined in Graphics.UI.Gtk.Gdk.Pixbuf

Methods

succ :: Colorspace -> Colorspace Source #

pred :: Colorspace -> Colorspace Source #

toEnum :: Int -> Colorspace Source #

fromEnum :: Colorspace -> Int Source #

enumFrom :: Colorspace -> [Colorspace] Source #

enumFromThen :: Colorspace -> Colorspace -> [Colorspace] Source #

enumFromTo :: Colorspace -> Colorspace -> [Colorspace] Source #

enumFromThenTo :: Colorspace -> Colorspace -> Colorspace -> [Colorspace] Source #

# Constructors

pixbufNew :: Colorspace -> Bool -> Int -> Int -> Int -> IO Pixbuf Source #

Create a new image in memory.

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

pixbufNewFromData :: Ptr CUChar -> Colorspace -> Bool -> Int -> Int -> Int -> Int -> IO Pixbuf Source #

pixbufNewFromFile :: GlibFilePath fp => fp -> IO Pixbuf Source #

Load an image synchonously.

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

pixbufNewFromFileAtSize :: GlibString string => string -> Int -> Int -> IO Pixbuf Source #

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

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

pixbufNewFromFileAtScale Source #

Arguments

:: GlibString string |
=> string | the name of the file
-> Int | target width
-> Int | target height
-> Bool | whether to preserve the aspect ratio
-> IO Pixbuf |

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

When preserving the aspect ratio, a width of -1 will cause the image to be scaled to the exact given height, and a height of -1 will cause the image to be scaled to the exact given width. When not preserving aspect ratio, a width or height of -1 means to not scale the image at all in that dimension. Negative values for width and height are allowed since Gtk+ 2.8.

- If an error occurs, the function will throw an exception that can be caught using e.g. `catchGErrorJust` and one of the error codes in `PixbufError`.
- Available since Gtk+ version 2.6

pixbufNewFromSurface :: Surface -> Int -> Int -> Int -> Int -> IO Pixbuf Source #

Creates a new pixbuf from a cairo Surface.

Transfers image data from a cairo Surface and converts it to an RGB(A) representation inside a Pixbuf. This allows you to efficiently read individual pixels from cairo surfaces. For GdkWindows, use gdk_pixbuf_get_from_window() instead.

This function will create an RGB pixbuf with 8 bits per channel. The pixbuf will contain an alpha channel if the surface contains one.

pixbufNewFromWindow Source #

Arguments

:: DrawWindowClass self |
=> self | `window` - The source window.
-> Int | `srcX` - Source X coordinate within window.
-> Int | `srcY` - Source Y coordinate within window.
-> Int | `width` - Width in pixels of region to get.
-> Int | `height` - Height in pixels of region to get.
-> IO Pixbuf |

Creates a new pixbuf from a GDK window.

Transfers image data from a GdkWindow and converts it to an RGB(A) representation inside a GdkPixbuf. In other words, copies image data from a server-side drawable to a client-side RGB(A) buffer. This allows you to efficiently read individual pixels on the client side.

This function will create an RGB pixbuf with 8 bits per channel with the size specified by the width and height arguments scaled by the scale factor of window. The pixbuf will contain an alpha channel if the window contains one.

pixbufNewFromInline :: Ptr InlineImage -> IO Pixbuf Source #

Create a new image from a static pointer.

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

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

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

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

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

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

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

    foreign label "my_image" myImage :: Ptr InlineImage

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

data InlineImage Source #

A dymmy type for inline picture data.

- This dummy type is used to declare pointers to image data that is embedded in the executable. See `pixbufNewFromInline` for an example.

pixbufNewSubpixbuf :: Pixbuf -> Int -> Int -> Int -> Int -> IO Pixbuf Source #

Create a restricted view of an image.

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

pixbufNewFromXPMData :: GlibString string => [string] -> IO Pixbuf Source #

Create a new image from a string.

- Creates a new pixbuf from a string description.

# Methods

pixbufGetColorSpace :: Pixbuf -> IO Colorspace Source #

Queries the color space of a pixbuf.

pixbufGetNChannels :: Pixbuf -> IO Int Source #

Queries the number of colors for each pixel.

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

pixbufGetHasAlpha :: Pixbuf -> IO Bool Source #

Query if the image has an alpha channel.

- The alpha channel determines the opaqueness of the pixel.

pixbufGetBitsPerSample :: Pixbuf -> IO Int Source #

Queries the number of bits for each color.

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

data PixbufData i e Source #

An array that stored the raw pixel data of a `Pixbuf`.

- See `pixbufGetPixels`.

#### Instances

Instances details

Storable e => MArray PixbufData e IO Source # | `PixbufData` is a mutable array.

Instance details

Defined in Graphics.UI.Gtk.Gdk.PixbufData

Methods

getBounds :: Ix i => PixbufData i e -> IO (i, i) Source #

getNumElements :: Ix i => PixbufData i e -> IO Int Source #

newArray :: Ix i => (i, i) -> e -> IO (PixbufData i e) Source #

newArray_ :: Ix i => (i, i) -> IO (PixbufData i e) Source #

unsafeNewArray_ :: Ix i => (i, i) -> IO (PixbufData i e) Source #

unsafeRead :: Ix i => PixbufData i e -> Int -> IO e Source #

unsafeWrite :: Ix i => PixbufData i e -> Int -> e -> IO () Source #

pixbufGetPixels :: Storable e => Pixbuf -> IO (PixbufData Int e) Source #

Retrieve the internal array of raw image data.

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

pixbufGetWidth :: Pixbuf -> IO Int Source #

Queries the width of this image.

pixbufGetHeight :: Pixbuf -> IO Int Source #

Queries the height of this image.

pixbufGetRowstride :: Pixbuf -> IO Int Source #

Queries the rowstride of this image.

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

pixbufGetOption :: GlibString string => Pixbuf -> string -> IO (Maybe string) Source #

Returns an attribute of an image.

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

type ImageFormat = DefaultGlibString Source #

A string representing an image file format.

pixbufGetFormats :: [ImageFormat] Source #

pixbufSave :: (GlibString string, GlibFilePath fp) => Pixbuf -> fp -> ImageFormat -> [(string, string)] -> IO () Source #

Save an image to disk.

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

pixbufCopy :: Pixbuf -> IO Pixbuf Source #

Create a deep copy of an image.

data InterpType Source #

How an image is scaled.

`InterpNearest`
  Nearest neighbor sampling; this is the fastest and lowest quality mode. Quality is normally unacceptable when scaling down, but may be OK when scaling up.
`InterpTiles`
  This is an accurate simulation of the PostScript image operator without any interpolation enabled. Each pixel is rendered as a tiny parallelogram of solid color, the edges of which are implemented with antialiasing. It resembles nearest neighbor for enlargement, and bilinear for reduction.
`InterpBilinear`
  Best quality/speed balance; use this mode by default. Bilinear interpolation. For enlargement, it is equivalent to point-sampling the ideal bilinear-interpolated image. For reduction, it is equivalent to laying down small tiles and integrating over the coverage area.
`InterpHyper`
  This is the slowest and highest quality reconstruction function. It is derived from the hyperbolic filters in Wolberg's "Digital Image Warping", and is formally defined as the hyperbolic-filter sampling the ideal hyperbolic-filter interpolated image (the filter is designed to be idempotent for 1:1 pixel mapping).

Constructors

InterpNearest |
InterpTiles |
InterpBilinear |
InterpHyper |

#### Instances

Instances details

Enum InterpType Source # |

Instance details

Defined in Graphics.UI.Gtk.Gdk.Pixbuf

Methods

succ :: InterpType -> InterpType Source #

pred :: InterpType -> InterpType Source #

toEnum :: Int -> InterpType Source #

fromEnum :: InterpType -> Int Source #

enumFrom :: InterpType -> [InterpType] Source #

enumFromThen :: InterpType -> InterpType -> [InterpType] Source #

enumFromTo :: InterpType -> InterpType -> [InterpType] Source #

enumFromThenTo :: InterpType -> InterpType -> InterpType -> [InterpType] Source #

pixbufScaleSimple Source #

Arguments

:: Pixbuf | `src` - the source image
-> Int | `width` - the target width
-> Int | `height` the target height
-> InterpType | interpolation type
-> IO Pixbuf |

Scale an image.

- Creates a new `Pixbuf` containing a copy of `src` scaled to the given measures. Leaves `src` unaffected.
- `interp` affects the quality and speed of the scaling function. `InterpNearest` is the fastest option but yields very poor quality when scaling down. `InterpBilinear` is a good trade-off between speed and quality and should thus be used as a default.

pixbufScale Source #

Arguments

:: Pixbuf | `src` - the source pixbuf
-> Pixbuf | `dest` - the pixbuf into which to render the results
-> Int | `destX` - the left coordinate for region to render
-> Int | `destY` - the top coordinate for region to render
-> Int | `destWidth` - the width of the region to render
-> Int | `destHeight` - the height of the region to render
-> Double | `offsetX` - the offset in the X direction (currently rounded to an integer)
-> Double | `offsetY` - the offset in the Y direction (currently rounded to an integer)
-> Double | `scaleX` - the scale factor in the X direction
-> Double | `scaleY` - the scale factor in the Y direction
-> InterpType | the interpolation type for the transformation.
-> IO () |

Copy a scaled image part to another image.

- This function is the generic version of `pixbufScaleSimple`. It scales `src` by `scaleX` and `scaleY` and translate the image by `offsetX` and `offsetY`. Whatever is in the intersection with the rectangle `destX`, `destY`, `destWidth`, `destHeight` will be rendered into `dest`.
- The rectangle in the destination is simply overwritten. Use `pixbufComposite` if you need to blend the source image onto the destination.

pixbufComposite Source #

Arguments

:: Pixbuf | `src` - the source pixbuf
-> Pixbuf | `dest` - the pixbuf into which to render the results
-> Int | `destX` - the left coordinate for region to render
-> Int | `destY` - the top coordinate for region to render
-> Int | `destWidth` - the width of the region to render
-> Int | `destHeight` - the height of the region to render
-> Double | `offsetX` - the offset in the X direction (currently rounded to an integer)
-> Double | `offsetY` - the offset in the Y direction (currently rounded to an integer)
-> Double | `scaleX` - the scale factor in the X direction
-> Double | `scaleY` - the scale factor in the Y direction
-> InterpType | the interpolation type for the transformation.
-> Word8 | `alpha` - the transparency
-> IO () |

Blend a scaled image part onto another image.

- This function is similar to `pixbufScale` but allows the original image to "shine through". The `alpha` value determines how opaque the source image is. Passing `0` is equivalent to not calling this function at all, passing `255` has the same effect as calling `pixbufScale`.

pixbufFlipHorizontally :: Pixbuf -> IO Pixbuf Source #

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

pixbufFlipHorazontally :: Pixbuf -> IO Pixbuf Source #

pixbufFlipVertically :: Pixbuf -> IO Pixbuf Source #

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

pixbufRotateSimple :: Pixbuf -> PixbufRotation -> IO Pixbuf Source #

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

data PixbufRotation Source #

The possible rotations which can be passed to `pixbufRotateSimple`.

To make them easier to use, their numerical values are the actual degrees.

Constructors

PixbufRotateNone |
PixbufRotateCounterclockwise |
PixbufRotateUpsidedown |
PixbufRotateClockwise |

#### Instances

Instances details

Enum PixbufRotation Source #

Add an opacity layer to the `Pixbuf`.

- This function returns a copy of the given `src` `Pixbuf`, leaving `src` unmodified. The new `Pixbuf` has an alpha (opacity) channel which defaults to `255` (fully opaque pixels) unless `src` already had an alpha channel in which case the original values are kept. Passing in a color triple `(r,g,b)` makes all pixels that have this color fully transparent (opacity of `0`). The pixel color itself remains unchanged during this substitution.

Instance details

Defined in Graphics.UI.Gtk.Gdk.Pixbuf

Methods

succ :: PixbufRotation -> PixbufRotation Source #

pred :: PixbufRotation -> PixbufRotation Source #

toEnum :: Int -> PixbufRotation Source #

fromEnum :: PixbufRotation -> Int Source #

enumFrom :: PixbufRotation -> [PixbufRotation] Source #

enumFromThen :: PixbufRotation -> PixbufRotation -> [PixbufRotation] Source #

enumFromTo :: PixbufRotation -> PixbufRotation -> [PixbufRotation] Source #

enumFromThenTo :: PixbufRotation -> PixbufRotation -> PixbufRotation -> [PixbufRotation] Source #

pixbufAddAlpha :: Pixbuf -> Maybe (Word8, Word8, Word8) -> IO Pixbuf Source #

pixbufCopyArea Source #

Arguments

:: Pixbuf | Source pixbuf
-> Int | Source X coordinate within the source pixbuf
-> Int | Source Y coordinate within the source pixbuf
-> Int | Width of the area to copy
-> Int | Height of the area to copy
-> Pixbuf | Destination pixbuf
-> Int | X coordinate within the destination pixbuf
-> Int | Y coordinate within the destination pixbuf
-> IO () |

Copy a rectangular portion into another `Pixbuf`.

The source `Pixbuf` remains unchanged. Conversion between different formats is done automatically.

pixbufFill :: Pixbuf -> Word8 -> Word8 -> Word8 -> Word8 -> IO () Source #

Fills a `Pixbuf` with a color.

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