    {-# LINE 2 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}
    {-# LANGUAGE OverloadedStrings #-}

    {-# LINE 3 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}
    {-# LANGUAGE EmptyDataDecls #-}

    {-# LINE 4 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}
    -- -*-haskell-*-
    -- GIMP Toolkit (GTK) Pixbuf
    --
    -- Author : Vincenzo Ciancia, Axel Simon
    --
    -- Created: 26 March 2002
    --
    -- Copyright (C) 2002-2005 Axel Simon, Vincenzo Ciancia
    --
    -- This library is free software; you can redistribute it and/or
    -- modify it under the terms of the GNU Lesser General Public
    -- License as published by the Free Software Foundation; either
    -- version 2.1 of the License, or (at your option) any later version.
    --
    -- This library is distributed in the hope that it will be useful,
    -- but WITHOUT ANY WARRANTY; without even the implied warranty of
    -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    -- Lesser General Public License for more details.
    --
    -- TODO
    --
    -- if anybody writes an image manipulation program, do the checker board
    -- functions: gdk_pixbuf_composite_color_simple and
    -- gdk_pixbuf_composite_color. Moreover, do: pixbuf_saturate_and_pixelate
    --
    --
    -- pixbuf loader
    --
    -- module interface
    --
    -- rendering function for Bitmaps and Pixmaps when the latter are added
    --
    -- |
    -- Maintainer : gtk2hs-users@lists.sourceforge.net
    -- Stability : provisional
    -- Portability : portable (depends on GHC)
    --
    -- '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
    -- 'Graphics.UI.Gtk.Gdk.Drawable.drawPixbuf'.
    --
    module Graphics.UI.Gtk.Gdk.Pixbuf (
    -- * Class Hierarchy
    -- |
    -- @
    -- | 'GObject'
    -- | +----Pixbuf
    -- @

    -- * Types
      Pixbuf,
      PixbufClass,
      castToPixbuf, gTypePixbuf,
      toPixbuf,
      PixbufError(..),
      Colorspace(..),

    -- * Constructors
      pixbufNew,
      pixbufNewFromData,
      pixbufNewFromFile,

      pixbufNewFromFileAtSize,

      pixbufNewFromFileAtScale,

      pixbufNewFromSurface,
      pixbufNewFromWindow,

      pixbufNewFromInline,
      InlineImage,
      pixbufNewSubpixbuf,
      pixbufNewFromXPMData,

    -- * Methods
      pixbufGetColorSpace,
      pixbufGetNChannels,
      pixbufGetHasAlpha,
      pixbufGetBitsPerSample,
      PixbufData,
      pixbufGetPixels,
      pixbufGetWidth,
      pixbufGetHeight,
      pixbufGetRowstride,
      pixbufGetOption,
      ImageFormat,
      pixbufGetFormats,
      pixbufSave,
      pixbufCopy,
      InterpType(..),
      pixbufScaleSimple,
      pixbufScale,
      pixbufComposite,

      pixbufFlipHorizontally,
      pixbufFlipHorazontally,
      pixbufFlipVertically,
      pixbufRotateSimple,
      PixbufRotation(..),

      pixbufAddAlpha,
      pixbufCopyArea,
      pixbufFill,

      ) where

    import Control.Monad (liftM)
    import System.Glib.FFI
    import System.Glib.UTFString
    import System.Glib.GObject
    import Graphics.UI.Gtk.Types
    {-# LINE 133 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}

    import System.Glib.GError (GError(..), GErrorClass(..), GErrorDomain,
                                    propagateGError)
    import Graphics.UI.Gtk.Gdk.PixbufData ( PixbufData, mkPixbufData )

    import Graphics.Rendering.Cairo
    import Graphics.Rendering.Cairo.Types

    {-# LINE 147 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}

    -- | Error codes for loading image files.
    --
    data PixbufError = PixbufErrorCorruptImage
                     | PixbufErrorInsufficientMemory
                     | PixbufErrorBadOption
                     | PixbufErrorUnknownType
                     | PixbufErrorUnsupportedOperation
                     | PixbufErrorFailed
                     | PixbufErrorIncompleteAnimation
                     deriving (Enum)

    {-# LINE 151 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}

    -- | Enumerate all supported color spaces.
    --
    -- * Only RGB is supported right now.
    --
    data Colorspace = ColorspaceRgb
                    deriving (Enum)

    {-# LINE 157 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}

    -- | Queries the color space of a pixbuf.
    --
    pixbufGetColorSpace :: Pixbuf -> IO Colorspace
    pixbufGetColorSpace :: Pixbuf -> IO Colorspace
    pixbufGetColorSpace Pixbuf
    pb = (CInt -> Colorspace) -> IO CInt -> IO Colorspace
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Int -> Colorspace
    forall a. Enum a => Int -> a
    toEnum (Int -> Colorspace) -> (CInt -> Int) -> CInt -> Colorspace
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) (IO CInt -> IO Colorspace) -> IO CInt -> IO Colorspace
    forall a b. (a -> b) -> a -> b
    $
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO CInt) -> IO CInt)
    -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> IO CInt
    gdk_pixbuf_get_colorspace Ptr Pixbuf
    argPtr1) Pixbuf
    pb

    -- | 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.
    --
    pixbufGetNChannels :: Pixbuf -> IO Int
    pixbufGetNChannels :: Pixbuf -> IO Int
    pixbufGetNChannels Pixbuf
    pb = (CInt -> Int) -> IO CInt -> IO Int
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (IO CInt -> IO Int) -> IO CInt -> IO Int
    forall a b. (a -> b) -> a -> b
    $
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO CInt) -> IO CInt)
    -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> IO CInt
    gdk_pixbuf_get_n_channels Ptr Pixbuf
    argPtr1) Pixbuf
    pb

    -- | Query if the image has an alpha channel.
    --
    -- * The alpha channel determines the opaqueness of the pixel.
    --
    pixbufGetHasAlpha :: Pixbuf -> IO Bool
    pixbufGetHasAlpha :: Pixbuf -> IO Bool
    pixbufGetHasAlpha Pixbuf
    pb =
      (CInt -> Bool) -> IO CInt -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool (IO CInt -> IO Bool) -> IO CInt -> IO Bool
    forall a b. (a -> b) -> a -> b
    $ (\(Pixbuf ForeignPtr Pixbuf
    arg1) -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO CInt) -> IO CInt)
    -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> IO CInt
    gdk_pixbuf_get_has_alpha Ptr Pixbuf
    argPtr1) Pixbuf
    pb

    -- | 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.
    --
    pixbufGetBitsPerSample :: Pixbuf -> IO Int
    pixbufGetBitsPerSample :: Pixbuf -> IO Int
    pixbufGetBitsPerSample Pixbuf
    pb = (CInt -> Int) -> IO CInt -> IO Int
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (IO CInt -> IO Int) -> IO CInt -> IO Int
    forall a b. (a -> b) -> a -> b
    $
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO CInt) -> IO CInt)
    -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> IO CInt
    gdk_pixbuf_get_bits_per_sample Ptr Pixbuf
    argPtr1) Pixbuf
    pb

    -- | 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.
    --
    pixbufGetPixels :: Storable e => Pixbuf -> IO (PixbufData Int e)
    pixbufGetPixels :: forall e. Storable e => Pixbuf -> IO (PixbufData Int e)
    pixbufGetPixels Pixbuf
    pb = do
      pixPtr_ <- (\(Pixbuf ForeignPtr Pixbuf
    arg1) -> ForeignPtr Pixbuf
    -> (Ptr Pixbuf -> IO (Ptr CUChar)) -> IO (Ptr CUChar)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO (Ptr CUChar)) -> IO (Ptr CUChar))
    -> (Ptr Pixbuf -> IO (Ptr CUChar)) -> IO (Ptr CUChar)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> IO (Ptr CUChar)
    gdk_pixbuf_get_pixels Ptr Pixbuf
    argPtr1) Pixbuf
    pb
      chan <- pixbufGetNChannels pb
      bits <- pixbufGetBitsPerSample pb
      w <- pixbufGetWidth pb
      h <- pixbufGetHeight pb
      r <- pixbufGetRowstride pb
      let pixPtr = Ptr CUChar -> Ptr b
    forall a b. Ptr a -> Ptr b
    castPtr Ptr CUChar
    pixPtr_
      let bytes = (Int
    hInt -> Int -> Int
    forall a. Num a => a -> a -> a
    -Int
    1)Int -> Int -> Int
    forall a. Num a => a -> a -> a
    *Int
    rInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    wInt -> Int -> Int
    forall a. Num a => a -> a -> a
    *((Int
    chanInt -> Int -> Int
    forall a. Num a => a -> a -> a
    *Int
    bitsInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    7) Int -> Int -> Int
    forall a. Integral a => a -> a -> a
    `div` Int
    8)
      return (mkPixbufData pb pixPtr bytes)

    -- | Queries the width of this image.
    --
    pixbufGetWidth :: Pixbuf -> IO Int
    pixbufGetWidth :: Pixbuf -> IO Int
    pixbufGetWidth Pixbuf
    pb = (CInt -> Int) -> IO CInt -> IO Int
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (IO CInt -> IO Int) -> IO CInt -> IO Int
    forall a b. (a -> b) -> a -> b
    $
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO CInt) -> IO CInt)
    -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> IO CInt
    gdk_pixbuf_get_width Ptr Pixbuf
    argPtr1) Pixbuf
    pb

    -- | Queries the height of this image.
    --
    pixbufGetHeight :: Pixbuf -> IO Int
    pixbufGetHeight :: Pixbuf -> IO Int
    pixbufGetHeight Pixbuf
    pb = (CInt -> Int) -> IO CInt -> IO Int
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (IO CInt -> IO Int) -> IO CInt -> IO Int
    forall a b. (a -> b) -> a -> b
    $
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO CInt) -> IO CInt)
    -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> IO CInt
    gdk_pixbuf_get_height Ptr Pixbuf
    argPtr1) Pixbuf
    pb

    -- | 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.
    --
    pixbufGetRowstride :: Pixbuf -> IO Int
    pixbufGetRowstride :: Pixbuf -> IO Int
    pixbufGetRowstride Pixbuf
    pb = (CInt -> Int) -> IO CInt -> IO Int
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (IO CInt -> IO Int) -> IO CInt -> IO Int
    forall a b. (a -> b) -> a -> b
    $
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO CInt) -> IO CInt)
    -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> IO CInt
    gdk_pixbuf_get_rowstride Ptr Pixbuf
    argPtr1) Pixbuf
    pb

    -- | Returns an attribute of an image.
    --
    -- * Looks up if some information was stored under the @key@ when
    -- this image was saved.
    --
    pixbufGetOption :: (GlibString string) => Pixbuf -> string -> IO (Maybe string)
    pixbufGetOption :: forall string.
    GlibString string =>
    Pixbuf -> string -> IO (Maybe string)
    pixbufGetOption Pixbuf
    pb string
    key = string -> (Ptr CChar -> IO (Maybe string)) -> IO (Maybe string)
    forall a. string -> (Ptr CChar -> IO a) -> IO a
    forall s a. GlibString s => s -> (Ptr CChar -> IO a) -> IO a
    withUTFString string
    key ((Ptr CChar -> IO (Maybe string)) -> IO (Maybe string))
    -> (Ptr CChar -> IO (Maybe string)) -> IO (Maybe string)
    forall a b. (a -> b) -> a -> b
    $ \Ptr CChar
    strPtr -> do
      resPtr <- (\(Pixbuf ForeignPtr Pixbuf
    arg1) Ptr CChar
    arg2 -> ForeignPtr Pixbuf
    -> (Ptr Pixbuf -> IO (Ptr CChar)) -> IO (Ptr CChar)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO (Ptr CChar)) -> IO (Ptr CChar))
    -> (Ptr Pixbuf -> IO (Ptr CChar)) -> IO (Ptr CChar)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> Ptr CChar -> IO (Ptr CChar)
    gdk_pixbuf_get_option Ptr Pixbuf
    argPtr1 Ptr CChar
    arg2) Pixbuf
    pb Ptr CChar
    strPtr
      if (resPtr==nullPtr) then return Nothing else
        liftM Just $ peekUTFString resPtr

    -- helper functions
    pixbufErrorDomain :: GErrorDomain
    pixbufErrorDomain :: CUInt
    pixbufErrorDomain = CUInt
    gdk_pixbuf_error_quark
    {-# LINE 268 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}

    instance GErrorClass PixbufError where
      gerrorDomain :: PixbufError -> CUInt
    gerrorDomain PixbufError
    _ = CUInt
    pixbufErrorDomain

    -- | Load an image synchonously.
    --
    -- * Use this function to load only small images as this call will block.
    --
    -- * If an error occurs, the function will throw an exception that can
    -- be caught using e.g. 'System.Glib.GError.catchGErrorJust' and one of the
    -- error codes in 'PixbufError'.
    --
    pixbufNewFromFile :: GlibFilePath fp => fp -> IO Pixbuf
    pixbufNewFromFile :: forall fp. GlibFilePath fp => fp -> IO Pixbuf
    pixbufNewFromFile fp
    fname =
      (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $
      (Ptr (Ptr ()) -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a. (Ptr (Ptr ()) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr ()) -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr (Ptr ()) -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr (Ptr ())
    errPtrPtr ->
         fp -> (Ptr CChar -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a. fp -> (Ptr CChar -> IO a) -> IO a
    forall fp a. GlibFilePath fp => fp -> (Ptr CChar -> IO a) -> IO a
    withUTFFilePath fp
    fname ((Ptr CChar -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr CChar -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr CChar
    strPtr ->

         Ptr CChar -> Ptr (Ptr ()) -> IO (Ptr Pixbuf)
    gdk_pixbuf_new_from_file
    {-# LINE 290 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}

        Ptr CChar
    strPtr Ptr (Ptr ())
    errPtrPtr

    -- | Creates a new pixbuf by loading an image from a file. The file format is
    -- detected automatically. The image will be scaled to fit in the requested
    -- size, preserving the image's aspect ratio.
    --
    -- * If an error occurs, the function will throw an exception that can
    -- be caught using e.g. 'System.Glib.GError.catchGErrorJust' and one of the
    -- error codes in 'PixbufError'.
    --
    -- * Available since Gtk+ version 2.4
    --
    pixbufNewFromFileAtSize :: GlibString string => string -> Int -> Int -> IO Pixbuf
    pixbufNewFromFileAtSize :: forall string.
    GlibString string =>
    string -> Int -> Int -> IO Pixbuf
    pixbufNewFromFileAtSize string
    filename Int
    width Int
    height =
      (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $
      (Ptr (Ptr ()) -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a. (Ptr (Ptr ()) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr ()) -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr (Ptr ()) -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr (Ptr ())
    errPtrPtr ->
        string -> (Ptr CChar -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a. string -> (Ptr CChar -> IO a) -> IO a
    forall s a. GlibString s => s -> (Ptr CChar -> IO a) -> IO a
    withUTFString string
    filename ((Ptr CChar -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr CChar -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr CChar
    filenamePtr ->

        Ptr CChar -> CInt -> CInt -> Ptr (Ptr ()) -> IO (Ptr Pixbuf)
    gdk_pixbuf_new_from_file_at_size
    {-# LINE 313 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}

        Ptr CChar
    filenamePtr
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    width)
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    height)
        Ptr (Ptr ())
    errPtrPtr

    -- | 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. 'System.Glib.GError.catchGErrorJust' and one of the
    -- error codes in 'PixbufError'.
    --
    -- * Available since Gtk+ version 2.6
    --
    pixbufNewFromFileAtScale :: GlibString string
      => string -- ^ the name of the file
      -> Int -- ^ target width
      -> Int -- ^ target height
      -> Bool -- ^ whether to preserve the aspect ratio
      -> IO Pixbuf
    pixbufNewFromFileAtScale :: forall string.
    GlibString string =>
    string -> Int -> Int -> Bool -> IO Pixbuf
    pixbufNewFromFileAtScale string
    filename Int
    width Int
    height Bool
    preserveAspectRatio =
      (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $
      (Ptr (Ptr ()) -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a. (Ptr (Ptr ()) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr ()) -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr (Ptr ()) -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr (Ptr ())
    errPtrPtr ->
        string -> (Ptr CChar -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a. string -> (Ptr CChar -> IO a) -> IO a
    forall s a. GlibString s => s -> (Ptr CChar -> IO a) -> IO a
    withUTFString string
    filename ((Ptr CChar -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr CChar -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr CChar
    filenamePtr ->

        Ptr CChar
    -> CInt -> CInt -> CInt -> Ptr (Ptr ()) -> IO (Ptr Pixbuf)
    gdk_pixbuf_new_from_file_at_scale
    {-# LINE 351 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}

        Ptr CChar
    filenamePtr
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    width)
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    height)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    preserveAspectRatio)
        Ptr (Ptr ())
    errPtrPtr

    -- | 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.
    pixbufNewFromSurface :: Surface -> Int -> Int -> Int -> Int -> IO Pixbuf
    pixbufNewFromSurface :: Surface -> Int -> Int -> Int -> Int -> IO Pixbuf
    pixbufNewFromSurface Surface
    surface Int
    srcX Int
    srcY Int
    width Int
    height =
      Surface -> (Ptr Surface -> IO Pixbuf) -> IO Pixbuf
    forall {b}. Surface -> (Ptr Surface -> IO b) -> IO b
    withSurface Surface
    surface ((Ptr Surface -> IO Pixbuf) -> IO Pixbuf)
    -> (Ptr Surface -> IO Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $ \Ptr Surface
    ss -> (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $
        Ptr () -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Pixbuf)
    gdk_pixbuf_get_from_surface
    {-# LINE 369 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}
        (castPtr ss)
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    srcX)
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    srcY)
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    width)
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    height)

    -- | 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.
    pixbufNewFromWindow :: 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
    pixbufNewFromWindow :: forall self.
    DrawWindowClass self =>
    self -> Int -> Int -> Int -> Int -> IO Pixbuf
    pixbufNewFromWindow self
    window Int
    srcX Int
    srcY Int
    width Int
    height =
      (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $
        (\(DrawWindow ForeignPtr DrawWindow
    arg1) CInt
    arg2 CInt
    arg3 CInt
    arg4 CInt
    arg5 -> ForeignPtr DrawWindow
    -> (Ptr DrawWindow -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr DrawWindow
    arg1 ((Ptr DrawWindow -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr DrawWindow -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr DrawWindow
    argPtr1 ->Ptr DrawWindow -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Pixbuf)
    gdk_pixbuf_get_from_window Ptr DrawWindow
    argPtr1 CInt
    arg2 CInt
    arg3 CInt
    arg4 CInt
    arg5)
    {-# LINE 390 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}
          (toDrawWindow window)
          (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    srcX)
          (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    srcY)
          (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    width)
          (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    height)

    -- | A string representing an image file format.
    --
    type ImageFormat = DefaultGlibString

    -- constant pixbufGetFormats A list of valid image file formats.
    --
    pixbufGetFormats :: [ImageFormat]

    pixbufGetFormats :: [ImageFormat]
    pixbufGetFormats = [ImageFormat
    "png",ImageFormat
    "bmp",ImageFormat
    "wbmp", ImageFormat
    "gif",ImageFormat
    "ico",ImageFormat
    "ani",ImageFormat
    "jpeg",ImageFormat
    "pnm",
                        ImageFormat
    "ras",ImageFormat
    "tiff",ImageFormat
    "xpm",ImageFormat
    "xbm",ImageFormat
    "tga"]

    -- | Save an image to disk.
    --
    -- * The function takes a list of key - value pairs to specify
    -- either how an image is saved or to actually save this additional
    -- data with the image. JPEG images can be saved with a \"quality\"
    -- parameter; its value should be in the range [0,100]. Text chunks
    -- can be attached to PNG images by specifying parameters of the form
    -- \"tEXt::key\", where key is an ASCII string of length 1-79.
    -- The values are Unicode strings.
    --
    -- * If an error occurs, the function will throw an exception that can
    -- be caught using e.g. 'System.Glib.GError.catchGErrorJust' and one of the
    -- error codes in 'PixbufError'.
    --
    pixbufSave :: (GlibString string, GlibFilePath fp) => Pixbuf -> fp -> ImageFormat -> [(string, string)] ->
                  IO ()
    pixbufSave :: forall string fp.
    (GlibString string, GlibFilePath fp) =>
    Pixbuf -> fp -> ImageFormat -> [(string, string)] -> IO ()
    pixbufSave Pixbuf
    pb fp
    fname ImageFormat
    iType [(string, string)]
    options =
      let ([string]
    keys, [string]
    values) = [(string, string)] -> ([string], [string])
    forall a b. [(a, b)] -> ([a], [b])
    unzip [(string, string)]
    options in
      (Ptr (Ptr ()) -> IO ()) -> IO ()
    forall a. (Ptr (Ptr ()) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr ()) -> IO ()) -> IO ())
    -> (Ptr (Ptr ()) -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr (Ptr ())
    errPtrPtr ->
        fp -> (Ptr CChar -> IO ()) -> IO ()
    forall a. fp -> (Ptr CChar -> IO a) -> IO a
    forall fp a. GlibFilePath fp => fp -> (Ptr CChar -> IO a) -> IO a
    withUTFFilePath fp
    fname ((Ptr CChar -> IO ()) -> IO ()) -> (Ptr CChar -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr CChar
    fnPtr ->
        ImageFormat -> (Ptr CChar -> IO ()) -> IO ()
    forall s a. GlibString s => s -> (Ptr CChar -> IO a) -> IO a
    forall a. ImageFormat -> (Ptr CChar -> IO a) -> IO a
    withUTFString ImageFormat
    iType ((Ptr CChar -> IO ()) -> IO ()) -> (Ptr CChar -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr CChar
    tyPtr ->
        [string] -> (Ptr (Ptr CChar) -> IO ()) -> IO ()
    forall s a.
    GlibString s =>
    [s] -> (Ptr (Ptr CChar) -> IO a) -> IO a
    withUTFStringArray0 [string]
    keys ((Ptr (Ptr CChar) -> IO ()) -> IO ())
    -> (Ptr (Ptr CChar) -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr (Ptr CChar)
    keysPtr ->
        [string] -> (Ptr (Ptr CChar) -> IO ()) -> IO ()
    forall s a.
    GlibString s =>
    [s] -> (Ptr (Ptr CChar) -> IO a) -> IO a
    withUTFStringArray [string]
    values ((Ptr (Ptr CChar) -> IO ()) -> IO ())
    -> (Ptr (Ptr CChar) -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr (Ptr CChar)
    valuesPtr -> do

          (\(Pixbuf ForeignPtr Pixbuf
    arg1) Ptr CChar
    arg2 Ptr CChar
    arg3 Ptr (Ptr CChar)
    arg4 Ptr (Ptr CChar)
    arg5 Ptr (Ptr ())
    arg6 -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO CInt) -> IO CInt)
    -> (Ptr Pixbuf -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf
    -> Ptr CChar
    -> Ptr CChar
    -> Ptr (Ptr CChar)
    -> Ptr (Ptr CChar)
    -> Ptr (Ptr ())
    -> IO CInt
    gdk_pixbuf_savev Ptr Pixbuf
    argPtr1 Ptr CChar
    arg2 Ptr CChar
    arg3 Ptr (Ptr CChar)
    arg4 Ptr (Ptr CChar)
    arg5 Ptr (Ptr ())
    arg6)
    {-# LINE 435 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}

            Pixbuf
    pb Ptr CChar
    fnPtr Ptr CChar
    tyPtr Ptr (Ptr CChar)
    keysPtr Ptr (Ptr CChar)
    valuesPtr Ptr (Ptr ())
    errPtrPtr
          () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    -- | 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.
    --
    pixbufNew :: Colorspace -> Bool -> Int -> Int -> Int -> IO Pixbuf
    pixbufNew :: Colorspace -> Bool -> Int -> Int -> Int -> IO Pixbuf
    pixbufNew Colorspace
    colorspace Bool
    hasAlpha Int
    bitsPerSample Int
    width Int
    height =
      (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $
        CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Pixbuf)
    gdk_pixbuf_new ((Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (Colorspace -> Int) -> Colorspace -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Colorspace -> Int
    forall a. Enum a => a -> Int
    fromEnum) Colorspace
    colorspace)
          (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    hasAlpha) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    bitsPerSample) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    width)
          (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    height)

    pixbufNewFromData :: Ptr CUChar -> Colorspace -> Bool -> Int -> Int -> Int -> Int -> IO Pixbuf
    pixbufNewFromData :: Ptr CUChar
    -> Colorspace -> Bool -> Int -> Int -> Int -> Int -> IO Pixbuf
    pixbufNewFromData Ptr CUChar
    imData Colorspace
    cSpace Bool
    hasAlpha Int
    bitsPerSample Int
    width Int
    height Int
    rowStride
      = (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $
         Ptr CUChar
    -> CInt
    -> CInt
    -> CInt
    -> CInt
    -> CInt
    -> CInt
    -> FunPtr (Ptr CUChar -> Ptr () -> IO ())
    -> Ptr ()
    -> IO (Ptr Pixbuf)
    gdk_pixbuf_new_from_data
    {-# LINE 460 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}
           imData
           (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (Colorspace -> Int) -> Colorspace -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Colorspace -> Int
    forall a. Enum a => a -> Int
    fromEnum (Colorspace -> CInt) -> Colorspace -> CInt
    forall a b. (a -> b) -> a -> b
    $ Colorspace
    cSpace)
           (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    hasAlpha)
           (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    bitsPerSample)
           (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    width)
           (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    height)
           (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    rowStride)
           FunPtr (Ptr CUChar -> Ptr () -> IO ())
    forall a. FunPtr a
    nullFunPtr Ptr ()
    forall {b}. Ptr b
    nullPtr

    -- | Create a new image from a string.
    --
    -- * Creates a new pixbuf from a string description.
    --
    pixbufNewFromXPMData :: GlibString string => [string] -> IO Pixbuf
    pixbufNewFromXPMData :: forall string. GlibString string => [string] -> IO Pixbuf
    pixbufNewFromXPMData [string]
    s =
      [string] -> (Ptr (Ptr CChar) -> IO Pixbuf) -> IO Pixbuf
    forall s a.
    GlibString s =>
    [s] -> (Ptr (Ptr CChar) -> IO a) -> IO a
    withUTFStringArray0 [string]
    s ((Ptr (Ptr CChar) -> IO Pixbuf) -> IO Pixbuf)
    -> (Ptr (Ptr CChar) -> IO Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $ \Ptr (Ptr CChar)
    strsPtr ->
        (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $ Ptr (Ptr CChar) -> IO (Ptr Pixbuf)
    gdk_pixbuf_new_from_xpm_data Ptr (Ptr CChar)
    strsPtr

    -- | 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.
    --
    data InlineImage

    -- | 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.
    --
    --
    pixbufNewFromInline :: Ptr InlineImage -> IO Pixbuf
    pixbufNewFromInline :: Ptr InlineImage -> IO Pixbuf
    pixbufNewFromInline Ptr InlineImage
    iPtr = (Ptr (Ptr GError) -> IO Pixbuf) -> IO Pixbuf
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr (Ptr GError) -> IO Pixbuf) -> IO Pixbuf)
    -> (Ptr (Ptr GError) -> IO Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $ \Ptr (Ptr GError)
    errPtrPtr -> do
      pbPtr <- CInt -> Ptr CUChar -> CInt -> Ptr (Ptr ()) -> IO (Ptr Pixbuf)
    gdk_pixbuf_new_from_inline (-CInt
    1) (Ptr InlineImage -> Ptr CUChar
    forall a b. Ptr a -> Ptr b
    castPtr Ptr InlineImage
    iPtr)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    False) (Ptr (Ptr GError) -> Ptr (Ptr ())
    forall a b. Ptr a -> Ptr b
    castPtr Ptr (Ptr GError)
    errPtrPtr)
      if pbPtr/=nullPtr then wrapNewGObject mkPixbuf (return pbPtr)
        else do
          errPtr <- peek errPtrPtr
          (GError dom code msg) <- peek errPtr
          error $ glibToString msg

    -- | 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.
    --
    pixbufNewSubpixbuf :: Pixbuf -> Int -> Int -> Int -> Int -> IO Pixbuf
    pixbufNewSubpixbuf :: Pixbuf -> Int -> Int -> Int -> Int -> IO Pixbuf
    pixbufNewSubpixbuf Pixbuf
    pb Int
    srcX Int
    srcY Int
    height Int
    width =
      (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $ do
        pbPtr <- (\(Pixbuf ForeignPtr Pixbuf
    arg1) CInt
    arg2 CInt
    arg3 CInt
    arg4 CInt
    arg5 -> ForeignPtr Pixbuf
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Pixbuf)
    gdk_pixbuf_new_subpixbuf Ptr Pixbuf
    argPtr1 CInt
    arg2 CInt
    arg3 CInt
    arg4 CInt
    arg5) Pixbuf
    pb
          (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    srcX) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    srcY)
          (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    height) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    width)
        if pbPtr==nullPtr then error "pixbufNewSubpixbuf: invalid bounds"
          else return pbPtr

    -- | Create a deep copy of an image.
    --
    pixbufCopy :: Pixbuf -> IO Pixbuf
    pixbufCopy :: Pixbuf -> IO Pixbuf
    pixbufCopy Pixbuf
    pb = (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $ (\(Pixbuf ForeignPtr Pixbuf
    arg1) -> ForeignPtr Pixbuf
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> IO (Ptr Pixbuf)
    gdk_pixbuf_copy Ptr Pixbuf
    argPtr1) Pixbuf
    pb

    -- | 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).
    --
    data InterpType = InterpNearest
                    | InterpTiles
                    | InterpBilinear
                    | InterpHyper
                    deriving (Int -> InterpType
    InterpType -> Int
    InterpType -> [InterpType]
    InterpType -> InterpType
    InterpType -> InterpType -> [InterpType]
    InterpType -> InterpType -> InterpType -> [InterpType]
    (InterpType -> InterpType)
    -> (InterpType -> InterpType)
    -> (Int -> InterpType)
    -> (InterpType -> Int)
    -> (InterpType -> [InterpType])
    -> (InterpType -> InterpType -> [InterpType])
    -> (InterpType -> InterpType -> [InterpType])
    -> (InterpType -> InterpType -> InterpType -> [InterpType])
    -> Enum InterpType
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: InterpType -> InterpType
    succ :: InterpType -> InterpType
    $cpred :: InterpType -> InterpType
    pred :: InterpType -> InterpType
    $ctoEnum :: Int -> InterpType
    toEnum :: Int -> InterpType
    $cfromEnum :: InterpType -> Int
    fromEnum :: InterpType -> Int
    $cenumFrom :: InterpType -> [InterpType]
    enumFrom :: InterpType -> [InterpType]
    $cenumFromThen :: InterpType -> InterpType -> [InterpType]
    enumFromThen :: InterpType -> InterpType -> [InterpType]
    $cenumFromTo :: InterpType -> InterpType -> [InterpType]
    enumFromTo :: InterpType -> InterpType -> [InterpType]
    $cenumFromThenTo :: InterpType -> InterpType -> InterpType -> [InterpType]
    enumFromThenTo :: InterpType -> InterpType -> InterpType -> [InterpType]
    Enum)

    {-# LINE 579 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}

    -- | 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.
    --
    pixbufScaleSimple ::
      Pixbuf -- ^ @src@ - the source image
      -> Int -- ^ @width@ - the target width
      -> Int -- ^ @height@ the target height
      -> InterpType -- ^ interpolation type
      -> IO Pixbuf
    pixbufScaleSimple :: Pixbuf -> Int -> Int -> InterpType -> IO Pixbuf
    pixbufScaleSimple Pixbuf
    pb Int
    width Int
    height InterpType
    interp =
        (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $ (Ptr Pixbuf -> Ptr Pixbuf) -> IO (Ptr Pixbuf) -> IO (Ptr Pixbuf)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Ptr Pixbuf -> Ptr Pixbuf
    forall a b. Ptr a -> Ptr b
    castPtr (IO (Ptr Pixbuf) -> IO (Ptr Pixbuf))
    -> IO (Ptr Pixbuf) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $
            (\(Pixbuf ForeignPtr Pixbuf
    arg1) CInt
    arg2 CInt
    arg3 CInt
    arg4 -> ForeignPtr Pixbuf
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> CInt -> CInt -> CInt -> IO (Ptr Pixbuf)
    gdk_pixbuf_scale_simple Ptr Pixbuf
    argPtr1 CInt
    arg2 CInt
    arg3 CInt
    arg4) (Pixbuf -> Pixbuf
    forall o. PixbufClass o => o -> Pixbuf
    toPixbuf Pixbuf
    pb)
            (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    width) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    height)
            (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> Int -> CInt
    forall a b. (a -> b) -> a -> b
    $ InterpType -> Int
    forall a. Enum a => a -> Int
    fromEnum InterpType
    interp)

    -- | 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.
    --
    pixbufScale ::
        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 ()
    pixbufScale :: Pixbuf
    -> Pixbuf
    -> Int
    -> Int
    -> Int
    -> Int
    -> Double
    -> Double
    -> Double
    -> Double
    -> InterpType
    -> IO ()
    pixbufScale Pixbuf
    src Pixbuf
    dest Int
    destX Int
    destY Int
    destWidth Int
    destHeight Double
    offsetX Double
    offsetY
      Double
    scaleX Double
    scaleY InterpType
    interp =
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) (Pixbuf ForeignPtr Pixbuf
    arg2) CInt
    arg3 CInt
    arg4 CInt
    arg5 CInt
    arg6 CDouble
    arg7 CDouble
    arg8 CDouble
    arg9 CDouble
    arg10 CInt
    arg11 -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO ()) -> IO ()) -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg2 ((Ptr Pixbuf -> IO ()) -> IO ()) -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr2 ->Ptr Pixbuf
    -> Ptr Pixbuf
    -> CInt
    -> CInt
    -> CInt
    -> CInt
    -> CDouble
    -> CDouble
    -> CDouble
    -> CDouble
    -> CInt
    -> IO ()
    gdk_pixbuf_scale Ptr Pixbuf
    argPtr1 Ptr Pixbuf
    argPtr2 CInt
    arg3 CInt
    arg4 CInt
    arg5 CInt
    arg6 CDouble
    arg7 CDouble
    arg8 CDouble
    arg9 CDouble
    arg10 CInt
    arg11) Pixbuf
    src Pixbuf
    dest
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    destX) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    destY)
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    destWidth) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    destHeight)
        (Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    offsetX) (Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    offsetY)
        (Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    scaleX) (Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    scaleY)
        ((Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (InterpType -> Int) -> InterpType -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . InterpType -> Int
    forall a. Enum a => a -> Int
    fromEnum) InterpType
    interp)

    -- | 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'.
    --
    pixbufComposite ::
         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 ()
    pixbufComposite :: Pixbuf
    -> Pixbuf
    -> Int
    -> Int
    -> Int
    -> Int
    -> Double
    -> Double
    -> Double
    -> Double
    -> InterpType
    -> Word8
    -> IO ()
    pixbufComposite Pixbuf
    src Pixbuf
    dest Int
    destX Int
    destY Int
    destWidth Int
    destHeight
      Double
    offsetX Double
    offsetY Double
    scaleX Double
    scaleY InterpType
    interp Word8
    alpha =
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) (Pixbuf ForeignPtr Pixbuf
    arg2) CInt
    arg3 CInt
    arg4 CInt
    arg5 CInt
    arg6 CDouble
    arg7 CDouble
    arg8 CDouble
    arg9 CDouble
    arg10 CInt
    arg11 CInt
    arg12 -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO ()) -> IO ()) -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg2 ((Ptr Pixbuf -> IO ()) -> IO ()) -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr2 ->Ptr Pixbuf
    -> Ptr Pixbuf
    -> CInt
    -> CInt
    -> CInt
    -> CInt
    -> CDouble
    -> CDouble
    -> CDouble
    -> CDouble
    -> CInt
    -> CInt
    -> IO ()
    gdk_pixbuf_composite Ptr Pixbuf
    argPtr1 Ptr Pixbuf
    argPtr2 CInt
    arg3 CInt
    arg4 CInt
    arg5 CInt
    arg6 CDouble
    arg7 CDouble
    arg8 CDouble
    arg9 CDouble
    arg10 CInt
    arg11 CInt
    arg12) Pixbuf
    src Pixbuf
    dest
      (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    destX) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    destY) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    destWidth)
      (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    destHeight) (Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    offsetX) (Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    offsetY)
      (Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    scaleX) (Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    scaleY)
      ((Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (InterpType -> Int) -> InterpType -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . InterpType -> Int
    forall a. Enum a => a -> Int
    fromEnum) InterpType
    interp) (Word8 -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    alpha)

    -- | Flips a pixbuf horizontally and returns the result in a new pixbuf.
    --
    pixbufFlipHorizontally :: Pixbuf -> IO Pixbuf
    pixbufFlipHorizontally :: Pixbuf -> IO Pixbuf
    pixbufFlipHorizontally Pixbuf
    self =
      (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) CInt
    arg2 -> ForeignPtr Pixbuf
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> CInt -> IO (Ptr Pixbuf)
    gdk_pixbuf_flip Ptr Pixbuf
    argPtr1 CInt
    arg2)
    {-# LINE 678 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}
        self
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    True)
    pixbufFlipHorazontally :: Pixbuf -> IO Pixbuf
    pixbufFlipHorazontally = Pixbuf -> IO Pixbuf
    pixbufFlipHorizontally

    -- | Flips a pixbuf vertically and returns the result in a new pixbuf.
    --
    pixbufFlipVertically :: Pixbuf -> IO Pixbuf
    pixbufFlipVertically :: Pixbuf -> IO Pixbuf
    pixbufFlipVertically Pixbuf
    self =
      (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) CInt
    arg2 -> ForeignPtr Pixbuf
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> CInt -> IO (Ptr Pixbuf)
    gdk_pixbuf_flip Ptr Pixbuf
    argPtr1 CInt
    arg2)
    {-# LINE 688 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}
        self
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    False)

    -- | Rotates a pixbuf by a multiple of 90 degrees, and returns the result in a
    -- new pixbuf.
    --
    pixbufRotateSimple :: Pixbuf -> PixbufRotation -> IO Pixbuf
    pixbufRotateSimple :: Pixbuf -> PixbufRotation -> IO Pixbuf
    pixbufRotateSimple Pixbuf
    self PixbufRotation
    angle =
      (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    wrapNewGObject (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr Pixbuf)
    forall {a}. (ForeignPtr Pixbuf -> Pixbuf, FinalizerPtr a)
    mkPixbuf (IO (Ptr Pixbuf) -> IO Pixbuf) -> IO (Ptr Pixbuf) -> IO Pixbuf
    forall a b. (a -> b) -> a -> b
    $
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) CInt
    arg2 -> ForeignPtr Pixbuf
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf))
    -> (Ptr Pixbuf -> IO (Ptr Pixbuf)) -> IO (Ptr Pixbuf)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> CInt -> IO (Ptr Pixbuf)
    gdk_pixbuf_rotate_simple Ptr Pixbuf
    argPtr1 CInt
    arg2)
    {-# LINE 698 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}
        self
        ((Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (PixbufRotation -> Int) -> PixbufRotation -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PixbufRotation -> Int
    forall a. Enum a => a -> Int
    fromEnum) PixbufRotation
    angle)

    -- | The possible rotations which can be passed to 'pixbufRotateSimple'.
    --
    -- To make them easier to use, their numerical values are the actual degrees.
    --
    data PixbufRotation = PixbufRotateNone
                        | PixbufRotateCounterclockwise
                        | PixbufRotateUpsidedown
                        | PixbufRotateClockwise

    instance Enum PixbufRotation where
      fromEnum :: PixbufRotation -> Int
    fromEnum PixbufRotation
    PixbufRotateNone = Int
    0
      fromEnum PixbufRotation
    PixbufRotateCounterclockwise = Int
    90
      fromEnum PixbufRotation
    PixbufRotateUpsidedown = Int
    180
      fromEnum PixbufRotation
    PixbufRotateClockwise = Int
    270

      toEnum :: Int -> PixbufRotation
    toEnum Int
    0 = PixbufRotation
    PixbufRotateNone
      toEnum Int
    90 = PixbufRotation
    PixbufRotateCounterclockwise
      toEnum Int
    180 = PixbufRotation
    PixbufRotateUpsidedown
      toEnum Int
    270 = PixbufRotation
    PixbufRotateClockwise
      toEnum Int
    unmatched = [Char] -> PixbufRotation
    forall a. HasCallStack => [Char] -> a
    error ([Char]
    "PixbufRotation.toEnum: Cannot match " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Int -> [Char]
    forall a. Show a => a -> [Char]
    show Int
    unmatched)

      succ PixbufRotateNone = PixbufRotateCounterclockwise
      succ PixbufRotateCounterclockwise = PixbufRotateUpsidedown
      succ PixbufRotateUpsidedown = PixbufRotateClockwise
      succ _ = undefined

      pred :: PixbufRotation -> PixbufRotation
    pred PixbufRotation
    PixbufRotateCounterclockwise = PixbufRotation
    PixbufRotateNone
      pred PixbufRotation
    PixbufRotateUpsidedown = PixbufRotation
    PixbufRotateCounterclockwise
      pred PixbufRotation
    PixbufRotateClockwise = PixbufRotation
    PixbufRotateUpsidedown
      pred PixbufRotation
    _ = PixbufRotation
    forall a. HasCallStack => a
    undefined

      enumFromTo :: PixbufRotation -> PixbufRotation -> [PixbufRotation]
    enumFromTo PixbufRotation
    x PixbufRotation
    y | PixbufRotation -> Int
    forall a. Enum a => a -> Int
    fromEnum PixbufRotation
    x Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == PixbufRotation -> Int
    forall a. Enum a => a -> Int
    fromEnum PixbufRotation
    y = [ PixbufRotation
    y ]
                     | Bool
    otherwise = PixbufRotation
    x PixbufRotation -> [PixbufRotation] -> [PixbufRotation]
    forall a. a -> [a] -> [a]
    : PixbufRotation -> PixbufRotation -> [PixbufRotation]
    forall a. Enum a => a -> a -> [a]
    enumFromTo (PixbufRotation -> PixbufRotation
    forall a. Enum a => a -> a
    succ PixbufRotation
    x) PixbufRotation
    y
      enumFrom :: PixbufRotation -> [PixbufRotation]
    enumFrom PixbufRotation
    x = PixbufRotation -> PixbufRotation -> [PixbufRotation]
    forall a. Enum a => a -> a -> [a]
    enumFromTo PixbufRotation
    x PixbufRotation
    PixbufRotateClockwise
      enumFromThen :: PixbufRotation -> PixbufRotation -> [PixbufRotation]
    enumFromThen PixbufRotation
    _ PixbufRotation
    _ =     [Char] -> [PixbufRotation]
    forall a. HasCallStack => [Char] -> a
    error [Char]
    "Enum PixbufRotation: enumFromThen not implemented"
      enumFromThenTo :: PixbufRotation
    -> PixbufRotation -> PixbufRotation -> [PixbufRotation]
    enumFromThenTo PixbufRotation
    _ PixbufRotation
    _ PixbufRotation
    _ =     [Char] -> [PixbufRotation]
    forall a. HasCallStack => [Char] -> a
    error [Char]
    "Enum PixbufRotation: enumFromThenTo not implemented"

    {-# LINE 706 "./Graphics/UI/Gtk/Gdk/Pixbuf.chs" #-}

    -- | 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.
    --
    pixbufAddAlpha :: Pixbuf -> Maybe (Word8, Word8, Word8) -> IO Pixbuf
    pixbufAddAlpha pb Nothing = wrapNewGObject mkPixbuf $
      (\(Pixbuf arg1) arg2 arg3 arg4 arg5 -> withForeignPtr arg1 $ \argPtr1 ->gdk_pixbuf_add_alpha argPtr1 arg2 arg3 arg4 arg5) pb (fromBool False) 0 0 0
    pixbufAddAlpha pb (Just (r,g,b)) = wrapNewGObject mkPixbuf $
      (\(Pixbuf arg1) arg2 arg3 arg4 arg5 -> withForeignPtr arg1 $ \argPtr1 ->gdk_pixbuf_add_alpha argPtr1 arg2 arg3 arg4 arg5) pb (fromBool True)
        (fromIntegral r) (fromIntegral g) (fromIntegral b)

    -- | Copy a rectangular portion into another 'Pixbuf'.
    --
    -- The source 'Pixbuf' remains unchanged. Conversion between
    -- different formats is done automatically.
    --
    pixbufCopyArea ::
        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 ()
    pixbufCopyArea :: Pixbuf -> Int -> Int -> Int -> Int -> Pixbuf -> Int -> Int -> IO ()
    pixbufCopyArea Pixbuf
    src Int
    srcX Int
    srcY Int
    srcWidth Int
    srcHeight Pixbuf
    dest Int
    destX Int
    destY =
      (\(Pixbuf ForeignPtr Pixbuf
    arg1) CInt
    arg2 CInt
    arg3 CInt
    arg4 CInt
    arg5 (Pixbuf ForeignPtr Pixbuf
    arg6) CInt
    arg7 CInt
    arg8 -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO ()) -> IO ()) -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg6 ((Ptr Pixbuf -> IO ()) -> IO ()) -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr6 ->Ptr Pixbuf
    -> CInt
    -> CInt
    -> CInt
    -> CInt
    -> Ptr Pixbuf
    -> CInt
    -> CInt
    -> IO ()
    gdk_pixbuf_copy_area Ptr Pixbuf
    argPtr1 CInt
    arg2 CInt
    arg3 CInt
    arg4 CInt
    arg5 Ptr Pixbuf
    argPtr6 CInt
    arg7 CInt
    arg8) Pixbuf
    src
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    srcX) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    srcY)
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    srcWidth) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    srcHeight)
        Pixbuf
    dest (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    destX) (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    destY)

    -- | 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.
    --
    pixbufFill :: Pixbuf -> Word8 -> Word8 -> Word8 -> Word8 -> IO ()
    pixbufFill :: Pixbuf -> Word8 -> Word8 -> Word8 -> Word8 -> IO ()
    pixbufFill Pixbuf
    pb Word8
    red Word8
    green Word8
    blue Word8
    alpha = (\(Pixbuf ForeignPtr Pixbuf
    arg1) CUInt
    arg2 -> ForeignPtr Pixbuf -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Pixbuf
    arg1 ((Ptr Pixbuf -> IO ()) -> IO ()) -> (Ptr Pixbuf -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Pixbuf
    argPtr1 ->Ptr Pixbuf -> CUInt -> IO ()
    gdk_pixbuf_fill Ptr Pixbuf
    argPtr1 CUInt
    arg2) Pixbuf
    pb
      ((Word8 -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    red) CUInt -> Int -> CUInt
    forall a. Bits a => a -> Int -> a
    `shiftL` Int
    24 CUInt -> CUInt -> CUInt
    forall a. Bits a => a -> a -> a
    .|.
       (Word8 -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    green) CUInt -> Int -> CUInt
    forall a. Bits a => a -> Int -> a
    `shiftL` Int
    16 CUInt -> CUInt -> CUInt
    forall a. Bits a => a -> a -> a
    .|.
       (Word8 -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    blue) CUInt -> Int -> CUInt
    forall a. Bits a => a -> Int -> a
    `shiftL` Int
    8 CUInt -> CUInt -> CUInt
    forall a. Bits a => a -> a -> a
    .|.
       (Word8 -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    alpha))

    foreign import ccall unsafe "gdk_pixbuf_get_colorspace"
      gdk_pixbuf_get_colorspace :: ((Ptr Pixbuf) -> (IO CInt))

    foreign import ccall unsafe "gdk_pixbuf_get_n_channels"
      gdk_pixbuf_get_n_channels :: ((Ptr Pixbuf) -> (IO CInt))

    foreign import ccall unsafe "gdk_pixbuf_get_has_alpha"
      gdk_pixbuf_get_has_alpha :: ((Ptr Pixbuf) -> (IO CInt))

    foreign import ccall unsafe "gdk_pixbuf_get_bits_per_sample"
      gdk_pixbuf_get_bits_per_sample :: ((Ptr Pixbuf) -> (IO CInt))

    foreign import ccall unsafe "gdk_pixbuf_get_pixels"
      gdk_pixbuf_get_pixels :: ((Ptr Pixbuf) -> (IO (Ptr CUChar)))

    foreign import ccall unsafe "gdk_pixbuf_get_width"
      gdk_pixbuf_get_width :: ((Ptr Pixbuf) -> (IO CInt))

    foreign import ccall unsafe "gdk_pixbuf_get_height"
      gdk_pixbuf_get_height :: ((Ptr Pixbuf) -> (IO CInt))

    foreign import ccall unsafe "gdk_pixbuf_get_rowstride"
      gdk_pixbuf_get_rowstride :: ((Ptr Pixbuf) -> (IO CInt))

    foreign import ccall unsafe "gdk_pixbuf_get_option"
      gdk_pixbuf_get_option :: ((Ptr Pixbuf) -> ((Ptr CChar) -> (IO (Ptr CChar))))

    foreign import ccall unsafe "gdk_pixbuf_error_quark"
      gdk_pixbuf_error_quark :: CUInt

    foreign import ccall unsafe "gdk_pixbuf_new_from_file"
      gdk_pixbuf_new_from_file :: ((Ptr CChar) -> ((Ptr (Ptr ())) -> (IO (Ptr Pixbuf))))

    foreign import ccall safe "gdk_pixbuf_new_from_file_at_size"
      gdk_pixbuf_new_from_file_at_size :: ((Ptr CChar) -> (CInt -> (CInt -> ((Ptr (Ptr ())) -> (IO (Ptr Pixbuf))))))

    foreign import ccall safe "gdk_pixbuf_new_from_file_at_scale"
      gdk_pixbuf_new_from_file_at_scale :: ((Ptr CChar) -> (CInt -> (CInt -> (CInt -> ((Ptr (Ptr ())) -> (IO (Ptr Pixbuf)))))))

    foreign import ccall safe "gdk_pixbuf_get_from_surface"
      gdk_pixbuf_get_from_surface :: ((Ptr ()) -> (CInt -> (CInt -> (CInt -> (CInt -> (IO (Ptr Pixbuf)))))))

    foreign import ccall safe "gdk_pixbuf_get_from_window"
      gdk_pixbuf_get_from_window :: ((Ptr DrawWindow) -> (CInt -> (CInt -> (CInt -> (CInt -> (IO (Ptr Pixbuf)))))))

    foreign import ccall unsafe "gdk_pixbuf_savev"
      gdk_pixbuf_savev :: ((Ptr Pixbuf) -> ((Ptr CChar) -> ((Ptr CChar) -> ((Ptr (Ptr CChar)) -> ((Ptr (Ptr CChar)) -> ((Ptr (Ptr ())) -> (IO CInt)))))))

    foreign import ccall safe "gdk_pixbuf_new"
      gdk_pixbuf_new :: (CInt -> (CInt -> (CInt -> (CInt -> (CInt -> (IO (Ptr Pixbuf)))))))

    foreign import ccall safe "gdk_pixbuf_new_from_data"
      gdk_pixbuf_new_from_data :: ((Ptr CUChar) -> (CInt -> (CInt -> (CInt -> (CInt -> (CInt -> (CInt -> ((FunPtr ((Ptr CUChar) -> ((Ptr ()) -> (IO ())))) -> ((Ptr ()) -> (IO (Ptr Pixbuf)))))))))))

    foreign import ccall safe "gdk_pixbuf_new_from_xpm_data"
      gdk_pixbuf_new_from_xpm_data :: ((Ptr (Ptr CChar)) -> (IO (Ptr Pixbuf)))

    foreign import ccall unsafe "gdk_pixbuf_new_from_inline"
      gdk_pixbuf_new_from_inline :: (CInt -> ((Ptr CUChar) -> (CInt -> ((Ptr (Ptr ())) -> (IO (Ptr Pixbuf))))))

    foreign import ccall unsafe "gdk_pixbuf_new_subpixbuf"
      gdk_pixbuf_new_subpixbuf :: ((Ptr Pixbuf) -> (CInt -> (CInt -> (CInt -> (CInt -> (IO (Ptr Pixbuf)))))))

    foreign import ccall unsafe "gdk_pixbuf_copy"
      gdk_pixbuf_copy :: ((Ptr Pixbuf) -> (IO (Ptr Pixbuf)))

    foreign import ccall safe "gdk_pixbuf_scale_simple"
      gdk_pixbuf_scale_simple :: ((Ptr Pixbuf) -> (CInt -> (CInt -> (CInt -> (IO (Ptr Pixbuf))))))

    foreign import ccall unsafe "gdk_pixbuf_scale"
      gdk_pixbuf_scale :: ((Ptr Pixbuf) -> ((Ptr Pixbuf) -> (CInt -> (CInt -> (CInt -> (CInt -> (CDouble -> (CDouble -> (CDouble -> (CDouble -> (CInt -> (IO ()))))))))))))

    foreign import ccall unsafe "gdk_pixbuf_composite"
      gdk_pixbuf_composite :: ((Ptr Pixbuf) -> ((Ptr Pixbuf) -> (CInt -> (CInt -> (CInt -> (CInt -> (CDouble -> (CDouble -> (CDouble -> (CDouble -> (CInt -> (CInt -> (IO ())))))))))))))

    foreign import ccall safe "gdk_pixbuf_flip"
      gdk_pixbuf_flip :: ((Ptr Pixbuf) -> (CInt -> (IO (Ptr Pixbuf))))

    foreign import ccall safe "gdk_pixbuf_rotate_simple"
      gdk_pixbuf_rotate_simple :: ((Ptr Pixbuf) -> (CInt -> (IO (Ptr Pixbuf))))

    foreign import ccall unsafe "gdk_pixbuf_add_alpha"
      gdk_pixbuf_add_alpha :: ((Ptr Pixbuf) -> (CInt -> (CUChar -> (CUChar -> (CUChar -> (IO (Ptr Pixbuf)))))))

    foreign import ccall unsafe "gdk_pixbuf_copy_area"
      gdk_pixbuf_copy_area :: ((Ptr Pixbuf) -> (CInt -> (CInt -> (CInt -> (CInt -> ((Ptr Pixbuf) -> (CInt -> (CInt -> (IO ())))))))))

    foreign import ccall unsafe "gdk_pixbuf_fill"
      gdk_pixbuf_fill :: ((Ptr Pixbuf) -> (CUInt -> (IO ())))