gi-gdkpixbuf 2.0.18 → 2.0.19

raw patch · 25 files changed

+8618/−8 lines, 25 filesdep ~haskell-gidep ~haskell-gi-basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-gi, haskell-gi-base

API changes (from Hackage documentation)

Files

• ChangeLog.md +4/−0
• GI/GdkPixbuf.hs +54/−0
• GI/GdkPixbuf/Callbacks.hs +276/−0
• GI/GdkPixbuf/Constants.hs +74/−0
• GI/GdkPixbuf/Enums.hs +348/−0
• GI/GdkPixbuf/Enums.hs-boot +39/−0
• GI/GdkPixbuf/Objects.hs +51/−0
• GI/GdkPixbuf/Objects/Pixbuf.hs +4010/−0
• GI/GdkPixbuf/Objects/Pixbuf.hs-boot +161/−0
• GI/GdkPixbuf/Objects/PixbufAnimation.hs +673/−0
• GI/GdkPixbuf/Objects/PixbufAnimation.hs-boot +44/−0
• GI/GdkPixbuf/Objects/PixbufAnimationIter.hs +351/−0
• GI/GdkPixbuf/Objects/PixbufAnimationIter.hs-boot +41/−0
• GI/GdkPixbuf/Objects/PixbufLoader.hs +1052/−0
• GI/GdkPixbuf/Objects/PixbufLoader.hs-boot +62/−0
• GI/GdkPixbuf/Objects/PixbufSimpleAnim.hs +390/−0
• GI/GdkPixbuf/Objects/PixbufSimpleAnim.hs-boot +41/−0
• GI/GdkPixbuf/Objects/PixbufSimpleAnimIter.hs +126/−0
• GI/GdkPixbuf/Objects/PixbufSimpleAnimIter.hs-boot +29/−0
• GI/GdkPixbuf/Structs.hs +41/−0
• GI/GdkPixbuf/Structs/PixbufFormat.hs +667/−0
• GI/GdkPixbuf/Structs/PixbufFormat.hs-boot +62/−0
• README.md +1/−1
• gi-gdkpixbuf.cabal +20/−6
• stack.yaml +1/−1

@@ -1,3 +1,7 @@+### 2.0.19+++ Update to haskell-gi(-base) 0.22+ ### 2.0.18  + The return value of [pixbufLoaderGetPixbuf](https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.18/docs/GI-GdkPixbuf-Objects-PixbufLoader.html#v:pixbufLoaderGetPixbuf) is nullable, but was not marked as such.

@@ -0,0 +1,54 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GdkPixbuf+    (     module GI.GdkPixbuf.Callbacks           ,+    module GI.GdkPixbuf.Constants           ,+    module GI.GdkPixbuf.Enums               ,+    module GI.GdkPixbuf.Objects             ,+    module GI.GdkPixbuf.Structs             ,++++    module Data.GI.Base                     ,+++    ) where++import GI.GdkPixbuf.Callbacks+import GI.GdkPixbuf.Constants+import GI.GdkPixbuf.Enums+import GI.GdkPixbuf.Objects+import GI.GdkPixbuf.Structs++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++import Data.GI.Base+

@@ -0,0 +1,276 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GdkPixbuf.Callbacks+    ( ++ -- * Signals+-- ** PixbufDestroyNotify #signal:PixbufDestroyNotify#++    C_PixbufDestroyNotify                   ,+    PixbufDestroyNotify                     ,+    PixbufDestroyNotify_WithClosures        ,+    drop_closures_PixbufDestroyNotify       ,+    dynamic_PixbufDestroyNotify             ,+    genClosure_PixbufDestroyNotify          ,+    mk_PixbufDestroyNotify                  ,+    noPixbufDestroyNotify                   ,+    noPixbufDestroyNotify_WithClosures      ,+    wrap_PixbufDestroyNotify                ,+++-- ** PixbufSaveFunc #signal:PixbufSaveFunc#++    C_PixbufSaveFunc                        ,+    PixbufSaveFunc                          ,+    PixbufSaveFunc_WithClosures             ,+    drop_closures_PixbufSaveFunc            ,+    dynamic_PixbufSaveFunc                  ,+    genClosure_PixbufSaveFunc               ,+    mk_PixbufSaveFunc                       ,+    noPixbufSaveFunc                        ,+    noPixbufSaveFunc_WithClosures           ,+    wrap_PixbufSaveFunc                     ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++-- callback PixbufSaveFunc+--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if successful, %FALSE (with @error set) if failed.", sinceVersion = Nothing}, args = [Arg {argCName = "buf", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "bytes to be written.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes in @buf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A location to return an error.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to gdk_pixbuf_save_to_callback().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Specifies the type of the function passed to\ngdk_pixbuf_save_to_callback().  It is called once for each block of\nbytes that is \"written\" by gdk_pixbuf_save_to_callback().  If\nsuccessful it should return %TRUE.  If an error occurs it should set\n@error and return %FALSE, in which case gdk_pixbuf_save_to_callback()\nwill fail with the same error.", sinceVersion = Just "2.4"}}+-- | Type for the callback on the (unwrapped) C side.+type C_PixbufSaveFunc =+    Ptr Word8 ->+    Word64 ->+    Ptr (Ptr GError) ->+    Ptr () ->+    IO CInt++-- Args : [Arg {argCName = "buf", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "bytes to be written.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes in @buf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A location to return an error.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to gdk_pixbuf_save_to_callback().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes in @buf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_PixbufSaveFunc :: FunPtr C_PixbufSaveFunc -> C_PixbufSaveFunc++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_PixbufSaveFunc ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_PixbufSaveFunc+    -> ByteString+    {- ^ /@buf@/: bytes to be written. -}+    -> Ptr ()+    {- ^ /@data@/: user data passed to @/gdk_pixbuf_save_to_callback()/@. -}+    -> m ((Bool, GError))+    {- ^ __Returns:__ 'True' if successful, 'False' (with /@error@/ set) if failed. -}+dynamic_PixbufSaveFunc __funPtr buf data_ = liftIO $ do+    let count = fromIntegral $ B.length buf+    buf' <- packByteString buf+    error_ <- allocMem :: IO (Ptr (Ptr GError))+    result <- (__dynamic_C_PixbufSaveFunc __funPtr) buf' count error_ data_+    let result' = (/= 0) result+    error_' <- peek error_+    error_'' <- (wrapBoxed GError) error_'+    freeMem buf'+    freeMem error_+    return (result', error_'')++-- | Generate a function pointer callable from C code, from a `C_PixbufSaveFunc`.+foreign import ccall "wrapper"+    mk_PixbufSaveFunc :: C_PixbufSaveFunc -> IO (FunPtr C_PixbufSaveFunc)++{- |+Specifies the type of the function passed to+@/gdk_pixbuf_save_to_callback()/@.  It is called once for each block of+bytes that is \"written\" by @/gdk_pixbuf_save_to_callback()/@.  If+successful it should return 'True'.  If an error occurs it should set+/@error@/ and return 'False', in which case @/gdk_pixbuf_save_to_callback()/@+will fail with the same error.++/Since: 2.4/+-}+type PixbufSaveFunc =+    ByteString+    {- ^ /@buf@/: bytes to be written. -}+    -> IO ((Bool, GError))+    {- ^ __Returns:__ 'True' if successful, 'False' (with /@error@/ set) if failed. -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `PixbufSaveFunc`@.+noPixbufSaveFunc :: Maybe PixbufSaveFunc+noPixbufSaveFunc = Nothing++{- |+Specifies the type of the function passed to+@/gdk_pixbuf_save_to_callback()/@.  It is called once for each block of+bytes that is \"written\" by @/gdk_pixbuf_save_to_callback()/@.  If+successful it should return 'True'.  If an error occurs it should set+/@error@/ and return 'False', in which case @/gdk_pixbuf_save_to_callback()/@+will fail with the same error.++/Since: 2.4/+-}+type PixbufSaveFunc_WithClosures =+    ByteString+    {- ^ /@buf@/: bytes to be written. -}+    -> Ptr ()+    {- ^ /@data@/: user data passed to @/gdk_pixbuf_save_to_callback()/@. -}+    -> IO ((Bool, GError))+    {- ^ __Returns:__ 'True' if successful, 'False' (with /@error@/ set) if failed. -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `PixbufSaveFunc_WithClosures`@.+noPixbufSaveFunc_WithClosures :: Maybe PixbufSaveFunc_WithClosures+noPixbufSaveFunc_WithClosures = Nothing++-- | A simple wrapper that ignores the closure arguments.+drop_closures_PixbufSaveFunc :: PixbufSaveFunc -> PixbufSaveFunc_WithClosures+drop_closures_PixbufSaveFunc _f buf _ = _f buf++-- | Wrap the callback into a `GClosure`.+genClosure_PixbufSaveFunc :: MonadIO m => PixbufSaveFunc -> m (GClosure C_PixbufSaveFunc)+genClosure_PixbufSaveFunc cb = liftIO $ do+    let cb' = drop_closures_PixbufSaveFunc cb+    let cb'' = wrap_PixbufSaveFunc Nothing cb'+    mk_PixbufSaveFunc cb'' >>= B.GClosure.newGClosure+++-- | Wrap a `PixbufSaveFunc` into a `C_PixbufSaveFunc`.+wrap_PixbufSaveFunc ::+    Maybe (Ptr (FunPtr C_PixbufSaveFunc)) ->+    PixbufSaveFunc_WithClosures ->+    C_PixbufSaveFunc+wrap_PixbufSaveFunc funptrptr _cb buf count error_ data_ = do+    buf' <- (unpackByteStringWithLength count) buf+    (result, outerror_) <- _cb  buf' data_+    outerror_' <- B.ManagedPtr.disownBoxed outerror_+    poke error_ outerror_'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'+++-- callback PixbufDestroyNotify+--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "pixels", argType = TCArray False (-1) (-1) (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The pixel array of the pixbuf\n  that is being finalized.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User closure data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "A function of this type is responsible for freeing the pixel array\nof a pixbuf.  The gdk_pixbuf_new_from_data() function lets you\npass in a pre-allocated pixel array so that a pixbuf can be\ncreated from it; in this case you will need to pass in a function\nof #GdkPixbufDestroyNotify so that the pixel data can be freed\nwhen the pixbuf is finalized.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_PixbufDestroyNotify =+    Ptr Word8 ->+    Ptr () ->+    IO ()++-- Args : [Arg {argCName = "pixels", argType = TCArray False (-1) (-1) (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The pixel array of the pixbuf\n  that is being finalized.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User closure data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_PixbufDestroyNotify :: FunPtr C_PixbufDestroyNotify -> C_PixbufDestroyNotify++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_PixbufDestroyNotify ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_PixbufDestroyNotify+    -> Ptr Word8+    {- ^ /@pixels@/: The pixel array of the pixbuf+  that is being finalized. -}+    -> Ptr ()+    {- ^ /@data@/: User closure data. -}+    -> m ()+dynamic_PixbufDestroyNotify __funPtr pixels data_ = liftIO $ do+    (__dynamic_C_PixbufDestroyNotify __funPtr) pixels data_+    return ()++-- | Generate a function pointer callable from C code, from a `C_PixbufDestroyNotify`.+foreign import ccall "wrapper"+    mk_PixbufDestroyNotify :: C_PixbufDestroyNotify -> IO (FunPtr C_PixbufDestroyNotify)++{- |+A function of this type is responsible for freeing the pixel array+of a pixbuf.  The 'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewFromData' function lets you+pass in a pre-allocated pixel array so that a pixbuf can be+created from it; in this case you will need to pass in a function+of 'GI.GdkPixbuf.Callbacks.PixbufDestroyNotify' so that the pixel data can be freed+when the pixbuf is finalized.+-}+type PixbufDestroyNotify =+    Ptr Word8+    {- ^ /@pixels@/: The pixel array of the pixbuf+  that is being finalized. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `PixbufDestroyNotify`@.+noPixbufDestroyNotify :: Maybe PixbufDestroyNotify+noPixbufDestroyNotify = Nothing++{- |+A function of this type is responsible for freeing the pixel array+of a pixbuf.  The 'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewFromData' function lets you+pass in a pre-allocated pixel array so that a pixbuf can be+created from it; in this case you will need to pass in a function+of 'GI.GdkPixbuf.Callbacks.PixbufDestroyNotify' so that the pixel data can be freed+when the pixbuf is finalized.+-}+type PixbufDestroyNotify_WithClosures =+    Ptr Word8+    {- ^ /@pixels@/: The pixel array of the pixbuf+  that is being finalized. -}+    -> Ptr ()+    {- ^ /@data@/: User closure data. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `PixbufDestroyNotify_WithClosures`@.+noPixbufDestroyNotify_WithClosures :: Maybe PixbufDestroyNotify_WithClosures+noPixbufDestroyNotify_WithClosures = Nothing++-- | A simple wrapper that ignores the closure arguments.+drop_closures_PixbufDestroyNotify :: PixbufDestroyNotify -> PixbufDestroyNotify_WithClosures+drop_closures_PixbufDestroyNotify _f pixels _ = _f pixels++-- | Wrap the callback into a `GClosure`.+genClosure_PixbufDestroyNotify :: MonadIO m => PixbufDestroyNotify -> m (GClosure C_PixbufDestroyNotify)+genClosure_PixbufDestroyNotify cb = liftIO $ do+    let cb' = drop_closures_PixbufDestroyNotify cb+    let cb'' = wrap_PixbufDestroyNotify Nothing cb'+    mk_PixbufDestroyNotify cb'' >>= B.GClosure.newGClosure+++-- | Wrap a `PixbufDestroyNotify` into a `C_PixbufDestroyNotify`.+wrap_PixbufDestroyNotify ::+    Maybe (Ptr (FunPtr C_PixbufDestroyNotify)) ->+    PixbufDestroyNotify_WithClosures ->+    C_PixbufDestroyNotify+wrap_PixbufDestroyNotify funptrptr _cb pixels data_ = do+    _cb  pixels data_+    maybeReleaseFunPtr funptrptr+++

@@ -0,0 +1,74 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GdkPixbuf.Constants+    ( +    pattern PIXBUF_VERSION                  ,+    pattern PIXBUF_MINOR                    ,+    pattern PIXBUF_MICRO                    ,+    pattern PIXBUF_MAJOR                    ,+    pattern PIXBUF_FEATURES_H               ,++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++{- |+Contains the full version of the gdk-pixbuf header as a string.+This is the version being compiled against; contrast with+@/gdk_pixbuf_version/@.+-}+pattern PIXBUF_VERSION = "2.38.1" :: T.Text++{- |+Minor version of gdk-pixbuf library, that is the \"8\" in+\"0.8.2\" for example.+-}+pattern PIXBUF_MINOR = 38 :: Int32++{- |+Micro version of gdk-pixbuf library, that is the \"2\" in+\"0.8.2\" for example.+-}+pattern PIXBUF_MICRO = 1 :: Int32++{- |+Major version of gdk-pixbuf library, that is the \"0\" in+\"0.8.2\" for example.+-}+pattern PIXBUF_MAJOR = 2 :: Int32++{- |+/No description available in the introspection data./+-}+pattern PIXBUF_FEATURES_H = 1 :: Int32++

@@ -0,0 +1,348 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GdkPixbuf.Enums+    ( ++ -- * Enumerations+-- ** Colorspace #enum:Colorspace#++    Colorspace(..)                          ,+++-- ** InterpType #enum:InterpType#++    InterpType(..)                          ,+++-- ** PixbufAlphaMode #enum:PixbufAlphaMode#++    PixbufAlphaMode(..)                     ,+++-- ** PixbufError #enum:PixbufError#++    PixbufError(..)                         ,+    catchPixbufError                        ,+    handlePixbufError                       ,+++-- ** PixbufRotation #enum:PixbufRotation#++    PixbufRotation(..)                      ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++-- Enum PixbufRotation+{- |+The possible rotations which can be passed to 'GI.GdkPixbuf.Objects.Pixbuf.pixbufRotateSimple'.+To make them easier to use, their numerical values are the actual degrees.+-}+data PixbufRotation = +      PixbufRotationNone+    {- ^+    No rotation.+    -}+    | PixbufRotationCounterclockwise+    {- ^+    Rotate by 90 degrees.+    -}+    | PixbufRotationUpsidedown+    {- ^+    Rotate by 180 degrees.+    -}+    | PixbufRotationClockwise+    {- ^+    Rotate by 270 degrees.+    -}+    | AnotherPixbufRotation Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum PixbufRotation where+    fromEnum PixbufRotationNone = 0+    fromEnum PixbufRotationCounterclockwise = 90+    fromEnum PixbufRotationUpsidedown = 180+    fromEnum PixbufRotationClockwise = 270+    fromEnum (AnotherPixbufRotation k) = k++    toEnum 0 = PixbufRotationNone+    toEnum 90 = PixbufRotationCounterclockwise+    toEnum 180 = PixbufRotationUpsidedown+    toEnum 270 = PixbufRotationClockwise+    toEnum k = AnotherPixbufRotation k++instance P.Ord PixbufRotation where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gdk_pixbuf_rotation_get_type" c_gdk_pixbuf_rotation_get_type :: +    IO GType++instance BoxedEnum PixbufRotation where+    boxedEnumType _ = c_gdk_pixbuf_rotation_get_type++-- Enum PixbufError+{- |+An error code in the @/GDK_PIXBUF_ERROR/@ domain. Many gdk-pixbuf+operations can cause errors in this domain, or in the @/G_FILE_ERROR/@+domain.+-}+data PixbufError = +      PixbufErrorCorruptImage+    {- ^+    An image file was broken somehow.+    -}+    | PixbufErrorInsufficientMemory+    {- ^+    Not enough memory.+    -}+    | PixbufErrorBadOption+    {- ^+    A bad option was passed to a pixbuf save module.+    -}+    | PixbufErrorUnknownType+    {- ^+    Unknown image type.+    -}+    | PixbufErrorUnsupportedOperation+    {- ^+    Don\'t know how to perform the+     given operation on the type of image at hand.+    -}+    | PixbufErrorFailed+    {- ^+    Generic failure code, something went wrong.+    -}+    | PixbufErrorIncompleteAnimation+    {- ^+    Only part of the animation was loaded.+    -}+    | AnotherPixbufError Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum PixbufError where+    fromEnum PixbufErrorCorruptImage = 0+    fromEnum PixbufErrorInsufficientMemory = 1+    fromEnum PixbufErrorBadOption = 2+    fromEnum PixbufErrorUnknownType = 3+    fromEnum PixbufErrorUnsupportedOperation = 4+    fromEnum PixbufErrorFailed = 5+    fromEnum PixbufErrorIncompleteAnimation = 6+    fromEnum (AnotherPixbufError k) = k++    toEnum 0 = PixbufErrorCorruptImage+    toEnum 1 = PixbufErrorInsufficientMemory+    toEnum 2 = PixbufErrorBadOption+    toEnum 3 = PixbufErrorUnknownType+    toEnum 4 = PixbufErrorUnsupportedOperation+    toEnum 5 = PixbufErrorFailed+    toEnum 6 = PixbufErrorIncompleteAnimation+    toEnum k = AnotherPixbufError k++instance P.Ord PixbufError where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++instance GErrorClass PixbufError where+    gerrorClassDomain _ = "gdk-pixbuf-error-quark"++-- | Catch exceptions of type `PixbufError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.+catchPixbufError ::+    IO a ->+    (PixbufError -> GErrorMessage -> IO a) ->+    IO a+catchPixbufError = catchGErrorJustDomain++-- | Handle exceptions of type `PixbufError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.+handlePixbufError ::+    (PixbufError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handlePixbufError = handleGErrorJustDomain++foreign import ccall "gdk_pixbuf_error_get_type" c_gdk_pixbuf_error_get_type :: +    IO GType++instance BoxedEnum PixbufError where+    boxedEnumType _ = c_gdk_pixbuf_error_get_type++-- Enum PixbufAlphaMode+{- |+These values can be passed to+@/gdk_pixbuf_xlib_render_to_drawable_alpha()/@ to control how the alpha+channel of an image should be handled.  This function can create a+bilevel clipping mask (black and white) and use it while painting+the image.  In the future, when the X Window System gets an alpha+channel extension, it will be possible to do full alpha+compositing onto arbitrary drawables.  For now both cases fall+back to a bilevel clipping mask.+-}+data PixbufAlphaMode = +      PixbufAlphaModeBilevel+    {- ^+    A bilevel clipping mask (black and white)+     will be created and used to draw the image.  Pixels below 0.5 opacity+     will be considered fully transparent, and all others will be+     considered fully opaque.+    -}+    | PixbufAlphaModeFull+    {- ^+    For now falls back to @/GDK_PIXBUF_ALPHA_BILEVEL/@.+     In the future it will do full alpha compositing.+    -}+    | AnotherPixbufAlphaMode Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum PixbufAlphaMode where+    fromEnum PixbufAlphaModeBilevel = 0+    fromEnum PixbufAlphaModeFull = 1+    fromEnum (AnotherPixbufAlphaMode k) = k++    toEnum 0 = PixbufAlphaModeBilevel+    toEnum 1 = PixbufAlphaModeFull+    toEnum k = AnotherPixbufAlphaMode k++instance P.Ord PixbufAlphaMode where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gdk_pixbuf_alpha_mode_get_type" c_gdk_pixbuf_alpha_mode_get_type :: +    IO GType++instance BoxedEnum PixbufAlphaMode where+    boxedEnumType _ = c_gdk_pixbuf_alpha_mode_get_type++-- Enum InterpType+{- |+This enumeration describes the different interpolation modes that+can be used with the scaling functions. /@gDKINTERPNEAREST@/ is+the fastest scaling method, but has horrible quality when+scaling down. /@gDKINTERPBILINEAR@/ is the best choice if you+aren\'t sure what to choose, it has a good speed\/quality balance.++**Note**: Cubic filtering is missing from the list; hyperbolic+interpolation is just as fast and results in higher quality.+-}+data InterpType = +      InterpTypeNearest+    {- ^+    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.+    -}+    | InterpTypeTiles+    {- ^+    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.+    -}+    | InterpTypeBilinear+    {- ^+    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.+    -}+    | InterpTypeHyper+    {- ^+    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).+     **Deprecated**: this interpolation filter is deprecated, as in reality+     it has a lower quality than the /@gDKINTERPBILINEAR@/ filter+     (Since: 2.38)+    -}+    | AnotherInterpType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum InterpType where+    fromEnum InterpTypeNearest = 0+    fromEnum InterpTypeTiles = 1+    fromEnum InterpTypeBilinear = 2+    fromEnum InterpTypeHyper = 3+    fromEnum (AnotherInterpType k) = k++    toEnum 0 = InterpTypeNearest+    toEnum 1 = InterpTypeTiles+    toEnum 2 = InterpTypeBilinear+    toEnum 3 = InterpTypeHyper+    toEnum k = AnotherInterpType k++instance P.Ord InterpType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gdk_interp_type_get_type" c_gdk_interp_type_get_type :: +    IO GType++instance BoxedEnum InterpType where+    boxedEnumType _ = c_gdk_interp_type_get_type++-- Enum Colorspace+{- |+This enumeration defines the color spaces that are supported by+the gdk-pixbuf library.  Currently only RGB is supported.+-}+data Colorspace = +      ColorspaceRgb+    {- ^+    Indicates a red\/green\/blue additive color space.+    -}+    | AnotherColorspace Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum Colorspace where+    fromEnum ColorspaceRgb = 0+    fromEnum (AnotherColorspace k) = k++    toEnum 0 = ColorspaceRgb+    toEnum k = AnotherColorspace k++instance P.Ord Colorspace where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gdk_colorspace_get_type" c_gdk_colorspace_get_type :: +    IO GType++instance BoxedEnum Colorspace where+    boxedEnumType _ = c_gdk_colorspace_get_type++

@@ -0,0 +1,39 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GdkPixbuf.Enums where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++data PixbufRotation+instance P.Enum PixbufRotation where+instance BoxedEnum PixbufRotation where+data PixbufError+instance P.Enum PixbufError where+instance BoxedEnum PixbufError where+data PixbufAlphaMode+instance P.Enum PixbufAlphaMode where+instance BoxedEnum PixbufAlphaMode where+data InterpType+instance P.Enum InterpType where+instance BoxedEnum InterpType where+data Colorspace+instance P.Enum Colorspace where+instance BoxedEnum Colorspace where

@@ -0,0 +1,51 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GdkPixbuf.Objects+    (     module GI.GdkPixbuf.Objects.Pixbuf      ,+    module GI.GdkPixbuf.Objects.PixbufAnimation,+    module GI.GdkPixbuf.Objects.PixbufAnimationIter,+    module GI.GdkPixbuf.Objects.PixbufLoader,+    module GI.GdkPixbuf.Objects.PixbufSimpleAnim,+    module GI.GdkPixbuf.Objects.PixbufSimpleAnimIter,+++    ) where++import GI.GdkPixbuf.Objects.Pixbuf+import GI.GdkPixbuf.Objects.PixbufAnimation+import GI.GdkPixbuf.Objects.PixbufAnimationIter+import GI.GdkPixbuf.Objects.PixbufLoader+import GI.GdkPixbuf.Objects.PixbufSimpleAnim+import GI.GdkPixbuf.Objects.PixbufSimpleAnimIter++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL+++

@@ -0,0 +1,4010 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++This is the main structure in the gdk-pixbuf library.  It is+used to represent images.  It contains information about the+image\'s pixel data, its color space, bits per sample, width and+height, and the rowstride (the number of bytes between the start of+one row and the start of the next).+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GdkPixbuf.Objects.Pixbuf+    ( +#if ENABLE_OVERLOADING+    PixbufGetOptionsMethodInfo              ,+#endif++-- * Exported types+    Pixbuf(..)                              ,+    IsPixbuf                                ,+    toPixbuf                                ,+    noPixbuf                                ,+++ -- * Methods+-- ** addAlpha #method:addAlpha#++#if ENABLE_OVERLOADING+    PixbufAddAlphaMethodInfo                ,+#endif+    pixbufAddAlpha                          ,+++-- ** applyEmbeddedOrientation #method:applyEmbeddedOrientation#++#if ENABLE_OVERLOADING+    PixbufApplyEmbeddedOrientationMethodInfo,+#endif+    pixbufApplyEmbeddedOrientation          ,+++-- ** calculateRowstride #method:calculateRowstride#++    pixbufCalculateRowstride                ,+++-- ** composite #method:composite#++#if ENABLE_OVERLOADING+    PixbufCompositeMethodInfo               ,+#endif+    pixbufComposite                         ,+++-- ** compositeColor #method:compositeColor#++#if ENABLE_OVERLOADING+    PixbufCompositeColorMethodInfo          ,+#endif+    pixbufCompositeColor                    ,+++-- ** compositeColorSimple #method:compositeColorSimple#++#if ENABLE_OVERLOADING+    PixbufCompositeColorSimpleMethodInfo    ,+#endif+    pixbufCompositeColorSimple              ,+++-- ** copy #method:copy#++#if ENABLE_OVERLOADING+    PixbufCopyMethodInfo                    ,+#endif+    pixbufCopy                              ,+++-- ** copyArea #method:copyArea#++#if ENABLE_OVERLOADING+    PixbufCopyAreaMethodInfo                ,+#endif+    pixbufCopyArea                          ,+++-- ** copyOptions #method:copyOptions#++#if ENABLE_OVERLOADING+    PixbufCopyOptionsMethodInfo             ,+#endif+    pixbufCopyOptions                       ,+++-- ** fill #method:fill#++#if ENABLE_OVERLOADING+    PixbufFillMethodInfo                    ,+#endif+    pixbufFill                              ,+++-- ** flip #method:flip#++#if ENABLE_OVERLOADING+    PixbufFlipMethodInfo                    ,+#endif+    pixbufFlip                              ,+++-- ** getBitsPerSample #method:getBitsPerSample#++#if ENABLE_OVERLOADING+    PixbufGetBitsPerSampleMethodInfo        ,+#endif+    pixbufGetBitsPerSample                  ,+++-- ** getByteLength #method:getByteLength#++#if ENABLE_OVERLOADING+    PixbufGetByteLengthMethodInfo           ,+#endif+    pixbufGetByteLength                     ,+++-- ** getColorspace #method:getColorspace#++#if ENABLE_OVERLOADING+    PixbufGetColorspaceMethodInfo           ,+#endif+    pixbufGetColorspace                     ,+++-- ** getFileInfo #method:getFileInfo#++    pixbufGetFileInfo                       ,+++-- ** getFileInfoAsync #method:getFileInfoAsync#++    pixbufGetFileInfoAsync                  ,+++-- ** getFileInfoFinish #method:getFileInfoFinish#++    pixbufGetFileInfoFinish                 ,+++-- ** getFormats #method:getFormats#++    pixbufGetFormats                        ,+++-- ** getHasAlpha #method:getHasAlpha#++#if ENABLE_OVERLOADING+    PixbufGetHasAlphaMethodInfo             ,+#endif+    pixbufGetHasAlpha                       ,+++-- ** getHeight #method:getHeight#++#if ENABLE_OVERLOADING+    PixbufGetHeightMethodInfo               ,+#endif+    pixbufGetHeight                         ,+++-- ** getNChannels #method:getNChannels#++#if ENABLE_OVERLOADING+    PixbufGetNChannelsMethodInfo            ,+#endif+    pixbufGetNChannels                      ,+++-- ** getOption #method:getOption#++#if ENABLE_OVERLOADING+    PixbufGetOptionMethodInfo               ,+#endif+    pixbufGetOption                         ,+++-- ** getPixels #method:getPixels#++#if ENABLE_OVERLOADING+    PixbufGetPixelsMethodInfo               ,+#endif+    pixbufGetPixels                         ,+++-- ** getRowstride #method:getRowstride#++#if ENABLE_OVERLOADING+    PixbufGetRowstrideMethodInfo            ,+#endif+    pixbufGetRowstride                      ,+++-- ** getWidth #method:getWidth#++#if ENABLE_OVERLOADING+    PixbufGetWidthMethodInfo                ,+#endif+    pixbufGetWidth                          ,+++-- ** new #method:new#++    pixbufNew                               ,+++-- ** newFromBytes #method:newFromBytes#++    pixbufNewFromBytes                      ,+++-- ** newFromData #method:newFromData#++    pixbufNewFromData                       ,+++-- ** newFromFile #method:newFromFile#++    pixbufNewFromFile                       ,+++-- ** newFromFileAtScale #method:newFromFileAtScale#++    pixbufNewFromFileAtScale                ,+++-- ** newFromFileAtSize #method:newFromFileAtSize#++    pixbufNewFromFileAtSize                 ,+++-- ** newFromInline #method:newFromInline#++    pixbufNewFromInline                     ,+++-- ** newFromResource #method:newFromResource#++    pixbufNewFromResource                   ,+++-- ** newFromResourceAtScale #method:newFromResourceAtScale#++    pixbufNewFromResourceAtScale            ,+++-- ** newFromStream #method:newFromStream#++    pixbufNewFromStream                     ,+++-- ** newFromStreamAsync #method:newFromStreamAsync#++    pixbufNewFromStreamAsync                ,+++-- ** newFromStreamAtScale #method:newFromStreamAtScale#++    pixbufNewFromStreamAtScale              ,+++-- ** newFromStreamAtScaleAsync #method:newFromStreamAtScaleAsync#++    pixbufNewFromStreamAtScaleAsync         ,+++-- ** newFromStreamFinish #method:newFromStreamFinish#++    pixbufNewFromStreamFinish               ,+++-- ** newFromXpmData #method:newFromXpmData#++    pixbufNewFromXpmData                    ,+++-- ** newSubpixbuf #method:newSubpixbuf#++#if ENABLE_OVERLOADING+    PixbufNewSubpixbufMethodInfo            ,+#endif+    pixbufNewSubpixbuf                      ,+++-- ** readPixelBytes #method:readPixelBytes#++#if ENABLE_OVERLOADING+    PixbufReadPixelBytesMethodInfo          ,+#endif+    pixbufReadPixelBytes                    ,+++-- ** readPixels #method:readPixels#++#if ENABLE_OVERLOADING+    PixbufReadPixelsMethodInfo              ,+#endif+    pixbufReadPixels                        ,+++-- ** removeOption #method:removeOption#++#if ENABLE_OVERLOADING+    PixbufRemoveOptionMethodInfo            ,+#endif+    pixbufRemoveOption                      ,+++-- ** rotateSimple #method:rotateSimple#++#if ENABLE_OVERLOADING+    PixbufRotateSimpleMethodInfo            ,+#endif+    pixbufRotateSimple                      ,+++-- ** saturateAndPixelate #method:saturateAndPixelate#++#if ENABLE_OVERLOADING+    PixbufSaturateAndPixelateMethodInfo     ,+#endif+    pixbufSaturateAndPixelate               ,+++-- ** saveToBufferv #method:saveToBufferv#++#if ENABLE_OVERLOADING+    PixbufSaveToBuffervMethodInfo           ,+#endif+    pixbufSaveToBufferv                     ,+++-- ** saveToCallbackv #method:saveToCallbackv#++#if ENABLE_OVERLOADING+    PixbufSaveToCallbackvMethodInfo         ,+#endif+    pixbufSaveToCallbackv                   ,+++-- ** saveToStreamFinish #method:saveToStreamFinish#++    pixbufSaveToStreamFinish                ,+++-- ** saveToStreamv #method:saveToStreamv#++#if ENABLE_OVERLOADING+    PixbufSaveToStreamvMethodInfo           ,+#endif+    pixbufSaveToStreamv                     ,+++-- ** saveToStreamvAsync #method:saveToStreamvAsync#++#if ENABLE_OVERLOADING+    PixbufSaveToStreamvAsyncMethodInfo      ,+#endif+    pixbufSaveToStreamvAsync                ,+++-- ** savev #method:savev#++#if ENABLE_OVERLOADING+    PixbufSavevMethodInfo                   ,+#endif+    pixbufSavev                             ,+++-- ** scale #method:scale#++#if ENABLE_OVERLOADING+    PixbufScaleMethodInfo                   ,+#endif+    pixbufScale                             ,+++-- ** scaleSimple #method:scaleSimple#++#if ENABLE_OVERLOADING+    PixbufScaleSimpleMethodInfo             ,+#endif+    pixbufScaleSimple                       ,+++-- ** setOption #method:setOption#++#if ENABLE_OVERLOADING+    PixbufSetOptionMethodInfo               ,+#endif+    pixbufSetOption                         ,+++++ -- * Properties+-- ** bitsPerSample #attr:bitsPerSample#+{- | The number of bits per sample.+Currently only 8 bit per sample are supported.+-}+#if ENABLE_OVERLOADING+    PixbufBitsPerSamplePropertyInfo         ,+#endif+    constructPixbufBitsPerSample            ,+    getPixbufBitsPerSample                  ,+#if ENABLE_OVERLOADING+    pixbufBitsPerSample                     ,+#endif+++-- ** colorspace #attr:colorspace#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    PixbufColorspacePropertyInfo            ,+#endif+    constructPixbufColorspace               ,+    getPixbufColorspace                     ,+#if ENABLE_OVERLOADING+    pixbufColorspace                        ,+#endif+++-- ** hasAlpha #attr:hasAlpha#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    PixbufHasAlphaPropertyInfo              ,+#endif+    constructPixbufHasAlpha                 ,+    getPixbufHasAlpha                       ,+#if ENABLE_OVERLOADING+    pixbufHasAlpha                          ,+#endif+++-- ** height #attr:height#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    PixbufHeightPropertyInfo                ,+#endif+    constructPixbufHeight                   ,+    getPixbufHeight                         ,+#if ENABLE_OVERLOADING+    pixbufHeight                            ,+#endif+++-- ** nChannels #attr:nChannels#+{- | The number of samples per pixel.+Currently, only 3 or 4 samples per pixel are supported.+-}+#if ENABLE_OVERLOADING+    PixbufNChannelsPropertyInfo             ,+#endif+    constructPixbufNChannels                ,+    getPixbufNChannels                      ,+#if ENABLE_OVERLOADING+    pixbufNChannels                         ,+#endif+++-- ** pixelBytes #attr:pixelBytes#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    PixbufPixelBytesPropertyInfo            ,+#endif+    constructPixbufPixelBytes               ,+    getPixbufPixelBytes                     ,+#if ENABLE_OVERLOADING+    pixbufPixelBytes                        ,+#endif+++-- ** pixels #attr:pixels#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    PixbufPixelsPropertyInfo                ,+#endif+    constructPixbufPixels                   ,+    getPixbufPixels                         ,+#if ENABLE_OVERLOADING+    pixbufPixels                            ,+#endif+++-- ** rowstride #attr:rowstride#+{- | The number of bytes between the start of a row and+the start of the next row. This number must (obviously)+be at least as large as the width of the pixbuf.+-}+#if ENABLE_OVERLOADING+    PixbufRowstridePropertyInfo             ,+#endif+    constructPixbufRowstride                ,+    getPixbufRowstride                      ,+#if ENABLE_OVERLOADING+    pixbufRowstride                         ,+#endif+++-- ** width #attr:width#+{- | /No description available in the introspection data./+-}+#if ENABLE_OVERLOADING+    PixbufWidthPropertyInfo                 ,+#endif+    constructPixbufWidth                    ,+    getPixbufWidth                          ,+#if ENABLE_OVERLOADING+    pixbufWidth                             ,+#endif+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import qualified GI.GLib.Structs.Bytes as GLib.Bytes+import qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.GdkPixbuf.Callbacks as GdkPixbuf.Callbacks+import {-# SOURCE #-} qualified GI.GdkPixbuf.Enums as GdkPixbuf.Enums+import {-# SOURCE #-} qualified GI.GdkPixbuf.Structs.PixbufFormat as GdkPixbuf.PixbufFormat+import qualified GI.Gio.Callbacks as Gio.Callbacks+import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult+import qualified GI.Gio.Interfaces.Icon as Gio.Icon+import qualified GI.Gio.Interfaces.LoadableIcon as Gio.LoadableIcon+import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable+import qualified GI.Gio.Objects.InputStream as Gio.InputStream+import qualified GI.Gio.Objects.OutputStream as Gio.OutputStream++-- | Memory-managed wrapper type.+newtype Pixbuf = Pixbuf (ManagedPtr Pixbuf)+foreign import ccall "gdk_pixbuf_get_type"+    c_gdk_pixbuf_get_type :: IO GType++instance GObject Pixbuf where+    gobjectType = c_gdk_pixbuf_get_type+    ++-- | Type class for types which can be safely cast to `Pixbuf`, for instance with `toPixbuf`.+class (GObject o, O.IsDescendantOf Pixbuf o) => IsPixbuf o+instance (GObject o, O.IsDescendantOf Pixbuf o) => IsPixbuf o++instance O.HasParentTypes Pixbuf+type instance O.ParentTypes Pixbuf = '[GObject.Object.Object, Gio.Icon.Icon, Gio.LoadableIcon.LoadableIcon]++-- | Cast to `Pixbuf`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toPixbuf :: (MonadIO m, IsPixbuf o) => o -> m Pixbuf+toPixbuf = liftIO . unsafeCastTo Pixbuf++-- | A convenience alias for `Nothing` :: `Maybe` `Pixbuf`.+noPixbuf :: Maybe Pixbuf+noPixbuf = Nothing++#if ENABLE_OVERLOADING+type family ResolvePixbufMethod (t :: Symbol) (o :: *) :: * where+    ResolvePixbufMethod "addAlpha" o = PixbufAddAlphaMethodInfo+    ResolvePixbufMethod "applyEmbeddedOrientation" o = PixbufApplyEmbeddedOrientationMethodInfo+    ResolvePixbufMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolvePixbufMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolvePixbufMethod "composite" o = PixbufCompositeMethodInfo+    ResolvePixbufMethod "compositeColor" o = PixbufCompositeColorMethodInfo+    ResolvePixbufMethod "compositeColorSimple" o = PixbufCompositeColorSimpleMethodInfo+    ResolvePixbufMethod "copy" o = PixbufCopyMethodInfo+    ResolvePixbufMethod "copyArea" o = PixbufCopyAreaMethodInfo+    ResolvePixbufMethod "copyOptions" o = PixbufCopyOptionsMethodInfo+    ResolvePixbufMethod "equal" o = Gio.Icon.IconEqualMethodInfo+    ResolvePixbufMethod "fill" o = PixbufFillMethodInfo+    ResolvePixbufMethod "flip" o = PixbufFlipMethodInfo+    ResolvePixbufMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolvePixbufMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolvePixbufMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolvePixbufMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolvePixbufMethod "load" o = Gio.LoadableIcon.LoadableIconLoadMethodInfo+    ResolvePixbufMethod "loadAsync" o = Gio.LoadableIcon.LoadableIconLoadAsyncMethodInfo+    ResolvePixbufMethod "loadFinish" o = Gio.LoadableIcon.LoadableIconLoadFinishMethodInfo+    ResolvePixbufMethod "newSubpixbuf" o = PixbufNewSubpixbufMethodInfo+    ResolvePixbufMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolvePixbufMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolvePixbufMethod "readPixelBytes" o = PixbufReadPixelBytesMethodInfo+    ResolvePixbufMethod "readPixels" o = PixbufReadPixelsMethodInfo+    ResolvePixbufMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolvePixbufMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolvePixbufMethod "removeOption" o = PixbufRemoveOptionMethodInfo+    ResolvePixbufMethod "rotateSimple" o = PixbufRotateSimpleMethodInfo+    ResolvePixbufMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolvePixbufMethod "saturateAndPixelate" o = PixbufSaturateAndPixelateMethodInfo+    ResolvePixbufMethod "saveToBufferv" o = PixbufSaveToBuffervMethodInfo+    ResolvePixbufMethod "saveToCallbackv" o = PixbufSaveToCallbackvMethodInfo+    ResolvePixbufMethod "saveToStreamv" o = PixbufSaveToStreamvMethodInfo+    ResolvePixbufMethod "saveToStreamvAsync" o = PixbufSaveToStreamvAsyncMethodInfo+    ResolvePixbufMethod "savev" o = PixbufSavevMethodInfo+    ResolvePixbufMethod "scale" o = PixbufScaleMethodInfo+    ResolvePixbufMethod "scaleSimple" o = PixbufScaleSimpleMethodInfo+    ResolvePixbufMethod "serialize" o = Gio.Icon.IconSerializeMethodInfo+    ResolvePixbufMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolvePixbufMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolvePixbufMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolvePixbufMethod "toString" o = Gio.Icon.IconToStringMethodInfo+    ResolvePixbufMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolvePixbufMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolvePixbufMethod "getBitsPerSample" o = PixbufGetBitsPerSampleMethodInfo+    ResolvePixbufMethod "getByteLength" o = PixbufGetByteLengthMethodInfo+    ResolvePixbufMethod "getColorspace" o = PixbufGetColorspaceMethodInfo+    ResolvePixbufMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolvePixbufMethod "getHasAlpha" o = PixbufGetHasAlphaMethodInfo+    ResolvePixbufMethod "getHeight" o = PixbufGetHeightMethodInfo+    ResolvePixbufMethod "getNChannels" o = PixbufGetNChannelsMethodInfo+    ResolvePixbufMethod "getOption" o = PixbufGetOptionMethodInfo+    ResolvePixbufMethod "getOptions" o = PixbufGetOptionsMethodInfo+    ResolvePixbufMethod "getPixels" o = PixbufGetPixelsMethodInfo+    ResolvePixbufMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolvePixbufMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolvePixbufMethod "getRowstride" o = PixbufGetRowstrideMethodInfo+    ResolvePixbufMethod "getWidth" o = PixbufGetWidthMethodInfo+    ResolvePixbufMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolvePixbufMethod "setOption" o = PixbufSetOptionMethodInfo+    ResolvePixbufMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolvePixbufMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolvePixbufMethod t Pixbuf, O.MethodInfo info Pixbuf p) => OL.IsLabel t (Pixbuf -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- VVV Prop "bits-per-sample"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@bits-per-sample@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pixbuf #bitsPerSample+@+-}+getPixbufBitsPerSample :: (MonadIO m, IsPixbuf o) => o -> m Int32+getPixbufBitsPerSample obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "bits-per-sample"++{- |+Construct a `GValueConstruct` with valid value for the “@bits-per-sample@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPixbufBitsPerSample :: (IsPixbuf o) => Int32 -> IO (GValueConstruct o)+constructPixbufBitsPerSample val = B.Properties.constructObjectPropertyInt32 "bits-per-sample" val++#if ENABLE_OVERLOADING+data PixbufBitsPerSamplePropertyInfo+instance AttrInfo PixbufBitsPerSamplePropertyInfo where+    type AttrAllowedOps PixbufBitsPerSamplePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PixbufBitsPerSamplePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint PixbufBitsPerSamplePropertyInfo = IsPixbuf+    type AttrGetType PixbufBitsPerSamplePropertyInfo = Int32+    type AttrLabel PixbufBitsPerSamplePropertyInfo = "bits-per-sample"+    type AttrOrigin PixbufBitsPerSamplePropertyInfo = Pixbuf+    attrGet _ = getPixbufBitsPerSample+    attrSet _ = undefined+    attrConstruct _ = constructPixbufBitsPerSample+    attrClear _ = undefined+#endif++-- VVV Prop "colorspace"+   -- Type: TInterface (Name {namespace = "GdkPixbuf", name = "Colorspace"})+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@colorspace@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pixbuf #colorspace+@+-}+getPixbufColorspace :: (MonadIO m, IsPixbuf o) => o -> m GdkPixbuf.Enums.Colorspace+getPixbufColorspace obj = liftIO $ B.Properties.getObjectPropertyEnum obj "colorspace"++{- |+Construct a `GValueConstruct` with valid value for the “@colorspace@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPixbufColorspace :: (IsPixbuf o) => GdkPixbuf.Enums.Colorspace -> IO (GValueConstruct o)+constructPixbufColorspace val = B.Properties.constructObjectPropertyEnum "colorspace" val++#if ENABLE_OVERLOADING+data PixbufColorspacePropertyInfo+instance AttrInfo PixbufColorspacePropertyInfo where+    type AttrAllowedOps PixbufColorspacePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PixbufColorspacePropertyInfo = (~) GdkPixbuf.Enums.Colorspace+    type AttrBaseTypeConstraint PixbufColorspacePropertyInfo = IsPixbuf+    type AttrGetType PixbufColorspacePropertyInfo = GdkPixbuf.Enums.Colorspace+    type AttrLabel PixbufColorspacePropertyInfo = "colorspace"+    type AttrOrigin PixbufColorspacePropertyInfo = Pixbuf+    attrGet _ = getPixbufColorspace+    attrSet _ = undefined+    attrConstruct _ = constructPixbufColorspace+    attrClear _ = undefined+#endif++-- VVV Prop "has-alpha"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@has-alpha@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pixbuf #hasAlpha+@+-}+getPixbufHasAlpha :: (MonadIO m, IsPixbuf o) => o -> m Bool+getPixbufHasAlpha obj = liftIO $ B.Properties.getObjectPropertyBool obj "has-alpha"++{- |+Construct a `GValueConstruct` with valid value for the “@has-alpha@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPixbufHasAlpha :: (IsPixbuf o) => Bool -> IO (GValueConstruct o)+constructPixbufHasAlpha val = B.Properties.constructObjectPropertyBool "has-alpha" val++#if ENABLE_OVERLOADING+data PixbufHasAlphaPropertyInfo+instance AttrInfo PixbufHasAlphaPropertyInfo where+    type AttrAllowedOps PixbufHasAlphaPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PixbufHasAlphaPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PixbufHasAlphaPropertyInfo = IsPixbuf+    type AttrGetType PixbufHasAlphaPropertyInfo = Bool+    type AttrLabel PixbufHasAlphaPropertyInfo = "has-alpha"+    type AttrOrigin PixbufHasAlphaPropertyInfo = Pixbuf+    attrGet _ = getPixbufHasAlpha+    attrSet _ = undefined+    attrConstruct _ = constructPixbufHasAlpha+    attrClear _ = undefined+#endif++-- VVV Prop "height"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@height@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pixbuf #height+@+-}+getPixbufHeight :: (MonadIO m, IsPixbuf o) => o -> m Int32+getPixbufHeight obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "height"++{- |+Construct a `GValueConstruct` with valid value for the “@height@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPixbufHeight :: (IsPixbuf o) => Int32 -> IO (GValueConstruct o)+constructPixbufHeight val = B.Properties.constructObjectPropertyInt32 "height" val++#if ENABLE_OVERLOADING+data PixbufHeightPropertyInfo+instance AttrInfo PixbufHeightPropertyInfo where+    type AttrAllowedOps PixbufHeightPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PixbufHeightPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint PixbufHeightPropertyInfo = IsPixbuf+    type AttrGetType PixbufHeightPropertyInfo = Int32+    type AttrLabel PixbufHeightPropertyInfo = "height"+    type AttrOrigin PixbufHeightPropertyInfo = Pixbuf+    attrGet _ = getPixbufHeight+    attrSet _ = undefined+    attrConstruct _ = constructPixbufHeight+    attrClear _ = undefined+#endif++-- VVV Prop "n-channels"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@n-channels@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pixbuf #nChannels+@+-}+getPixbufNChannels :: (MonadIO m, IsPixbuf o) => o -> m Int32+getPixbufNChannels obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "n-channels"++{- |+Construct a `GValueConstruct` with valid value for the “@n-channels@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPixbufNChannels :: (IsPixbuf o) => Int32 -> IO (GValueConstruct o)+constructPixbufNChannels val = B.Properties.constructObjectPropertyInt32 "n-channels" val++#if ENABLE_OVERLOADING+data PixbufNChannelsPropertyInfo+instance AttrInfo PixbufNChannelsPropertyInfo where+    type AttrAllowedOps PixbufNChannelsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PixbufNChannelsPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint PixbufNChannelsPropertyInfo = IsPixbuf+    type AttrGetType PixbufNChannelsPropertyInfo = Int32+    type AttrLabel PixbufNChannelsPropertyInfo = "n-channels"+    type AttrOrigin PixbufNChannelsPropertyInfo = Pixbuf+    attrGet _ = getPixbufNChannels+    attrSet _ = undefined+    attrConstruct _ = constructPixbufNChannels+    attrClear _ = undefined+#endif++-- VVV Prop "pixel-bytes"+   -- Type: TInterface (Name {namespace = "GLib", name = "Bytes"})+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@pixel-bytes@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pixbuf #pixelBytes+@+-}+getPixbufPixelBytes :: (MonadIO m, IsPixbuf o) => o -> m (Maybe GLib.Bytes.Bytes)+getPixbufPixelBytes obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "pixel-bytes" GLib.Bytes.Bytes++{- |+Construct a `GValueConstruct` with valid value for the “@pixel-bytes@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPixbufPixelBytes :: (IsPixbuf o) => GLib.Bytes.Bytes -> IO (GValueConstruct o)+constructPixbufPixelBytes val = B.Properties.constructObjectPropertyBoxed "pixel-bytes" (Just val)++#if ENABLE_OVERLOADING+data PixbufPixelBytesPropertyInfo+instance AttrInfo PixbufPixelBytesPropertyInfo where+    type AttrAllowedOps PixbufPixelBytesPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint PixbufPixelBytesPropertyInfo = (~) GLib.Bytes.Bytes+    type AttrBaseTypeConstraint PixbufPixelBytesPropertyInfo = IsPixbuf+    type AttrGetType PixbufPixelBytesPropertyInfo = (Maybe GLib.Bytes.Bytes)+    type AttrLabel PixbufPixelBytesPropertyInfo = "pixel-bytes"+    type AttrOrigin PixbufPixelBytesPropertyInfo = Pixbuf+    attrGet _ = getPixbufPixelBytes+    attrSet _ = undefined+    attrConstruct _ = constructPixbufPixelBytes+    attrClear _ = undefined+#endif++-- VVV Prop "pixels"+   -- Type: TBasicType TPtr+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@pixels@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pixbuf #pixels+@+-}+getPixbufPixels :: (MonadIO m, IsPixbuf o) => o -> m (Ptr ())+getPixbufPixels obj = liftIO $ B.Properties.getObjectPropertyPtr obj "pixels"++{- |+Construct a `GValueConstruct` with valid value for the “@pixels@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPixbufPixels :: (IsPixbuf o) => Ptr () -> IO (GValueConstruct o)+constructPixbufPixels val = B.Properties.constructObjectPropertyPtr "pixels" val++#if ENABLE_OVERLOADING+data PixbufPixelsPropertyInfo+instance AttrInfo PixbufPixelsPropertyInfo where+    type AttrAllowedOps PixbufPixelsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PixbufPixelsPropertyInfo = (~) (Ptr ())+    type AttrBaseTypeConstraint PixbufPixelsPropertyInfo = IsPixbuf+    type AttrGetType PixbufPixelsPropertyInfo = (Ptr ())+    type AttrLabel PixbufPixelsPropertyInfo = "pixels"+    type AttrOrigin PixbufPixelsPropertyInfo = Pixbuf+    attrGet _ = getPixbufPixels+    attrSet _ = undefined+    attrConstruct _ = constructPixbufPixels+    attrClear _ = undefined+#endif++-- VVV Prop "rowstride"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@rowstride@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pixbuf #rowstride+@+-}+getPixbufRowstride :: (MonadIO m, IsPixbuf o) => o -> m Int32+getPixbufRowstride obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "rowstride"++{- |+Construct a `GValueConstruct` with valid value for the “@rowstride@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPixbufRowstride :: (IsPixbuf o) => Int32 -> IO (GValueConstruct o)+constructPixbufRowstride val = B.Properties.constructObjectPropertyInt32 "rowstride" val++#if ENABLE_OVERLOADING+data PixbufRowstridePropertyInfo+instance AttrInfo PixbufRowstridePropertyInfo where+    type AttrAllowedOps PixbufRowstridePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PixbufRowstridePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint PixbufRowstridePropertyInfo = IsPixbuf+    type AttrGetType PixbufRowstridePropertyInfo = Int32+    type AttrLabel PixbufRowstridePropertyInfo = "rowstride"+    type AttrOrigin PixbufRowstridePropertyInfo = Pixbuf+    attrGet _ = getPixbufRowstride+    attrSet _ = undefined+    attrConstruct _ = constructPixbufRowstride+    attrClear _ = undefined+#endif++-- VVV Prop "width"+   -- Type: TBasicType TInt+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@width@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pixbuf #width+@+-}+getPixbufWidth :: (MonadIO m, IsPixbuf o) => o -> m Int32+getPixbufWidth obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "width"++{- |+Construct a `GValueConstruct` with valid value for the “@width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPixbufWidth :: (IsPixbuf o) => Int32 -> IO (GValueConstruct o)+constructPixbufWidth val = B.Properties.constructObjectPropertyInt32 "width" val++#if ENABLE_OVERLOADING+data PixbufWidthPropertyInfo+instance AttrInfo PixbufWidthPropertyInfo where+    type AttrAllowedOps PixbufWidthPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PixbufWidthPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint PixbufWidthPropertyInfo = IsPixbuf+    type AttrGetType PixbufWidthPropertyInfo = Int32+    type AttrLabel PixbufWidthPropertyInfo = "width"+    type AttrOrigin PixbufWidthPropertyInfo = Pixbuf+    attrGet _ = getPixbufWidth+    attrSet _ = undefined+    attrConstruct _ = constructPixbufWidth+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Pixbuf+type instance O.AttributeList Pixbuf = PixbufAttributeList+type PixbufAttributeList = ('[ '("bitsPerSample", PixbufBitsPerSamplePropertyInfo), '("colorspace", PixbufColorspacePropertyInfo), '("hasAlpha", PixbufHasAlphaPropertyInfo), '("height", PixbufHeightPropertyInfo), '("nChannels", PixbufNChannelsPropertyInfo), '("pixelBytes", PixbufPixelBytesPropertyInfo), '("pixels", PixbufPixelsPropertyInfo), '("rowstride", PixbufRowstridePropertyInfo), '("width", PixbufWidthPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+pixbufBitsPerSample :: AttrLabelProxy "bitsPerSample"+pixbufBitsPerSample = AttrLabelProxy++pixbufColorspace :: AttrLabelProxy "colorspace"+pixbufColorspace = AttrLabelProxy++pixbufHasAlpha :: AttrLabelProxy "hasAlpha"+pixbufHasAlpha = AttrLabelProxy++pixbufHeight :: AttrLabelProxy "height"+pixbufHeight = AttrLabelProxy++pixbufNChannels :: AttrLabelProxy "nChannels"+pixbufNChannels = AttrLabelProxy++pixbufPixelBytes :: AttrLabelProxy "pixelBytes"+pixbufPixelBytes = AttrLabelProxy++pixbufPixels :: AttrLabelProxy "pixels"+pixbufPixels = AttrLabelProxy++pixbufRowstride :: AttrLabelProxy "rowstride"+pixbufRowstride = AttrLabelProxy++pixbufWidth :: AttrLabelProxy "width"+pixbufWidth = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Pixbuf = PixbufSignalList+type PixbufSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method Pixbuf::new+-- method type : Constructor+-- Args : [Arg {argCName = "colorspace", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Colorspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Color space for image", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "has_alpha", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether the image should have transparency information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bits_per_sample", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of bits per color sample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Width of image in pixels, must be > 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Height of image in pixels, must be > 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_new" gdk_pixbuf_new :: +    CUInt ->                                -- colorspace : TInterface (Name {namespace = "GdkPixbuf", name = "Colorspace"})+    CInt ->                                 -- has_alpha : TBasicType TBoolean+    Int32 ->                                -- bits_per_sample : TBasicType TInt+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    IO (Ptr Pixbuf)++{- |+Creates a new 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' structure and allocates a buffer for it.  The+buffer has an optimal rowstride.  Note that the buffer is not cleared;+you will have to fill it completely yourself.+-}+pixbufNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GdkPixbuf.Enums.Colorspace+    {- ^ /@colorspace@/: Color space for image -}+    -> Bool+    {- ^ /@hasAlpha@/: Whether the image should have transparency information -}+    -> Int32+    {- ^ /@bitsPerSample@/: Number of bits per color sample -}+    -> Int32+    {- ^ /@width@/: Width of image in pixels, must be > 0 -}+    -> Int32+    {- ^ /@height@/: Height of image in pixels, must be > 0 -}+    -> m (Maybe Pixbuf)+    {- ^ __Returns:__ A newly-created 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' with a reference count of 1, or+'Nothing' if not enough memory could be allocated for the image buffer. -}+pixbufNew colorspace hasAlpha bitsPerSample width height = liftIO $ do+    let colorspace' = (fromIntegral . fromEnum) colorspace+    let hasAlpha' = (fromIntegral . fromEnum) hasAlpha+    result <- gdk_pixbuf_new colorspace' hasAlpha' bitsPerSample width height+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (wrapObject Pixbuf) result'+        return result''+    return maybeResult++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_bytes+-- method type : Constructor+-- Args : [Arg {argCName = "data", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Image data in 8-bit/sample packed format inside a #GBytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "colorspace", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Colorspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Colorspace for the image data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "has_alpha", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether the data has an opacity channel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bits_per_sample", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of bits per sample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Width of the image in pixels, must be > 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Height of the image in pixels, must be > 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rowstride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Distance in bytes between row starts", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_bytes" gdk_pixbuf_new_from_bytes :: +    Ptr GLib.Bytes.Bytes ->                 -- data : TInterface (Name {namespace = "GLib", name = "Bytes"})+    CUInt ->                                -- colorspace : TInterface (Name {namespace = "GdkPixbuf", name = "Colorspace"})+    CInt ->                                 -- has_alpha : TBasicType TBoolean+    Int32 ->                                -- bits_per_sample : TBasicType TInt+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    Int32 ->                                -- rowstride : TBasicType TInt+    IO (Ptr Pixbuf)++{- |+Creates a new 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' out of in-memory readonly image data.+Currently only RGB images with 8 bits per sample are supported.+This is the 'GI.GLib.Structs.Bytes.Bytes' variant of 'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewFromData'.++/Since: 2.32/+-}+pixbufNewFromBytes ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GLib.Bytes.Bytes+    {- ^ /@data@/: Image data in 8-bit\/sample packed format inside a 'GI.GLib.Structs.Bytes.Bytes' -}+    -> GdkPixbuf.Enums.Colorspace+    {- ^ /@colorspace@/: Colorspace for the image data -}+    -> Bool+    {- ^ /@hasAlpha@/: Whether the data has an opacity channel -}+    -> Int32+    {- ^ /@bitsPerSample@/: Number of bits per sample -}+    -> Int32+    {- ^ /@width@/: Width of the image in pixels, must be > 0 -}+    -> Int32+    {- ^ /@height@/: Height of the image in pixels, must be > 0 -}+    -> Int32+    {- ^ /@rowstride@/: Distance in bytes between row starts -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' structure with a reference count of 1. -}+pixbufNewFromBytes data_ colorspace hasAlpha bitsPerSample width height rowstride = liftIO $ do+    data_' <- unsafeManagedPtrGetPtr data_+    let colorspace' = (fromIntegral . fromEnum) colorspace+    let hasAlpha' = (fromIntegral . fromEnum) hasAlpha+    result <- gdk_pixbuf_new_from_bytes data_' colorspace' hasAlpha' bitsPerSample width height rowstride+    checkUnexpectedReturnNULL "pixbufNewFromBytes" result+    result' <- (wrapObject Pixbuf) result+    touchManagedPtr data_+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_data+-- method type : Constructor+-- Args : [Arg {argCName = "data", argType = TCArray False (-1) (-1) (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Image data in 8-bit/sample packed format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "colorspace", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Colorspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Colorspace for the image data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "has_alpha", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether the data has an opacity channel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bits_per_sample", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of bits per sample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Width of the image in pixels, must be > 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Height of the image in pixels, must be > 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rowstride", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Distance in bytes between row starts", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_fn", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufDestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Function used to free the data when the pixbuf's reference count\ndrops to zero, or %NULL if the data should not be freed", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 8, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_fn_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Closure data to pass to the destroy notification function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_data" gdk_pixbuf_new_from_data :: +    Ptr Word8 ->                            -- data : TCArray False (-1) (-1) (TBasicType TUInt8)+    CUInt ->                                -- colorspace : TInterface (Name {namespace = "GdkPixbuf", name = "Colorspace"})+    CInt ->                                 -- has_alpha : TBasicType TBoolean+    Int32 ->                                -- bits_per_sample : TBasicType TInt+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    Int32 ->                                -- rowstride : TBasicType TInt+    FunPtr GdkPixbuf.Callbacks.C_PixbufDestroyNotify -> -- destroy_fn : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufDestroyNotify"})+    Ptr () ->                               -- destroy_fn_data : TBasicType TPtr+    IO (Ptr Pixbuf)++{- |+Creates a new 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' out of in-memory image data.  Currently only RGB+images with 8 bits per sample are supported.++Since you are providing a pre-allocated pixel buffer, you must also+specify a way to free that data.  This is done with a function of+type 'GI.GdkPixbuf.Callbacks.PixbufDestroyNotify'.  When a pixbuf created with is+finalized, your destroy notification function will be called, and+it is its responsibility to free the pixel array.++See also 'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewFromBytes'.+-}+pixbufNewFromData ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Ptr Word8+    {- ^ /@data@/: Image data in 8-bit\/sample packed format -}+    -> GdkPixbuf.Enums.Colorspace+    {- ^ /@colorspace@/: Colorspace for the image data -}+    -> Bool+    {- ^ /@hasAlpha@/: Whether the data has an opacity channel -}+    -> Int32+    {- ^ /@bitsPerSample@/: Number of bits per sample -}+    -> Int32+    {- ^ /@width@/: Width of the image in pixels, must be > 0 -}+    -> Int32+    {- ^ /@height@/: Height of the image in pixels, must be > 0 -}+    -> Int32+    {- ^ /@rowstride@/: Distance in bytes between row starts -}+    -> Maybe (GdkPixbuf.Callbacks.PixbufDestroyNotify)+    {- ^ /@destroyFn@/: Function used to free the data when the pixbuf\'s reference count+drops to zero, or 'Nothing' if the data should not be freed -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' structure with a reference count of 1. -}+pixbufNewFromData data_ colorspace hasAlpha bitsPerSample width height rowstride destroyFn = liftIO $ do+    let colorspace' = (fromIntegral . fromEnum) colorspace+    let hasAlpha' = (fromIntegral . fromEnum) hasAlpha+    maybeDestroyFn <- case destroyFn of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jDestroyFn -> do+            ptrdestroyFn <- callocMem :: IO (Ptr (FunPtr GdkPixbuf.Callbacks.C_PixbufDestroyNotify))+            jDestroyFn' <- GdkPixbuf.Callbacks.mk_PixbufDestroyNotify (GdkPixbuf.Callbacks.wrap_PixbufDestroyNotify (Just ptrdestroyFn) (GdkPixbuf.Callbacks.drop_closures_PixbufDestroyNotify jDestroyFn))+            poke ptrdestroyFn jDestroyFn'+            return jDestroyFn'+    let destroyFnData = nullPtr+    result <- gdk_pixbuf_new_from_data data_ colorspace' hasAlpha' bitsPerSample width height rowstride maybeDestroyFn destroyFnData+    checkUnexpectedReturnNULL "pixbufNewFromData" result+    result' <- (wrapObject Pixbuf) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_file+-- method type : Constructor+-- Args : [Arg {argCName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of file to load, in the GLib file\n    name encoding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_file" gdk_pixbuf_new_from_file :: +    CString ->                              -- filename : TBasicType TFileName+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Pixbuf)++{- |+Creates a new pixbuf by loading an image from a file.  The file format is+detected automatically. If 'Nothing' is returned, then /@error@/ will be set.+Possible errors are in the @/GDK_PIXBUF_ERROR/@ and @/G_FILE_ERROR/@ domains.+-}+pixbufNewFromFile ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    [Char]+    {- ^ /@filename@/: Name of file to load, in the GLib file+    name encoding -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created pixbuf with a reference count of 1, or 'Nothing' if+any of several error conditions occurred:  the file could not be opened,+there was no loader for the file\'s format, there was not enough memory to+allocate the image buffer, or the image file contained invalid data. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufNewFromFile filename = liftIO $ do+    filename' <- stringToCString filename+    onException (do+        result <- propagateGError $ gdk_pixbuf_new_from_file filename'+        checkUnexpectedReturnNULL "pixbufNewFromFile" result+        result' <- (wrapObject Pixbuf) result+        freeMem filename'+        return result'+     ) (do+        freeMem filename'+     )++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_file_at_scale+-- method type : Constructor+-- Args : [Arg {argCName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of file to load, in the GLib file\n    name encoding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The width the image should have or -1 to not constrain the width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The height the image should have or -1 to not constrain the height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "preserve_aspect_ratio", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to preserve the image's aspect ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_file_at_scale" gdk_pixbuf_new_from_file_at_scale :: +    CString ->                              -- filename : TBasicType TFileName+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    CInt ->                                 -- preserve_aspect_ratio : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Pixbuf)++{- |+Creates a new pixbuf by loading an image from a file.  The file format is+detected automatically. If 'Nothing' is returned, then /@error@/ will be set.+Possible errors are in the @/GDK_PIXBUF_ERROR/@ and @/G_FILE_ERROR/@ domains.+The image will be scaled to fit in the requested size, optionally preserving+the image\'s aspect ratio.++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 2.8.++/Since: 2.6/+-}+pixbufNewFromFileAtScale ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    [Char]+    {- ^ /@filename@/: Name of file to load, in the GLib file+    name encoding -}+    -> Int32+    {- ^ /@width@/: The width the image should have or -1 to not constrain the width -}+    -> Int32+    {- ^ /@height@/: The height the image should have or -1 to not constrain the height -}+    -> Bool+    {- ^ /@preserveAspectRatio@/: 'True' to preserve the image\'s aspect ratio -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created pixbuf with a reference count of 1, or 'Nothing'+if any of several error conditions occurred:  the file could not be opened,+there was no loader for the file\'s format, there was not enough memory to+allocate the image buffer, or the image file contained invalid data. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufNewFromFileAtScale filename width height preserveAspectRatio = liftIO $ do+    filename' <- stringToCString filename+    let preserveAspectRatio' = (fromIntegral . fromEnum) preserveAspectRatio+    onException (do+        result <- propagateGError $ gdk_pixbuf_new_from_file_at_scale filename' width height preserveAspectRatio'+        checkUnexpectedReturnNULL "pixbufNewFromFileAtScale" result+        result' <- (wrapObject Pixbuf) result+        freeMem filename'+        return result'+     ) (do+        freeMem filename'+     )++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_file_at_size+-- method type : Constructor+-- Args : [Arg {argCName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of file to load, in the GLib file\n    name encoding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The width the image should have or -1 to not constrain the width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The height the image should have or -1 to not constrain the height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_file_at_size" gdk_pixbuf_new_from_file_at_size :: +    CString ->                              -- filename : TBasicType TFileName+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Pixbuf)++{- |+Creates a new pixbuf by loading an image from a file.+The file format is detected automatically. If 'Nothing' is returned, then+/@error@/ will be set. Possible errors are in the @/GDK_PIXBUF_ERROR/@ and+@/G_FILE_ERROR/@ domains.++The image will be scaled to fit in the requested size, preserving+the image\'s aspect ratio. Note that the returned pixbuf may be smaller+than /@width@/ x /@height@/, if the aspect ratio requires it. To load+and image at the requested size, regardless of aspect ratio, use+'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewFromFileAtScale'.++/Since: 2.4/+-}+pixbufNewFromFileAtSize ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    [Char]+    {- ^ /@filename@/: Name of file to load, in the GLib file+    name encoding -}+    -> Int32+    {- ^ /@width@/: The width the image should have or -1 to not constrain the width -}+    -> Int32+    {- ^ /@height@/: The height the image should have or -1 to not constrain the height -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created pixbuf with a reference count of 1, or+'Nothing' if any of several error conditions occurred:  the file could not+be opened, there was no loader for the file\'s format, there was not+enough memory to allocate the image buffer, or the image file contained+invalid data. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufNewFromFileAtSize filename width height = liftIO $ do+    filename' <- stringToCString filename+    onException (do+        result <- propagateGError $ gdk_pixbuf_new_from_file_at_size filename' width height+        checkUnexpectedReturnNULL "pixbufNewFromFileAtSize" result+        result' <- (wrapObject Pixbuf) result+        freeMem filename'+        return result'+     ) (do+        freeMem filename'+     )++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_inline+-- method type : Constructor+-- Args : [Arg {argCName = "data_length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length in bytes of the @data argument or -1 to\n   disable length checks", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 0 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Byte data containing a\n   serialized #GdkPixdata structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "copy_pixels", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether to copy the pixel data, or use direct pointers\n              @data for the resulting pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "data_length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length in bytes of the @data argument or -1 to\n   disable length checks", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_inline" gdk_pixbuf_new_from_inline :: +    Int32 ->                                -- data_length : TBasicType TInt+    Ptr Word8 ->                            -- data : TCArray False (-1) 0 (TBasicType TUInt8)+    CInt ->                                 -- copy_pixels : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Pixbuf)++{-# DEPRECATED pixbufNewFromInline ["(Since version 2.32)","Use 'GI.Gio.Structs.Resource.Resource' instead."] #-}+{- |+Create a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' from a flat representation that is suitable for+storing as inline data in a program. This is useful if you want to+ship a program with images, but don\'t want to depend on any+external files.++gdk-pixbuf ships with a program called [gdk-pixbuf-csource][gdk-pixbuf-csource],+which allows for conversion of @/GdkPixbufs/@ into such a inline representation.+In almost all cases, you should pass the @--raw@ option to+@gdk-pixbuf-csource@. A sample invocation would be:++>+> gdk-pixbuf-csource --raw --name=myimage_inline myimage.png+++For the typical case where the inline pixbuf is read-only static data,+you don\'t need to copy the pixel data unless you intend to write to+it, so you can pass 'False' for /@copyPixels@/.  (If you pass @--rle@ to+@gdk-pixbuf-csource@, a copy will be made even if /@copyPixels@/ is 'False',+so using this option is generally a bad idea.)++If you create a pixbuf from const inline data compiled into your+program, it\'s probably safe to ignore errors and disable length checks,+since things will always succeed:+>+>pixbuf = gdk_pixbuf_new_from_inline (-1, myimage_inline, FALSE, NULL);+++For non-const inline data, you could get out of memory. For untrusted+inline data located at runtime, you could have corrupt inline data in+addition.+-}+pixbufNewFromInline ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    ByteString+    {- ^ /@data@/: Byte data containing a+   serialized @/GdkPixdata/@ structure -}+    -> Bool+    {- ^ /@copyPixels@/: Whether to copy the pixel data, or use direct pointers+              /@data@/ for the resulting pixbuf -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' structure with a reference,+  count of 1, or 'Nothing' if an error occurred. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufNewFromInline data_ copyPixels = liftIO $ do+    let dataLength = fromIntegral $ B.length data_+    data_' <- packByteString data_+    let copyPixels' = (fromIntegral . fromEnum) copyPixels+    onException (do+        result <- propagateGError $ gdk_pixbuf_new_from_inline dataLength data_' copyPixels'+        checkUnexpectedReturnNULL "pixbufNewFromInline" result+        result' <- (wrapObject Pixbuf) result+        freeMem data_'+        return result'+     ) (do+        freeMem data_'+     )++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_resource+-- method type : Constructor+-- Args : [Arg {argCName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path of the resource file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_resource" gdk_pixbuf_new_from_resource :: +    CString ->                              -- resource_path : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Pixbuf)++{- |+Creates a new pixbuf by loading an image from an resource.++The file format is detected automatically. If 'Nothing' is returned, then+/@error@/ will be set.++/Since: 2.26/+-}+pixbufNewFromResource ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@resourcePath@/: the path of the resource file -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created pixbuf, or 'Nothing' if any of several error+conditions occurred: the file could not be opened, the image format is+not supported, there was not enough memory to allocate the image buffer,+the stream contained invalid data, or the operation was cancelled. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufNewFromResource resourcePath = liftIO $ do+    resourcePath' <- textToCString resourcePath+    onException (do+        result <- propagateGError $ gdk_pixbuf_new_from_resource resourcePath'+        checkUnexpectedReturnNULL "pixbufNewFromResource" result+        result' <- (wrapObject Pixbuf) result+        freeMem resourcePath'+        return result'+     ) (do+        freeMem resourcePath'+     )++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_resource_at_scale+-- method type : Constructor+-- Args : [Arg {argCName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path of the resource file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The width the image should have or -1 to not constrain the width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The height the image should have or -1 to not constrain the height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "preserve_aspect_ratio", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to preserve the image's aspect ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_resource_at_scale" gdk_pixbuf_new_from_resource_at_scale :: +    CString ->                              -- resource_path : TBasicType TUTF8+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    CInt ->                                 -- preserve_aspect_ratio : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Pixbuf)++{- |+Creates a new pixbuf by loading an image from an resource.++The file format is detected automatically. If 'Nothing' is returned, then+/@error@/ will be set.++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.++The stream is not closed.++/Since: 2.26/+-}+pixbufNewFromResourceAtScale ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@resourcePath@/: the path of the resource file -}+    -> Int32+    {- ^ /@width@/: The width the image should have or -1 to not constrain the width -}+    -> Int32+    {- ^ /@height@/: The height the image should have or -1 to not constrain the height -}+    -> Bool+    {- ^ /@preserveAspectRatio@/: 'True' to preserve the image\'s aspect ratio -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created pixbuf, or 'Nothing' if any of several error+conditions occurred: the file could not be opened, the image format is+not supported, there was not enough memory to allocate the image buffer,+the stream contained invalid data, or the operation was cancelled. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufNewFromResourceAtScale resourcePath width height preserveAspectRatio = liftIO $ do+    resourcePath' <- textToCString resourcePath+    let preserveAspectRatio' = (fromIntegral . fromEnum) preserveAspectRatio+    onException (do+        result <- propagateGError $ gdk_pixbuf_new_from_resource_at_scale resourcePath' width height preserveAspectRatio'+        checkUnexpectedReturnNULL "pixbufNewFromResourceAtScale" result+        result' <- (wrapObject Pixbuf) result+        freeMem resourcePath'+        return result'+     ) (do+        freeMem resourcePath'+     )++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_stream+-- method type : Constructor+-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream to load the pixbuf from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_stream" gdk_pixbuf_new_from_stream :: +    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Pixbuf)++{- |+Creates a new pixbuf by loading an image from an input stream.++The file format is detected automatically. If 'Nothing' is returned, then+/@error@/ will be set. The /@cancellable@/ can be used to abort the operation+from another thread. If the operation was cancelled, the error+'GI.Gio.Enums.IOErrorEnumCancelled' will be returned. Other possible errors are in+the @/GDK_PIXBUF_ERROR/@ and @/G_IO_ERROR/@ domains.++The stream is not closed.++/Since: 2.14/+-}+pixbufNewFromStream ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>+    a+    {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream' to load the pixbuf from -}+    -> Maybe (b)+    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created pixbuf, or 'Nothing' if any of several error+conditions occurred: the file could not be opened, the image format is+not supported, there was not enough memory to allocate the image buffer,+the stream contained invalid data, or the operation was cancelled. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufNewFromStream stream cancellable = liftIO $ do+    stream' <- unsafeManagedPtrCastPtr stream+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ gdk_pixbuf_new_from_stream stream' maybeCancellable+        checkUnexpectedReturnNULL "pixbufNewFromStream" result+        result' <- (wrapObject Pixbuf) result+        touchManagedPtr stream+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_stream_at_scale+-- method type : Constructor+-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream to load the pixbuf from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The width the image should have or -1 to not constrain the width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The height the image should have or -1 to not constrain the height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "preserve_aspect_ratio", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to preserve the image's aspect ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_stream_at_scale" gdk_pixbuf_new_from_stream_at_scale :: +    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    CInt ->                                 -- preserve_aspect_ratio : TBasicType TBoolean+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Pixbuf)++{- |+Creates a new pixbuf by loading an image from an input stream.++The file format is detected automatically. If 'Nothing' is returned, then+/@error@/ will be set. The /@cancellable@/ can be used to abort the operation+from another thread. If the operation was cancelled, the error+'GI.Gio.Enums.IOErrorEnumCancelled' will be returned. Other possible errors are in+the @/GDK_PIXBUF_ERROR/@ and @/G_IO_ERROR/@ domains.++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. If both /@width@/ and /@height@/ are+given, this function will behave as if the smaller of the two values+is passed as -1.++When not preserving aspect ratio, a /@width@/ or /@height@/ of -1 means to not+scale the image at all in that dimension.++The stream is not closed.++/Since: 2.14/+-}+pixbufNewFromStreamAtScale ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>+    a+    {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream' to load the pixbuf from -}+    -> Int32+    {- ^ /@width@/: The width the image should have or -1 to not constrain the width -}+    -> Int32+    {- ^ /@height@/: The height the image should have or -1 to not constrain the height -}+    -> Bool+    {- ^ /@preserveAspectRatio@/: 'True' to preserve the image\'s aspect ratio -}+    -> Maybe (b)+    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created pixbuf, or 'Nothing' if any of several error+conditions occurred: the file could not be opened, the image format is+not supported, there was not enough memory to allocate the image buffer,+the stream contained invalid data, or the operation was cancelled. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufNewFromStreamAtScale stream width height preserveAspectRatio cancellable = liftIO $ do+    stream' <- unsafeManagedPtrCastPtr stream+    let preserveAspectRatio' = (fromIntegral . fromEnum) preserveAspectRatio+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ gdk_pixbuf_new_from_stream_at_scale stream' width height preserveAspectRatio' maybeCancellable+        checkUnexpectedReturnNULL "pixbufNewFromStreamAtScale" result+        result' <- (wrapObject Pixbuf) result+        touchManagedPtr stream+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_stream_finish+-- method type : Constructor+-- Args : [Arg {argCName = "async_result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_stream_finish" gdk_pixbuf_new_from_stream_finish :: +    Ptr Gio.AsyncResult.AsyncResult ->      -- async_result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Pixbuf)++{- |+Finishes an asynchronous pixbuf creation operation started with+'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewFromStreamAsync'.++/Since: 2.24/+-}+pixbufNewFromStreamFinish ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>+    a+    {- ^ /@asyncResult@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}+    -> m Pixbuf+    {- ^ __Returns:__ a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' or 'Nothing' on error. Free the returned+object with 'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufNewFromStreamFinish asyncResult = liftIO $ do+    asyncResult' <- unsafeManagedPtrCastPtr asyncResult+    onException (do+        result <- propagateGError $ gdk_pixbuf_new_from_stream_finish asyncResult'+        checkUnexpectedReturnNULL "pixbufNewFromStreamFinish" result+        result' <- (wrapObject Pixbuf) result+        touchManagedPtr asyncResult+        return result'+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_xpm_data+-- method type : Constructor+-- Args : [Arg {argCName = "data", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to inline XPM data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_xpm_data" gdk_pixbuf_new_from_xpm_data :: +    Ptr CString ->                          -- data : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO (Ptr Pixbuf)++{- |+Creates a new pixbuf by parsing XPM data in memory.  This data is commonly+the result of including an XPM file into a program\'s C source.+-}+pixbufNewFromXpmData ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    [T.Text]+    {- ^ /@data@/: Pointer to inline XPM data. -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created pixbuf with a reference count of 1. -}+pixbufNewFromXpmData data_ = liftIO $ do+    data_' <- packZeroTerminatedUTF8CArray data_+    result <- gdk_pixbuf_new_from_xpm_data data_'+    checkUnexpectedReturnNULL "pixbufNewFromXpmData" result+    result' <- (wrapObject Pixbuf) result+    mapZeroTerminatedCArray freeMem data_'+    freeMem data_'+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::add_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GdkPixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "substitute_color", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether to set a color to zero opacity.  If this\nis %FALSE, then the (@r, @g, @b) arguments will be ignored.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "r", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Red value to substitute.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "g", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Green value to substitute.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Blue value to substitute.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_add_alpha" gdk_pixbuf_add_alpha :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    CInt ->                                 -- substitute_color : TBasicType TBoolean+    Word8 ->                                -- r : TBasicType TUInt8+    Word8 ->                                -- g : TBasicType TUInt8+    Word8 ->                                -- b : TBasicType TUInt8+    IO (Ptr Pixbuf)++{- |+Takes an existing pixbuf and adds an alpha channel to it.+If the existing pixbuf already had an alpha channel, the channel+values are copied from the original; otherwise, the alpha channel+is initialized to 255 (full opacity).++If /@substituteColor@/ is 'True', then the color specified by (/@r@/, /@g@/, /@b@/) will be+assigned zero opacity. That is, if you pass (255, 255, 255) for the+substitute color, all white pixels will become fully transparent.+-}+pixbufAddAlpha ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'. -}+    -> Bool+    {- ^ /@substituteColor@/: Whether to set a color to zero opacity.  If this+is 'False', then the (/@r@/, /@g@/, /@b@/) arguments will be ignored. -}+    -> Word8+    {- ^ /@r@/: Red value to substitute. -}+    -> Word8+    {- ^ /@g@/: Green value to substitute. -}+    -> Word8+    {- ^ /@b@/: Blue value to substitute. -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created pixbuf with a reference count of 1. -}+pixbufAddAlpha pixbuf substituteColor r g b = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    let substituteColor' = (fromIntegral . fromEnum) substituteColor+    result <- gdk_pixbuf_add_alpha pixbuf' substituteColor' r g b+    checkUnexpectedReturnNULL "pixbufAddAlpha" result+    result' <- (wrapObject Pixbuf) result+    touchManagedPtr pixbuf+    return result'++#if ENABLE_OVERLOADING+data PixbufAddAlphaMethodInfo+instance (signature ~ (Bool -> Word8 -> Word8 -> Word8 -> m Pixbuf), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufAddAlphaMethodInfo a signature where+    overloadedMethod _ = pixbufAddAlpha++#endif++-- method Pixbuf::apply_embedded_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GdkPixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_apply_embedded_orientation" gdk_pixbuf_apply_embedded_orientation :: +    Ptr Pixbuf ->                           -- src : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO (Ptr Pixbuf)++{- |+Takes an existing pixbuf and checks for the presence of an+associated \"orientation\" option, which may be provided by the+jpeg loader (which reads the exif orientation tag) or the+tiff loader (which reads the tiff orientation tag, and+compensates it for the partial transforms performed by+libtiff). If an orientation option\/tag is present, the+appropriate transform will be performed so that the pixbuf+is oriented correctly.++/Since: 2.12/+-}+pixbufApplyEmbeddedOrientation ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@src@/: A 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'. -}+    -> m Pixbuf+    {- ^ __Returns:__ A newly-created pixbuf, 'Nothing' if+not enough memory could be allocated for it, or a reference to the+input pixbuf (with an increased reference count). -}+pixbufApplyEmbeddedOrientation src = liftIO $ do+    src' <- unsafeManagedPtrCastPtr src+    result <- gdk_pixbuf_apply_embedded_orientation src'+    checkUnexpectedReturnNULL "pixbufApplyEmbeddedOrientation" result+    result' <- (wrapObject Pixbuf) result+    touchManagedPtr src+    return result'++#if ENABLE_OVERLOADING+data PixbufApplyEmbeddedOrientationMethodInfo+instance (signature ~ (m Pixbuf), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufApplyEmbeddedOrientationMethodInfo a signature where+    overloadedMethod _ = pixbufApplyEmbeddedOrientation++#endif++-- method Pixbuf::composite+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkPixbuf into which to render the results", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the left coordinate for region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the top coordinate for region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width of the region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height of the region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset_x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the offset in the X direction (currently rounded to an integer)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset_y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the offset in the Y direction (currently rounded to an integer)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale_x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the scale factor in the X direction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale_y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the scale factor in the Y direction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interp_type", argType = TInterface (Name {namespace = "GdkPixbuf", name = "InterpType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the interpolation type for the transformation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "overall_alpha", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "overall alpha for source image (0..255)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_composite" gdk_pixbuf_composite :: +    Ptr Pixbuf ->                           -- src : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Ptr Pixbuf ->                           -- dest : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Int32 ->                                -- dest_x : TBasicType TInt+    Int32 ->                                -- dest_y : TBasicType TInt+    Int32 ->                                -- dest_width : TBasicType TInt+    Int32 ->                                -- dest_height : TBasicType TInt+    CDouble ->                              -- offset_x : TBasicType TDouble+    CDouble ->                              -- offset_y : TBasicType TDouble+    CDouble ->                              -- scale_x : TBasicType TDouble+    CDouble ->                              -- scale_y : TBasicType TDouble+    CUInt ->                                -- interp_type : TInterface (Name {namespace = "GdkPixbuf", name = "InterpType"})+    Int32 ->                                -- overall_alpha : TBasicType TInt+    IO ()++{- |+Creates a transformation of the source image /@src@/ by scaling by+/@scaleX@/ and /@scaleY@/ then translating by /@offsetX@/ and /@offsetY@/.+This gives an image in the coordinates of the destination pixbuf.+The rectangle (/@destX@/, /@destY@/, /@destWidth@/, /@destHeight@/)+is then alpha blended onto the corresponding rectangle of the+original destination image.++When the destination rectangle contains parts not in the source+image, the data at the edges of the source image is replicated+to infinity.++<<http://developer.gnome.org/gdkpixbuf/stable/composite.png>>+-}+pixbufComposite ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a, IsPixbuf b) =>+    a+    {- ^ /@src@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> b+    {- ^ /@dest@/: the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' into which to render the results -}+    -> Int32+    {- ^ /@destX@/: the left coordinate for region to render -}+    -> Int32+    {- ^ /@destY@/: the top coordinate for region to render -}+    -> Int32+    {- ^ /@destWidth@/: the width of the region to render -}+    -> Int32+    {- ^ /@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 -}+    -> GdkPixbuf.Enums.InterpType+    {- ^ /@interpType@/: the interpolation type for the transformation. -}+    -> Int32+    {- ^ /@overallAlpha@/: overall alpha for source image (0..255) -}+    -> m ()+pixbufComposite src dest destX destY destWidth destHeight offsetX offsetY scaleX scaleY interpType overallAlpha = liftIO $ do+    src' <- unsafeManagedPtrCastPtr src+    dest' <- unsafeManagedPtrCastPtr dest+    let offsetX' = realToFrac offsetX+    let offsetY' = realToFrac offsetY+    let scaleX' = realToFrac scaleX+    let scaleY' = realToFrac scaleY+    let interpType' = (fromIntegral . fromEnum) interpType+    gdk_pixbuf_composite src' dest' destX destY destWidth destHeight offsetX' offsetY' scaleX' scaleY' interpType' overallAlpha+    touchManagedPtr src+    touchManagedPtr dest+    return ()++#if ENABLE_OVERLOADING+data PixbufCompositeMethodInfo+instance (signature ~ (b -> Int32 -> Int32 -> Int32 -> Int32 -> Double -> Double -> Double -> Double -> GdkPixbuf.Enums.InterpType -> Int32 -> m ()), MonadIO m, IsPixbuf a, IsPixbuf b) => O.MethodInfo PixbufCompositeMethodInfo a signature where+    overloadedMethod _ = pixbufComposite++#endif++-- method Pixbuf::composite_color+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkPixbuf into which to render the results", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the left coordinate for region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the top coordinate for region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width of the region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height of the region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset_x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the offset in the X direction (currently rounded to an integer)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset_y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the offset in the Y direction (currently rounded to an integer)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale_x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the scale factor in the X direction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale_y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the scale factor in the Y direction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interp_type", argType = TInterface (Name {namespace = "GdkPixbuf", name = "InterpType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the interpolation type for the transformation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "overall_alpha", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "overall alpha for source image (0..255)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "check_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X offset for the checkboard (origin of checkboard is at -@check_x, -@check_y)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "check_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the Y offset for the checkboard", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "check_size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of checks in the checkboard (must be a power of two)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color1", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the color of check at upper left", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color2", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the color of the other check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_composite_color" gdk_pixbuf_composite_color :: +    Ptr Pixbuf ->                           -- src : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Ptr Pixbuf ->                           -- dest : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Int32 ->                                -- dest_x : TBasicType TInt+    Int32 ->                                -- dest_y : TBasicType TInt+    Int32 ->                                -- dest_width : TBasicType TInt+    Int32 ->                                -- dest_height : TBasicType TInt+    CDouble ->                              -- offset_x : TBasicType TDouble+    CDouble ->                              -- offset_y : TBasicType TDouble+    CDouble ->                              -- scale_x : TBasicType TDouble+    CDouble ->                              -- scale_y : TBasicType TDouble+    CUInt ->                                -- interp_type : TInterface (Name {namespace = "GdkPixbuf", name = "InterpType"})+    Int32 ->                                -- overall_alpha : TBasicType TInt+    Int32 ->                                -- check_x : TBasicType TInt+    Int32 ->                                -- check_y : TBasicType TInt+    Int32 ->                                -- check_size : TBasicType TInt+    Word32 ->                               -- color1 : TBasicType TUInt32+    Word32 ->                               -- color2 : TBasicType TUInt32+    IO ()++{- |+Creates a transformation of the source image /@src@/ by scaling by+/@scaleX@/ and /@scaleY@/ then translating by /@offsetX@/ and /@offsetY@/,+then alpha blends the rectangle (/@destX@/ ,/@destY@/, /@destWidth@/,+/@destHeight@/) of the resulting image with a checkboard of the+colors /@color1@/ and /@color2@/ and renders it onto the destination+image.++If the source image has no alpha channel, and /@overallAlpha@/ is 255, a fast+path is used which omits the alpha blending and just performs the scaling.++See 'GI.GdkPixbuf.Objects.Pixbuf.pixbufCompositeColorSimple' for a simpler variant of this+function suitable for many tasks.+-}+pixbufCompositeColor ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a, IsPixbuf b) =>+    a+    {- ^ /@src@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> b+    {- ^ /@dest@/: the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' into which to render the results -}+    -> Int32+    {- ^ /@destX@/: the left coordinate for region to render -}+    -> Int32+    {- ^ /@destY@/: the top coordinate for region to render -}+    -> Int32+    {- ^ /@destWidth@/: the width of the region to render -}+    -> Int32+    {- ^ /@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 -}+    -> GdkPixbuf.Enums.InterpType+    {- ^ /@interpType@/: the interpolation type for the transformation. -}+    -> Int32+    {- ^ /@overallAlpha@/: overall alpha for source image (0..255) -}+    -> Int32+    {- ^ /@checkX@/: the X offset for the checkboard (origin of checkboard is at -/@checkX@/, -/@checkY@/) -}+    -> Int32+    {- ^ /@checkY@/: the Y offset for the checkboard -}+    -> Int32+    {- ^ /@checkSize@/: the size of checks in the checkboard (must be a power of two) -}+    -> Word32+    {- ^ /@color1@/: the color of check at upper left -}+    -> Word32+    {- ^ /@color2@/: the color of the other check -}+    -> m ()+pixbufCompositeColor src dest destX destY destWidth destHeight offsetX offsetY scaleX scaleY interpType overallAlpha checkX checkY checkSize color1 color2 = liftIO $ do+    src' <- unsafeManagedPtrCastPtr src+    dest' <- unsafeManagedPtrCastPtr dest+    let offsetX' = realToFrac offsetX+    let offsetY' = realToFrac offsetY+    let scaleX' = realToFrac scaleX+    let scaleY' = realToFrac scaleY+    let interpType' = (fromIntegral . fromEnum) interpType+    gdk_pixbuf_composite_color src' dest' destX destY destWidth destHeight offsetX' offsetY' scaleX' scaleY' interpType' overallAlpha checkX checkY checkSize color1 color2+    touchManagedPtr src+    touchManagedPtr dest+    return ()++#if ENABLE_OVERLOADING+data PixbufCompositeColorMethodInfo+instance (signature ~ (b -> Int32 -> Int32 -> Int32 -> Int32 -> Double -> Double -> Double -> Double -> GdkPixbuf.Enums.InterpType -> Int32 -> Int32 -> Int32 -> Int32 -> Word32 -> Word32 -> m ()), MonadIO m, IsPixbuf a, IsPixbuf b) => O.MethodInfo PixbufCompositeColorMethodInfo a signature where+    overloadedMethod _ = pixbufCompositeColor++#endif++-- method Pixbuf::composite_color_simple+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width of destination image", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height of destination image", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interp_type", argType = TInterface (Name {namespace = "GdkPixbuf", name = "InterpType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the interpolation type for the transformation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "overall_alpha", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "overall alpha for source image (0..255)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "check_size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of checks in the checkboard (must be a power of two)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color1", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the color of check at upper left", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color2", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the color of the other check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_composite_color_simple" gdk_pixbuf_composite_color_simple :: +    Ptr Pixbuf ->                           -- src : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Int32 ->                                -- dest_width : TBasicType TInt+    Int32 ->                                -- dest_height : TBasicType TInt+    CUInt ->                                -- interp_type : TInterface (Name {namespace = "GdkPixbuf", name = "InterpType"})+    Int32 ->                                -- overall_alpha : TBasicType TInt+    Int32 ->                                -- check_size : TBasicType TInt+    Word32 ->                               -- color1 : TBasicType TUInt32+    Word32 ->                               -- color2 : TBasicType TUInt32+    IO (Ptr Pixbuf)++{- |+Creates a new 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' by scaling /@src@/ to /@destWidth@/ x+/@destHeight@/ and alpha blending the result with a checkboard of colors+/@color1@/ and /@color2@/.+-}+pixbufCompositeColorSimple ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@src@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> Int32+    {- ^ /@destWidth@/: the width of destination image -}+    -> Int32+    {- ^ /@destHeight@/: the height of destination image -}+    -> GdkPixbuf.Enums.InterpType+    {- ^ /@interpType@/: the interpolation type for the transformation. -}+    -> Int32+    {- ^ /@overallAlpha@/: overall alpha for source image (0..255) -}+    -> Int32+    {- ^ /@checkSize@/: the size of checks in the checkboard (must be a power of two) -}+    -> Word32+    {- ^ /@color1@/: the color of check at upper left -}+    -> Word32+    {- ^ /@color2@/: the color of the other check -}+    -> m (Maybe Pixbuf)+    {- ^ __Returns:__ the new 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf', or 'Nothing' if not enough memory could be+allocated for it. -}+pixbufCompositeColorSimple src destWidth destHeight interpType overallAlpha checkSize color1 color2 = liftIO $ do+    src' <- unsafeManagedPtrCastPtr src+    let interpType' = (fromIntegral . fromEnum) interpType+    result <- gdk_pixbuf_composite_color_simple src' destWidth destHeight interpType' overallAlpha checkSize color1 color2+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (wrapObject Pixbuf) result'+        return result''+    touchManagedPtr src+    return maybeResult++#if ENABLE_OVERLOADING+data PixbufCompositeColorSimpleMethodInfo+instance (signature ~ (Int32 -> Int32 -> GdkPixbuf.Enums.InterpType -> Int32 -> Int32 -> Word32 -> Word32 -> m (Maybe Pixbuf)), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufCompositeColorSimpleMethodInfo a signature where+    overloadedMethod _ = pixbufCompositeColorSimple++#endif++-- method Pixbuf::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_copy" gdk_pixbuf_copy :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO (Ptr Pixbuf)++{- |+Creates a new 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' with a copy of the information in the specified+/@pixbuf@/. Note that this does not copy the options set on the original 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf',+use 'GI.GdkPixbuf.Objects.Pixbuf.pixbufCopyOptions' for this.+-}+pixbufCopy ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf. -}+    -> m (Maybe Pixbuf)+    {- ^ __Returns:__ A newly-created pixbuf with a reference count of 1, or 'Nothing' if+not enough memory could be allocated. -}+pixbufCopy pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    result <- gdk_pixbuf_copy pixbuf'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (wrapObject Pixbuf) result'+        return result''+    touchManagedPtr pixbuf+    return maybeResult++#if ENABLE_OVERLOADING+data PixbufCopyMethodInfo+instance (signature ~ (m (Maybe Pixbuf)), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufCopyMethodInfo a signature where+    overloadedMethod _ = pixbufCopy++#endif++-- method Pixbuf::copy_area+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src_pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source X coordinate within @src_pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Source Y coordinate within @src_pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Width of the area to copy.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Height of the area to copy.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Destination pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate within @dest_pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate within @dest_pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_copy_area" gdk_pixbuf_copy_area :: +    Ptr Pixbuf ->                           -- src_pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Int32 ->                                -- src_x : TBasicType TInt+    Int32 ->                                -- src_y : TBasicType TInt+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    Ptr Pixbuf ->                           -- dest_pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Int32 ->                                -- dest_x : TBasicType TInt+    Int32 ->                                -- dest_y : TBasicType TInt+    IO ()++{- |+Copies a rectangular area from /@srcPixbuf@/ to /@destPixbuf@/.  Conversion of+pixbuf formats is done automatically.++If the source rectangle overlaps the destination rectangle on the+same pixbuf, it will be overwritten during the copy operation.+Therefore, you can not use this function to scroll a pixbuf.+-}+pixbufCopyArea ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a, IsPixbuf b) =>+    a+    {- ^ /@srcPixbuf@/: Source pixbuf. -}+    -> Int32+    {- ^ /@srcX@/: Source X coordinate within /@srcPixbuf@/. -}+    -> Int32+    {- ^ /@srcY@/: Source Y coordinate within /@srcPixbuf@/. -}+    -> Int32+    {- ^ /@width@/: Width of the area to copy. -}+    -> Int32+    {- ^ /@height@/: Height of the area to copy. -}+    -> b+    {- ^ /@destPixbuf@/: Destination pixbuf. -}+    -> Int32+    {- ^ /@destX@/: X coordinate within /@destPixbuf@/. -}+    -> Int32+    {- ^ /@destY@/: Y coordinate within /@destPixbuf@/. -}+    -> m ()+pixbufCopyArea srcPixbuf srcX srcY width height destPixbuf destX destY = liftIO $ do+    srcPixbuf' <- unsafeManagedPtrCastPtr srcPixbuf+    destPixbuf' <- unsafeManagedPtrCastPtr destPixbuf+    gdk_pixbuf_copy_area srcPixbuf' srcX srcY width height destPixbuf' destX destY+    touchManagedPtr srcPixbuf+    touchManagedPtr destPixbuf+    return ()++#if ENABLE_OVERLOADING+data PixbufCopyAreaMethodInfo+instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> b -> Int32 -> Int32 -> m ()), MonadIO m, IsPixbuf a, IsPixbuf b) => O.MethodInfo PixbufCopyAreaMethodInfo a signature where+    overloadedMethod _ = pixbufCopyArea++#endif++-- method Pixbuf::copy_options+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src_pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf to copy options from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkPixbuf to copy options to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_copy_options" gdk_pixbuf_copy_options :: +    Ptr Pixbuf ->                           -- src_pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Ptr Pixbuf ->                           -- dest_pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO CInt++{- |+Copy the key\/value pair options attached to a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' to another.+This is useful to keep original metadata after having manipulated+a file. However be careful to remove metadata which you\'ve already+applied, such as the \"orientation\" option after rotating the image.++/Since: 2.36/+-}+pixbufCopyOptions ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a, IsPixbuf b) =>+    a+    {- ^ /@srcPixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' to copy options from -}+    -> b+    {- ^ /@destPixbuf@/: the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' to copy options to -}+    -> m Bool+    {- ^ __Returns:__ 'True' on success. -}+pixbufCopyOptions srcPixbuf destPixbuf = liftIO $ do+    srcPixbuf' <- unsafeManagedPtrCastPtr srcPixbuf+    destPixbuf' <- unsafeManagedPtrCastPtr destPixbuf+    result <- gdk_pixbuf_copy_options srcPixbuf' destPixbuf'+    let result' = (/= 0) result+    touchManagedPtr srcPixbuf+    touchManagedPtr destPixbuf+    return result'++#if ENABLE_OVERLOADING+data PixbufCopyOptionsMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, IsPixbuf a, IsPixbuf b) => O.MethodInfo PixbufCopyOptionsMethodInfo a signature where+    overloadedMethod _ = pixbufCopyOptions++#endif++-- method Pixbuf::fill+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pixel", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "RGBA pixel to clear to\n        (0xffffffff is opaque white, 0x00000000 transparent black)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_fill" gdk_pixbuf_fill :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Word32 ->                               -- pixel : TBasicType TUInt32+    IO ()++{- |+Clears a pixbuf to the given RGBA value, converting the RGBA value into+the pixbuf\'s pixel format. The alpha will be ignored if the pixbuf+doesn\'t have an alpha channel.+-}+pixbufFill ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> Word32+    {- ^ /@pixel@/: RGBA pixel to clear to+        (0xffffffff is opaque white, 0x00000000 transparent black) -}+    -> m ()+pixbufFill pixbuf pixel = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    gdk_pixbuf_fill pixbuf' pixel+    touchManagedPtr pixbuf+    return ()++#if ENABLE_OVERLOADING+data PixbufFillMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufFillMethodInfo a signature where+    overloadedMethod _ = pixbufFill++#endif++-- method Pixbuf::flip+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "horizontal", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to flip horizontally, %FALSE to flip vertically", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_flip" gdk_pixbuf_flip :: +    Ptr Pixbuf ->                           -- src : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    CInt ->                                 -- horizontal : TBasicType TBoolean+    IO (Ptr Pixbuf)++{- |+Flips a pixbuf horizontally or vertically and returns the+result in a new pixbuf.++/Since: 2.6/+-}+pixbufFlip ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@src@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> Bool+    {- ^ /@horizontal@/: 'True' to flip horizontally, 'False' to flip vertically -}+    -> m (Maybe Pixbuf)+    {- ^ __Returns:__ the new 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf', or 'Nothing'+if not enough memory could be allocated for it. -}+pixbufFlip src horizontal = liftIO $ do+    src' <- unsafeManagedPtrCastPtr src+    let horizontal' = (fromIntegral . fromEnum) horizontal+    result <- gdk_pixbuf_flip src' horizontal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (wrapObject Pixbuf) result'+        return result''+    touchManagedPtr src+    return maybeResult++#if ENABLE_OVERLOADING+data PixbufFlipMethodInfo+instance (signature ~ (Bool -> m (Maybe Pixbuf)), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufFlipMethodInfo a signature where+    overloadedMethod _ = pixbufFlip++#endif++-- method Pixbuf::get_bits_per_sample+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_bits_per_sample" gdk_pixbuf_get_bits_per_sample :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO Int32++{- |+Queries the number of bits per color sample in a pixbuf.+-}+pixbufGetBitsPerSample ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf. -}+    -> m Int32+    {- ^ __Returns:__ Number of bits per color sample. -}+pixbufGetBitsPerSample pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    result <- gdk_pixbuf_get_bits_per_sample pixbuf'+    touchManagedPtr pixbuf+    return result++#if ENABLE_OVERLOADING+data PixbufGetBitsPerSampleMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufGetBitsPerSampleMethodInfo a signature where+    overloadedMethod _ = pixbufGetBitsPerSample++#endif++-- method Pixbuf::get_byte_length+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt64)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_byte_length" gdk_pixbuf_get_byte_length :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO Word64++{- |+Returns the length of the pixel data, in bytes.++/Since: 2.26/+-}+pixbufGetByteLength ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf -}+    -> m Word64+    {- ^ __Returns:__ The length of the pixel data. -}+pixbufGetByteLength pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    result <- gdk_pixbuf_get_byte_length pixbuf'+    touchManagedPtr pixbuf+    return result++#if ENABLE_OVERLOADING+data PixbufGetByteLengthMethodInfo+instance (signature ~ (m Word64), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufGetByteLengthMethodInfo a signature where+    overloadedMethod _ = pixbufGetByteLength++#endif++-- method Pixbuf::get_colorspace+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Colorspace"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_colorspace" gdk_pixbuf_get_colorspace :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO CUInt++{- |+Queries the color space of a pixbuf.+-}+pixbufGetColorspace ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf. -}+    -> m GdkPixbuf.Enums.Colorspace+    {- ^ __Returns:__ Color space. -}+pixbufGetColorspace pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    result <- gdk_pixbuf_get_colorspace pixbuf'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr pixbuf+    return result'++#if ENABLE_OVERLOADING+data PixbufGetColorspaceMethodInfo+instance (signature ~ (m GdkPixbuf.Enums.Colorspace), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufGetColorspaceMethodInfo a signature where+    overloadedMethod _ = pixbufGetColorspace++#endif++-- method Pixbuf::get_has_alpha+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_has_alpha" gdk_pixbuf_get_has_alpha :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO CInt++{- |+Queries whether a pixbuf has an alpha channel (opacity information).+-}+pixbufGetHasAlpha ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if it has an alpha channel, 'False' otherwise. -}+pixbufGetHasAlpha pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    result <- gdk_pixbuf_get_has_alpha pixbuf'+    let result' = (/= 0) result+    touchManagedPtr pixbuf+    return result'++#if ENABLE_OVERLOADING+data PixbufGetHasAlphaMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufGetHasAlphaMethodInfo a signature where+    overloadedMethod _ = pixbufGetHasAlpha++#endif++-- method Pixbuf::get_height+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_height" gdk_pixbuf_get_height :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO Int32++{- |+Queries the height of a pixbuf.+-}+pixbufGetHeight ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf. -}+    -> m Int32+    {- ^ __Returns:__ Height in pixels. -}+pixbufGetHeight pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    result <- gdk_pixbuf_get_height pixbuf'+    touchManagedPtr pixbuf+    return result++#if ENABLE_OVERLOADING+data PixbufGetHeightMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufGetHeightMethodInfo a signature where+    overloadedMethod _ = pixbufGetHeight++#endif++-- method Pixbuf::get_n_channels+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_n_channels" gdk_pixbuf_get_n_channels :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO Int32++{- |+Queries the number of channels of a pixbuf.+-}+pixbufGetNChannels ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf. -}+    -> m Int32+    {- ^ __Returns:__ Number of channels. -}+pixbufGetNChannels pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    result <- gdk_pixbuf_get_n_channels pixbuf'+    touchManagedPtr pixbuf+    return result++#if ENABLE_OVERLOADING+data PixbufGetNChannelsMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufGetNChannelsMethodInfo a signature where+    overloadedMethod _ = pixbufGetNChannels++#endif++-- method Pixbuf::get_option+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a nul-terminated string.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_option" gdk_pixbuf_get_option :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    CString ->                              -- key : TBasicType TUTF8+    IO CString++{- |+Looks up /@key@/ in the list of options that may have been attached to the+/@pixbuf@/ when it was loaded, or that may have been attached by another+function using 'GI.GdkPixbuf.Objects.Pixbuf.pixbufSetOption'.++For instance, the ANI loader provides \"Title\" and \"Artist\" options.+The ICO, XBM, and XPM loaders provide \"x_hot\" and \"y_hot\" hot-spot+options for cursor definitions. The PNG loader provides the tEXt ancillary+chunk key\/value pairs as options. Since 2.12, the TIFF and JPEG loaders+return an \"orientation\" option string that corresponds to the embedded+TIFF\/Exif orientation tag (if present). Since 2.32, the TIFF loader sets+the \"multipage\" option string to \"yes\" when a multi-page TIFF is loaded.+Since 2.32 the JPEG and PNG loaders set \"x-dpi\" and \"y-dpi\" if the file+contains image density information in dots per inch.+Since 2.36.6, the JPEG loader sets the \"comment\" option with the comment+EXIF tag.+-}+pixbufGetOption ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> T.Text+    {- ^ /@key@/: a nul-terminated string. -}+    -> m T.Text+    {- ^ __Returns:__ the value associated with /@key@/. This is a nul-terminated+string that should not be freed or 'Nothing' if /@key@/ was not found. -}+pixbufGetOption pixbuf key = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    key' <- textToCString key+    result <- gdk_pixbuf_get_option pixbuf' key'+    checkUnexpectedReturnNULL "pixbufGetOption" result+    result' <- cstringToText result+    touchManagedPtr pixbuf+    freeMem key'+    return result'++#if ENABLE_OVERLOADING+data PixbufGetOptionMethodInfo+instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufGetOptionMethodInfo a signature where+    overloadedMethod _ = pixbufGetOption++#endif++-- XXX Could not generate method Pixbuf::get_options+-- Error was : Not implemented: "Hash table argument with transfer = Container? result"+#if ENABLE_OVERLOADING+-- XXX: Dummy instance, since code generation failed.+-- Please file a bug at http://github.com/haskell-gi/haskell-gi.+data PixbufGetOptionsMethodInfo+instance (p ~ (), o ~ O.MethodResolutionFailed "getOptions" Pixbuf) => O.MethodInfo PixbufGetOptionsMethodInfo o p where+    overloadedMethod _ = undefined+#endif++-- method Pixbuf::get_pixels+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of the binary data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of the binary data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- returnType : Just (TCArray False (-1) 1 (TBasicType TUInt8))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_pixels_with_length" gdk_pixbuf_get_pixels_with_length :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Ptr Word32 ->                           -- length : TBasicType TUInt+    IO (Ptr Word8)++{- |+Queries a pointer to the pixel data of a pixbuf.++/Since: 2.26/+-}+pixbufGetPixels ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf. -}+    -> m ByteString+    {- ^ __Returns:__ A pointer to the pixbuf\'s+pixel data.  Please see the section on [image data][image-data]+for information about how the pixel data is stored in memory.++This function will cause an implicit copy of the pixbuf data if the+pixbuf was created from read-only data. -}+pixbufGetPixels pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    length_ <- allocMem :: IO (Ptr Word32)+    result <- gdk_pixbuf_get_pixels_with_length pixbuf' length_+    length_' <- peek length_+    checkUnexpectedReturnNULL "pixbufGetPixels" result+    result' <- (unpackByteStringWithLength length_') result+    touchManagedPtr pixbuf+    freeMem length_+    return result'++#if ENABLE_OVERLOADING+data PixbufGetPixelsMethodInfo+instance (signature ~ (m ByteString), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufGetPixelsMethodInfo a signature where+    overloadedMethod _ = pixbufGetPixels++#endif++-- method Pixbuf::get_rowstride+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_rowstride" gdk_pixbuf_get_rowstride :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO Int32++{- |+Queries the rowstride of a pixbuf, which is the number of bytes between+the start of a row and the start of the next row.+-}+pixbufGetRowstride ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf. -}+    -> m Int32+    {- ^ __Returns:__ Distance between row starts. -}+pixbufGetRowstride pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    result <- gdk_pixbuf_get_rowstride pixbuf'+    touchManagedPtr pixbuf+    return result++#if ENABLE_OVERLOADING+data PixbufGetRowstrideMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufGetRowstrideMethodInfo a signature where+    overloadedMethod _ = pixbufGetRowstride++#endif++-- method Pixbuf::get_width+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_width" gdk_pixbuf_get_width :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO Int32++{- |+Queries the width of a pixbuf.+-}+pixbufGetWidth ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf. -}+    -> m Int32+    {- ^ __Returns:__ Width in pixels. -}+pixbufGetWidth pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    result <- gdk_pixbuf_get_width pixbuf'+    touchManagedPtr pixbuf+    return result++#if ENABLE_OVERLOADING+data PixbufGetWidthMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufGetWidthMethodInfo a signature where+    overloadedMethod _ = pixbufGetWidth++#endif++-- method Pixbuf::new_subpixbuf+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src_pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coord in @src_pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coord in @src_pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width of region in @src_pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height of region in @src_pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_subpixbuf" gdk_pixbuf_new_subpixbuf :: +    Ptr Pixbuf ->                           -- src_pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Int32 ->                                -- src_x : TBasicType TInt+    Int32 ->                                -- src_y : TBasicType TInt+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    IO (Ptr Pixbuf)++{- |+Creates a new pixbuf which represents a sub-region of /@srcPixbuf@/.+The new pixbuf shares its pixels with the original pixbuf, so+writing to one affects both.  The new pixbuf holds a reference to+/@srcPixbuf@/, so /@srcPixbuf@/ will not be finalized until the new+pixbuf is finalized.++Note that if /@srcPixbuf@/ is read-only, this function will force it+to be mutable.+-}+pixbufNewSubpixbuf ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@srcPixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> Int32+    {- ^ /@srcX@/: X coord in /@srcPixbuf@/ -}+    -> Int32+    {- ^ /@srcY@/: Y coord in /@srcPixbuf@/ -}+    -> Int32+    {- ^ /@width@/: width of region in /@srcPixbuf@/ -}+    -> Int32+    {- ^ /@height@/: height of region in /@srcPixbuf@/ -}+    -> m Pixbuf+    {- ^ __Returns:__ a new pixbuf -}+pixbufNewSubpixbuf srcPixbuf srcX srcY width height = liftIO $ do+    srcPixbuf' <- unsafeManagedPtrCastPtr srcPixbuf+    result <- gdk_pixbuf_new_subpixbuf srcPixbuf' srcX srcY width height+    checkUnexpectedReturnNULL "pixbufNewSubpixbuf" result+    result' <- (wrapObject Pixbuf) result+    touchManagedPtr srcPixbuf+    return result'++#if ENABLE_OVERLOADING+data PixbufNewSubpixbufMethodInfo+instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> m Pixbuf), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufNewSubpixbufMethodInfo a signature where+    overloadedMethod _ = pixbufNewSubpixbuf++#endif++-- method Pixbuf::read_pixel_bytes+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GLib", name = "Bytes"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_read_pixel_bytes" gdk_pixbuf_read_pixel_bytes :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO (Ptr GLib.Bytes.Bytes)++{- |+Provides a 'GI.GLib.Structs.Bytes.Bytes' buffer containing the raw pixel data; the data+must not be modified.  This function allows skipping the implicit+copy that must be made if @/gdk_pixbuf_get_pixels()/@ is called on a+read-only pixbuf.++/Since: 2.32/+-}+pixbufReadPixelBytes ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf -}+    -> m GLib.Bytes.Bytes+    {- ^ __Returns:__ A new reference to a read-only copy of+  the pixel data.  Note that for mutable pixbufs, this function will+  incur a one-time copy of the pixel data for conversion into the+  returned 'GI.GLib.Structs.Bytes.Bytes'. -}+pixbufReadPixelBytes pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    result <- gdk_pixbuf_read_pixel_bytes pixbuf'+    checkUnexpectedReturnNULL "pixbufReadPixelBytes" result+    result' <- (wrapBoxed GLib.Bytes.Bytes) result+    touchManagedPtr pixbuf+    return result'++#if ENABLE_OVERLOADING+data PixbufReadPixelBytesMethodInfo+instance (signature ~ (m GLib.Bytes.Bytes), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufReadPixelBytesMethodInfo a signature where+    overloadedMethod _ = pixbufReadPixelBytes++#endif++-- method Pixbuf::read_pixels+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt8)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_read_pixels" gdk_pixbuf_read_pixels :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO Word8++{- |+Provides a read-only pointer to the raw pixel data; must not be+modified.  This function allows skipping the implicit copy that+must be made if @/gdk_pixbuf_get_pixels()/@ is called on a read-only+pixbuf.++/Since: 2.32/+-}+pixbufReadPixels ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: A pixbuf -}+    -> m Word8+    {- ^ __Returns:__ a read-only pointer to the raw pixel data -}+pixbufReadPixels pixbuf = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    result <- gdk_pixbuf_read_pixels pixbuf'+    touchManagedPtr pixbuf+    return result++#if ENABLE_OVERLOADING+data PixbufReadPixelsMethodInfo+instance (signature ~ (m Word8), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufReadPixelsMethodInfo a signature where+    overloadedMethod _ = pixbufReadPixels++#endif++-- method Pixbuf::remove_option+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a nul-terminated string representing the key to remove.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_remove_option" gdk_pixbuf_remove_option :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    CString ->                              -- key : TBasicType TUTF8+    IO CInt++{- |+Remove the key\/value pair option attached to a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'.++/Since: 2.36/+-}+pixbufRemoveOption ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> T.Text+    {- ^ /@key@/: a nul-terminated string representing the key to remove. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if an option was removed, 'False' if not. -}+pixbufRemoveOption pixbuf key = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    key' <- textToCString key+    result <- gdk_pixbuf_remove_option pixbuf' key'+    let result' = (/= 0) result+    touchManagedPtr pixbuf+    freeMem key'+    return result'++#if ENABLE_OVERLOADING+data PixbufRemoveOptionMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufRemoveOptionMethodInfo a signature where+    overloadedMethod _ = pixbufRemoveOption++#endif++-- method Pixbuf::rotate_simple+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "angle", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufRotation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the angle to rotate by", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_rotate_simple" gdk_pixbuf_rotate_simple :: +    Ptr Pixbuf ->                           -- src : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    CUInt ->                                -- angle : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufRotation"})+    IO (Ptr Pixbuf)++{- |+Rotates a pixbuf by a multiple of 90 degrees, and returns the+result in a new pixbuf.++If /@angle@/ is 0, a copy of /@src@/ is returned, avoiding any rotation.++/Since: 2.6/+-}+pixbufRotateSimple ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@src@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> GdkPixbuf.Enums.PixbufRotation+    {- ^ /@angle@/: the angle to rotate by -}+    -> m (Maybe Pixbuf)+    {- ^ __Returns:__ the new 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf', or 'Nothing'+if not enough memory could be allocated for it. -}+pixbufRotateSimple src angle = liftIO $ do+    src' <- unsafeManagedPtrCastPtr src+    let angle' = (fromIntegral . fromEnum) angle+    result <- gdk_pixbuf_rotate_simple src' angle'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (wrapObject Pixbuf) result'+        return result''+    touchManagedPtr src+    return maybeResult++#if ENABLE_OVERLOADING+data PixbufRotateSimpleMethodInfo+instance (signature ~ (GdkPixbuf.Enums.PixbufRotation -> m (Maybe Pixbuf)), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufRotateSimpleMethodInfo a signature where+    overloadedMethod _ = pixbufRotateSimple++#endif++-- method Pixbuf::saturate_and_pixelate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "source image", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "place to write modified version of @src", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "saturation", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "saturation factor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pixelate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to pixelate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_saturate_and_pixelate" gdk_pixbuf_saturate_and_pixelate :: +    Ptr Pixbuf ->                           -- src : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Ptr Pixbuf ->                           -- dest : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    CFloat ->                               -- saturation : TBasicType TFloat+    CInt ->                                 -- pixelate : TBasicType TBoolean+    IO ()++{- |+Modifies saturation and optionally pixelates /@src@/, placing the result in+/@dest@/. /@src@/ and /@dest@/ may be the same pixbuf with no ill effects.  If+/@saturation@/ is 1.0 then saturation is not changed. If it\'s less than 1.0,+saturation is reduced (the image turns toward grayscale); if greater than+1.0, saturation is increased (the image gets more vivid colors). If /@pixelate@/+is 'True', then pixels are faded in a checkerboard pattern to create a+pixelated image. /@src@/ and /@dest@/ must have the same image format, size, and+rowstride.+-}+pixbufSaturateAndPixelate ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a, IsPixbuf b) =>+    a+    {- ^ /@src@/: source image -}+    -> b+    {- ^ /@dest@/: place to write modified version of /@src@/ -}+    -> Float+    {- ^ /@saturation@/: saturation factor -}+    -> Bool+    {- ^ /@pixelate@/: whether to pixelate -}+    -> m ()+pixbufSaturateAndPixelate src dest saturation pixelate = liftIO $ do+    src' <- unsafeManagedPtrCastPtr src+    dest' <- unsafeManagedPtrCastPtr dest+    let saturation' = realToFrac saturation+    let pixelate' = (fromIntegral . fromEnum) pixelate+    gdk_pixbuf_saturate_and_pixelate src' dest' saturation' pixelate'+    touchManagedPtr src+    touchManagedPtr dest+    return ()++#if ENABLE_OVERLOADING+data PixbufSaturateAndPixelateMethodInfo+instance (signature ~ (b -> Float -> Bool -> m ()), MonadIO m, IsPixbuf a, IsPixbuf b) => O.MethodInfo PixbufSaturateAndPixelateMethodInfo a signature where+    overloadedMethod _ = pixbufSaturateAndPixelate++#endif++-- method Pixbuf::save_to_bufferv+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n  location to receive a pointer to the new buffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "buffer_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to receive the size of the new buffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of file format.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_keys", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of options to set, %NULL-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_values", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "values for named options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "buffer_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to receive the size of the new buffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_save_to_bufferv" gdk_pixbuf_save_to_bufferv :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Ptr (Ptr Word8) ->                      -- buffer : TCArray False (-1) 2 (TBasicType TUInt8)+    Ptr Word64 ->                           -- buffer_size : TBasicType TUInt64+    CString ->                              -- type : TBasicType TUTF8+    Ptr CString ->                          -- option_keys : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr CString ->                          -- option_values : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+Saves pixbuf to a new buffer in format /@type@/, which is currently \"jpeg\",+\"tiff\", \"png\", \"ico\" or \"bmp\".  See @/gdk_pixbuf_save_to_buffer()/@+for more details.++/Since: 2.4/+-}+pixbufSaveToBufferv ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'. -}+    -> T.Text+    {- ^ /@type@/: name of file format. -}+    -> [T.Text]+    {- ^ /@optionKeys@/: name of options to set, 'Nothing'-terminated -}+    -> [T.Text]+    {- ^ /@optionValues@/: values for named options -}+    -> m (ByteString)+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufSaveToBufferv pixbuf type_ optionKeys optionValues = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    buffer <- allocMem :: IO (Ptr (Ptr Word8))+    bufferSize <- allocMem :: IO (Ptr Word64)+    type_' <- textToCString type_+    optionKeys' <- packZeroTerminatedUTF8CArray optionKeys+    optionValues' <- packZeroTerminatedUTF8CArray optionValues+    onException (do+        _ <- propagateGError $ gdk_pixbuf_save_to_bufferv pixbuf' buffer bufferSize type_' optionKeys' optionValues'+        bufferSize' <- peek bufferSize+        buffer' <- peek buffer+        buffer'' <- (unpackByteStringWithLength bufferSize') buffer'+        freeMem buffer'+        touchManagedPtr pixbuf+        freeMem buffer+        freeMem bufferSize+        freeMem type_'+        mapZeroTerminatedCArray freeMem optionKeys'+        freeMem optionKeys'+        mapZeroTerminatedCArray freeMem optionValues'+        freeMem optionValues'+        return buffer''+     ) (do+        freeMem buffer+        freeMem bufferSize+        freeMem type_'+        mapZeroTerminatedCArray freeMem optionKeys'+        freeMem optionKeys'+        mapZeroTerminatedCArray freeMem optionValues'+        freeMem optionValues'+     )++#if ENABLE_OVERLOADING+data PixbufSaveToBuffervMethodInfo+instance (signature ~ (T.Text -> [T.Text] -> [T.Text] -> m (ByteString)), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufSaveToBuffervMethodInfo a signature where+    overloadedMethod _ = pixbufSaveToBufferv++#endif++-- method Pixbuf::save_to_callbackv+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "save_func", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufSaveFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a function that is called to save each block of data that\n  the save routine generates.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to the save function.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of file format.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_keys", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of options to set, %NULL-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_values", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "values for named options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_save_to_callbackv" gdk_pixbuf_save_to_callbackv :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    FunPtr GdkPixbuf.Callbacks.C_PixbufSaveFunc -> -- save_func : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufSaveFunc"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    CString ->                              -- type : TBasicType TUTF8+    Ptr CString ->                          -- option_keys : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr CString ->                          -- option_values : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+Saves pixbuf to a callback in format /@type@/, which is currently \"jpeg\",+\"png\", \"tiff\", \"ico\" or \"bmp\".  If /@error@/ is set, 'False' will be returned. See+gdk_pixbuf_save_to_callback () for more details.++/Since: 2.4/+-}+pixbufSaveToCallbackv ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'. -}+    -> GdkPixbuf.Callbacks.PixbufSaveFunc+    {- ^ /@saveFunc@/: a function that is called to save each block of data that+  the save routine generates. -}+    -> T.Text+    {- ^ /@type@/: name of file format. -}+    -> [T.Text]+    {- ^ /@optionKeys@/: name of options to set, 'Nothing'-terminated -}+    -> [T.Text]+    {- ^ /@optionValues@/: values for named options -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufSaveToCallbackv pixbuf saveFunc type_ optionKeys optionValues = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    saveFunc' <- GdkPixbuf.Callbacks.mk_PixbufSaveFunc (GdkPixbuf.Callbacks.wrap_PixbufSaveFunc Nothing (GdkPixbuf.Callbacks.drop_closures_PixbufSaveFunc saveFunc))+    type_' <- textToCString type_+    optionKeys' <- packZeroTerminatedUTF8CArray optionKeys+    optionValues' <- packZeroTerminatedUTF8CArray optionValues+    let userData = nullPtr+    onException (do+        _ <- propagateGError $ gdk_pixbuf_save_to_callbackv pixbuf' saveFunc' userData type_' optionKeys' optionValues'+        safeFreeFunPtr $ castFunPtrToPtr saveFunc'+        touchManagedPtr pixbuf+        freeMem type_'+        mapZeroTerminatedCArray freeMem optionKeys'+        freeMem optionKeys'+        mapZeroTerminatedCArray freeMem optionValues'+        freeMem optionValues'+        return ()+     ) (do+        safeFreeFunPtr $ castFunPtrToPtr saveFunc'+        freeMem type_'+        mapZeroTerminatedCArray freeMem optionKeys'+        freeMem optionKeys'+        mapZeroTerminatedCArray freeMem optionValues'+        freeMem optionValues'+     )++#if ENABLE_OVERLOADING+data PixbufSaveToCallbackvMethodInfo+instance (signature ~ (GdkPixbuf.Callbacks.PixbufSaveFunc -> T.Text -> [T.Text] -> [T.Text] -> m ()), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufSaveToCallbackvMethodInfo a signature where+    overloadedMethod _ = pixbufSaveToCallbackv++#endif++-- method Pixbuf::save_to_streamv+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream to save the pixbuf to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of file format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_keys", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of options to set, %NULL-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_values", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "values for named options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_save_to_streamv" gdk_pixbuf_save_to_streamv :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Ptr Gio.OutputStream.OutputStream ->    -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})+    CString ->                              -- type : TBasicType TUTF8+    Ptr CString ->                          -- option_keys : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr CString ->                          -- option_values : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+Saves /@pixbuf@/ to an output stream.++Supported file formats are currently \"jpeg\", \"tiff\", \"png\", \"ico\" or+\"bmp\". See @/gdk_pixbuf_save_to_stream()/@ for more details.++/Since: 2.36/+-}+pixbufSaveToStreamv ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) =>+    a+    {- ^ /@pixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> b+    {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream' to save the pixbuf to -}+    -> T.Text+    {- ^ /@type@/: name of file format -}+    -> [T.Text]+    {- ^ /@optionKeys@/: name of options to set, 'Nothing'-terminated -}+    -> [T.Text]+    {- ^ /@optionValues@/: values for named options -}+    -> Maybe (c)+    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufSaveToStreamv pixbuf stream type_ optionKeys optionValues cancellable = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    stream' <- unsafeManagedPtrCastPtr stream+    type_' <- textToCString type_+    optionKeys' <- packZeroTerminatedUTF8CArray optionKeys+    optionValues' <- packZeroTerminatedUTF8CArray optionValues+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        _ <- propagateGError $ gdk_pixbuf_save_to_streamv pixbuf' stream' type_' optionKeys' optionValues' maybeCancellable+        touchManagedPtr pixbuf+        touchManagedPtr stream+        whenJust cancellable touchManagedPtr+        freeMem type_'+        mapZeroTerminatedCArray freeMem optionKeys'+        freeMem optionKeys'+        mapZeroTerminatedCArray freeMem optionValues'+        freeMem optionValues'+        return ()+     ) (do+        freeMem type_'+        mapZeroTerminatedCArray freeMem optionKeys'+        freeMem optionKeys'+        mapZeroTerminatedCArray freeMem optionValues'+        freeMem optionValues'+     )++#if ENABLE_OVERLOADING+data PixbufSaveToStreamvMethodInfo+instance (signature ~ (b -> T.Text -> [T.Text] -> [T.Text] -> Maybe (c) -> m ()), MonadIO m, IsPixbuf a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo PixbufSaveToStreamvMethodInfo a signature where+    overloadedMethod _ = pixbufSaveToStreamv++#endif++-- method Pixbuf::save_to_streamv_async+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream to which to save the pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of file format", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_keys", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of options to set, %NULL-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_values", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "values for named options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the pixbuf is saved", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_save_to_streamv_async" gdk_pixbuf_save_to_streamv_async :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Ptr Gio.OutputStream.OutputStream ->    -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})+    CString ->                              -- type : TBasicType TUTF8+    Ptr CString ->                          -- option_keys : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr CString ->                          -- option_values : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    IO ()++{- |+Saves /@pixbuf@/ to an output stream asynchronously.++For more details see 'GI.GdkPixbuf.Objects.Pixbuf.pixbufSaveToStreamv', which is the synchronous+version of this function.++When the operation is finished, /@callback@/ will be called in the main thread.+You can then call 'GI.GdkPixbuf.Objects.Pixbuf.pixbufSaveToStreamFinish' to get the result of the operation.++/Since: 2.36/+-}+pixbufSaveToStreamvAsync ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) =>+    a+    {- ^ /@pixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> b+    {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream' to which to save the pixbuf -}+    -> T.Text+    {- ^ /@type@/: name of file format -}+    -> [T.Text]+    {- ^ /@optionKeys@/: name of options to set, 'Nothing'-terminated -}+    -> [T.Text]+    {- ^ /@optionValues@/: values for named options -}+    -> Maybe (c)+    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}+    -> Maybe (Gio.Callbacks.AsyncReadyCallback)+    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the pixbuf is saved -}+    -> m ()+pixbufSaveToStreamvAsync pixbuf stream type_ optionKeys optionValues cancellable callback = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    stream' <- unsafeManagedPtrCastPtr stream+    type_' <- textToCString type_+    optionKeys' <- packZeroTerminatedUTF8CArray optionKeys+    optionValues' <- packZeroTerminatedUTF8CArray optionValues+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))+            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))+            poke ptrcallback jCallback'+            return jCallback'+    let userData = nullPtr+    gdk_pixbuf_save_to_streamv_async pixbuf' stream' type_' optionKeys' optionValues' maybeCancellable maybeCallback userData+    touchManagedPtr pixbuf+    touchManagedPtr stream+    whenJust cancellable touchManagedPtr+    freeMem type_'+    mapZeroTerminatedCArray freeMem optionKeys'+    freeMem optionKeys'+    mapZeroTerminatedCArray freeMem optionValues'+    freeMem optionValues'+    return ()++#if ENABLE_OVERLOADING+data PixbufSaveToStreamvAsyncMethodInfo+instance (signature ~ (b -> T.Text -> [T.Text] -> [T.Text] -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsPixbuf a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo PixbufSaveToStreamvAsyncMethodInfo a signature where+    overloadedMethod _ = pixbufSaveToStreamvAsync++#endif++-- method Pixbuf::savev+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of file to save.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of file format.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_keys", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of options to set, %NULL-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_values", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "values for named options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_savev" gdk_pixbuf_savev :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    CString ->                              -- filename : TBasicType TFileName+    CString ->                              -- type : TBasicType TUTF8+    Ptr CString ->                          -- option_keys : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr CString ->                          -- option_values : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+Saves pixbuf to a file in /@type@/, which is currently \"jpeg\", \"png\", \"tiff\", \"ico\" or \"bmp\".+If /@error@/ is set, 'False' will be returned.+See gdk_pixbuf_save () for more details.+-}+pixbufSavev ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'. -}+    -> [Char]+    {- ^ /@filename@/: name of file to save. -}+    -> T.Text+    {- ^ /@type@/: name of file format. -}+    -> [T.Text]+    {- ^ /@optionKeys@/: name of options to set, 'Nothing'-terminated -}+    -> [T.Text]+    {- ^ /@optionValues@/: values for named options -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufSavev pixbuf filename type_ optionKeys optionValues = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    filename' <- stringToCString filename+    type_' <- textToCString type_+    optionKeys' <- packZeroTerminatedUTF8CArray optionKeys+    optionValues' <- packZeroTerminatedUTF8CArray optionValues+    onException (do+        _ <- propagateGError $ gdk_pixbuf_savev pixbuf' filename' type_' optionKeys' optionValues'+        touchManagedPtr pixbuf+        freeMem filename'+        freeMem type_'+        mapZeroTerminatedCArray freeMem optionKeys'+        freeMem optionKeys'+        mapZeroTerminatedCArray freeMem optionValues'+        freeMem optionValues'+        return ()+     ) (do+        freeMem filename'+        freeMem type_'+        mapZeroTerminatedCArray freeMem optionKeys'+        freeMem optionKeys'+        mapZeroTerminatedCArray freeMem optionValues'+        freeMem optionValues'+     )++#if ENABLE_OVERLOADING+data PixbufSavevMethodInfo+instance (signature ~ ([Char] -> T.Text -> [T.Text] -> [T.Text] -> m ()), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufSavevMethodInfo a signature where+    overloadedMethod _ = pixbufSavev++#endif++-- method Pixbuf::scale+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkPixbuf into which to render the results", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the left coordinate for region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the top coordinate for region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width of the region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height of the region to render", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset_x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the offset in the X direction (currently rounded to an integer)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset_y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the offset in the Y direction (currently rounded to an integer)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale_x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the scale factor in the X direction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale_y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the scale factor in the Y direction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interp_type", argType = TInterface (Name {namespace = "GdkPixbuf", name = "InterpType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the interpolation type for the transformation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_scale" gdk_pixbuf_scale :: +    Ptr Pixbuf ->                           -- src : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Ptr Pixbuf ->                           -- dest : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Int32 ->                                -- dest_x : TBasicType TInt+    Int32 ->                                -- dest_y : TBasicType TInt+    Int32 ->                                -- dest_width : TBasicType TInt+    Int32 ->                                -- dest_height : TBasicType TInt+    CDouble ->                              -- offset_x : TBasicType TDouble+    CDouble ->                              -- offset_y : TBasicType TDouble+    CDouble ->                              -- scale_x : TBasicType TDouble+    CDouble ->                              -- scale_y : TBasicType TDouble+    CUInt ->                                -- interp_type : TInterface (Name {namespace = "GdkPixbuf", name = "InterpType"})+    IO ()++{- |+Creates a transformation of the source image /@src@/ by scaling by+/@scaleX@/ and /@scaleY@/ then translating by /@offsetX@/ and /@offsetY@/,+then renders the rectangle (/@destX@/, /@destY@/, /@destWidth@/,+/@destHeight@/) of the resulting image onto the destination image+replacing the previous contents.++Try to use 'GI.GdkPixbuf.Objects.Pixbuf.pixbufScaleSimple' first, this function is+the industrial-strength power tool you can fall back to if+'GI.GdkPixbuf.Objects.Pixbuf.pixbufScaleSimple' isn\'t powerful enough.++If the source rectangle overlaps the destination rectangle on the+same pixbuf, it will be overwritten during the scaling which+results in rendering artifacts.+-}+pixbufScale ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a, IsPixbuf b) =>+    a+    {- ^ /@src@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> b+    {- ^ /@dest@/: the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' into which to render the results -}+    -> Int32+    {- ^ /@destX@/: the left coordinate for region to render -}+    -> Int32+    {- ^ /@destY@/: the top coordinate for region to render -}+    -> Int32+    {- ^ /@destWidth@/: the width of the region to render -}+    -> Int32+    {- ^ /@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 -}+    -> GdkPixbuf.Enums.InterpType+    {- ^ /@interpType@/: the interpolation type for the transformation. -}+    -> m ()+pixbufScale src dest destX destY destWidth destHeight offsetX offsetY scaleX scaleY interpType = liftIO $ do+    src' <- unsafeManagedPtrCastPtr src+    dest' <- unsafeManagedPtrCastPtr dest+    let offsetX' = realToFrac offsetX+    let offsetY' = realToFrac offsetY+    let scaleX' = realToFrac scaleX+    let scaleY' = realToFrac scaleY+    let interpType' = (fromIntegral . fromEnum) interpType+    gdk_pixbuf_scale src' dest' destX destY destWidth destHeight offsetX' offsetY' scaleX' scaleY' interpType'+    touchManagedPtr src+    touchManagedPtr dest+    return ()++#if ENABLE_OVERLOADING+data PixbufScaleMethodInfo+instance (signature ~ (b -> Int32 -> Int32 -> Int32 -> Int32 -> Double -> Double -> Double -> Double -> GdkPixbuf.Enums.InterpType -> m ()), MonadIO m, IsPixbuf a, IsPixbuf b) => O.MethodInfo PixbufScaleMethodInfo a signature where+    overloadedMethod _ = pixbufScale++#endif++-- method Pixbuf::scale_simple+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "src", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width of destination image", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height of destination image", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interp_type", argType = TInterface (Name {namespace = "GdkPixbuf", name = "InterpType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the interpolation type for the transformation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_scale_simple" gdk_pixbuf_scale_simple :: +    Ptr Pixbuf ->                           -- src : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    Int32 ->                                -- dest_width : TBasicType TInt+    Int32 ->                                -- dest_height : TBasicType TInt+    CUInt ->                                -- interp_type : TInterface (Name {namespace = "GdkPixbuf", name = "InterpType"})+    IO (Ptr Pixbuf)++{- |+Create a new 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' containing a copy of /@src@/ scaled to+/@destWidth@/ x /@destHeight@/. Leaves /@src@/ unaffected.  /@interpType@/+should be @/GDK_INTERP_NEAREST/@ if you want maximum speed (but when+scaling down @/GDK_INTERP_NEAREST/@ is usually unusably ugly).  The+default /@interpType@/ should be @/GDK_INTERP_BILINEAR/@ which offers+reasonable quality and speed.++You can scale a sub-portion of /@src@/ by creating a sub-pixbuf+pointing into /@src@/; see 'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewSubpixbuf'.++If /@destWidth@/ and /@destHeight@/ are equal to the /@src@/ width and height, a+copy of /@src@/ is returned, avoiding any scaling.++For more complicated scaling\/alpha blending see 'GI.GdkPixbuf.Objects.Pixbuf.pixbufScale'+and 'GI.GdkPixbuf.Objects.Pixbuf.pixbufComposite'.+-}+pixbufScaleSimple ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@src@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> Int32+    {- ^ /@destWidth@/: the width of destination image -}+    -> Int32+    {- ^ /@destHeight@/: the height of destination image -}+    -> GdkPixbuf.Enums.InterpType+    {- ^ /@interpType@/: the interpolation type for the transformation. -}+    -> m (Maybe Pixbuf)+    {- ^ __Returns:__ the new 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf', or 'Nothing' if not enough memory could be+allocated for it. -}+pixbufScaleSimple src destWidth destHeight interpType = liftIO $ do+    src' <- unsafeManagedPtrCastPtr src+    let interpType' = (fromIntegral . fromEnum) interpType+    result <- gdk_pixbuf_scale_simple src' destWidth destHeight interpType'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (wrapObject Pixbuf) result'+        return result''+    touchManagedPtr src+    return maybeResult++#if ENABLE_OVERLOADING+data PixbufScaleSimpleMethodInfo+instance (signature ~ (Int32 -> Int32 -> GdkPixbuf.Enums.InterpType -> m (Maybe Pixbuf)), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufScaleSimpleMethodInfo a signature where+    overloadedMethod _ = pixbufScaleSimple++#endif++-- method Pixbuf::set_option+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a nul-terminated string.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a nul-terminated string.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_set_option" gdk_pixbuf_set_option :: +    Ptr Pixbuf ->                           -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    CString ->                              -- key : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    IO CInt++{- |+Attaches a key\/value pair as an option to a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'. If /@key@/ already+exists in the list of options attached to /@pixbuf@/, the new value is+ignored and 'False' is returned.++/Since: 2.2/+-}+pixbufSetOption ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbuf a) =>+    a+    {- ^ /@pixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -}+    -> T.Text+    {- ^ /@key@/: a nul-terminated string. -}+    -> T.Text+    {- ^ /@value@/: a nul-terminated string. -}+    -> m Bool+    {- ^ __Returns:__ 'True' on success. -}+pixbufSetOption pixbuf key value = liftIO $ do+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    key' <- textToCString key+    value' <- textToCString value+    result <- gdk_pixbuf_set_option pixbuf' key' value'+    let result' = (/= 0) result+    touchManagedPtr pixbuf+    freeMem key'+    freeMem value'+    return result'++#if ENABLE_OVERLOADING+data PixbufSetOptionMethodInfo+instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m, IsPixbuf a) => O.MethodInfo PixbufSetOptionMethodInfo a signature where+    overloadedMethod _ = pixbufSetOption++#endif++-- method Pixbuf::calculate_rowstride+-- method type : MemberFunction+-- Args : [Arg {argCName = "colorspace", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Colorspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Color space for image", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "has_alpha", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether the image should have transparency information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bits_per_sample", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of bits per color sample", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Width of image in pixels, must be > 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Height of image in pixels, must be > 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_calculate_rowstride" gdk_pixbuf_calculate_rowstride :: +    CUInt ->                                -- colorspace : TInterface (Name {namespace = "GdkPixbuf", name = "Colorspace"})+    CInt ->                                 -- has_alpha : TBasicType TBoolean+    Int32 ->                                -- bits_per_sample : TBasicType TInt+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    IO Int32++{- |+Calculates the rowstride that an image created with those values would+have. This is useful for front-ends and backends that want to sanity+check image values without needing to create them.++/Since: 2.36.8/+-}+pixbufCalculateRowstride ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    GdkPixbuf.Enums.Colorspace+    {- ^ /@colorspace@/: Color space for image -}+    -> Bool+    {- ^ /@hasAlpha@/: Whether the image should have transparency information -}+    -> Int32+    {- ^ /@bitsPerSample@/: Number of bits per color sample -}+    -> Int32+    {- ^ /@width@/: Width of image in pixels, must be > 0 -}+    -> Int32+    {- ^ /@height@/: Height of image in pixels, must be > 0 -}+    -> m Int32+    {- ^ __Returns:__ the rowstride for the given values, or -1 in case of error. -}+pixbufCalculateRowstride colorspace hasAlpha bitsPerSample width height = liftIO $ do+    let colorspace' = (fromIntegral . fromEnum) colorspace+    let hasAlpha' = (fromIntegral . fromEnum) hasAlpha+    result <- gdk_pixbuf_calculate_rowstride colorspace' hasAlpha' bitsPerSample width height+    return result++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::get_file_info+-- method type : MemberFunction+-- Args : [Arg {argCName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The name of the file to identify.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for the width of the\n    image, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for the height of the\n    image, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_file_info" gdk_pixbuf_get_file_info :: +    CString ->                              -- filename : TBasicType TFileName+    Ptr Int32 ->                            -- width : TBasicType TInt+    Ptr Int32 ->                            -- height : TBasicType TInt+    IO (Ptr GdkPixbuf.PixbufFormat.PixbufFormat)++{- |+Parses an image file far enough to determine its format and size.++/Since: 2.4/+-}+pixbufGetFileInfo ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    [Char]+    {- ^ /@filename@/: The name of the file to identify. -}+    -> m ((Maybe GdkPixbuf.PixbufFormat.PixbufFormat, Int32, Int32))+    {- ^ __Returns:__ A 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' describing+   the image format of the file or 'Nothing' if the image format wasn\'t+   recognized. The return value is owned by 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' and should+   not be freed. -}+pixbufGetFileInfo filename = liftIO $ do+    filename' <- stringToCString filename+    width <- allocMem :: IO (Ptr Int32)+    height <- allocMem :: IO (Ptr Int32)+    result <- gdk_pixbuf_get_file_info filename' width height+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newBoxed GdkPixbuf.PixbufFormat.PixbufFormat) result'+        return result''+    width' <- peek width+    height' <- peek height+    freeMem filename'+    freeMem width+    freeMem height+    return (maybeResult, width', height')++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::get_file_info_async+-- method type : MemberFunction+-- Args : [Arg {argCName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The name of the file to identify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the file info is available", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_file_info_async" gdk_pixbuf_get_file_info_async :: +    CString ->                              -- filename : TBasicType TFileName+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    IO ()++{- |+Asynchronously parses an image file far enough to determine its+format and size.++For more details see 'GI.GdkPixbuf.Objects.Pixbuf.pixbufGetFileInfo', which is the synchronous+version of this function.++When the operation is finished, /@callback@/ will be called in the+main thread. You can then call 'GI.GdkPixbuf.Objects.Pixbuf.pixbufGetFileInfoFinish' to+get the result of the operation.++/Since: 2.32/+-}+pixbufGetFileInfoAsync ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>+    [Char]+    {- ^ /@filename@/: The name of the file to identify -}+    -> Maybe (a)+    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}+    -> Maybe (Gio.Callbacks.AsyncReadyCallback)+    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the file info is available -}+    -> m ()+pixbufGetFileInfoAsync filename cancellable callback = liftIO $ do+    filename' <- stringToCString filename+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))+            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))+            poke ptrcallback jCallback'+            return jCallback'+    let userData = nullPtr+    gdk_pixbuf_get_file_info_async filename' maybeCancellable maybeCallback userData+    whenJust cancellable touchManagedPtr+    freeMem filename'+    return ()++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::get_file_info_finish+-- method type : MemberFunction+-- Args : [Arg {argCName = "async_result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for the width of the image, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for the height of the image, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_file_info_finish" gdk_pixbuf_get_file_info_finish :: +    Ptr Gio.AsyncResult.AsyncResult ->      -- async_result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})+    Ptr Int32 ->                            -- width : TBasicType TInt+    Ptr Int32 ->                            -- height : TBasicType TInt+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr GdkPixbuf.PixbufFormat.PixbufFormat)++{- |+Finishes an asynchronous pixbuf parsing operation started with+'GI.GdkPixbuf.Objects.Pixbuf.pixbufGetFileInfoAsync'.++/Since: 2.32/+-}+pixbufGetFileInfoFinish ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>+    a+    {- ^ /@asyncResult@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}+    -> m ((GdkPixbuf.PixbufFormat.PixbufFormat, Int32, Int32))+    {- ^ __Returns:__ A 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' describing the image+   format of the file or 'Nothing' if the image format wasn\'t+   recognized. The return value is owned by GdkPixbuf and should+   not be freed. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufGetFileInfoFinish asyncResult = liftIO $ do+    asyncResult' <- unsafeManagedPtrCastPtr asyncResult+    width <- allocMem :: IO (Ptr Int32)+    height <- allocMem :: IO (Ptr Int32)+    onException (do+        result <- propagateGError $ gdk_pixbuf_get_file_info_finish asyncResult' width height+        checkUnexpectedReturnNULL "pixbufGetFileInfoFinish" result+        result' <- (newBoxed GdkPixbuf.PixbufFormat.PixbufFormat) result+        width' <- peek width+        height' <- peek height+        touchManagedPtr asyncResult+        freeMem width+        freeMem height+        return (result', width', height')+     ) (do+        freeMem width+        freeMem height+     )++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::get_formats+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : Just (TGSList (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"})))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_get_formats" gdk_pixbuf_get_formats :: +    IO (Ptr (GSList (Ptr GdkPixbuf.PixbufFormat.PixbufFormat)))++{- |+Obtains the available information about the image formats supported+by GdkPixbuf.++/Since: 2.2/+-}+pixbufGetFormats ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m [GdkPixbuf.PixbufFormat.PixbufFormat]+    {- ^ __Returns:__ A list of+@/GdkPixbufFormats/@ describing the supported image formats. The list should+be freed when it is no longer needed, but the structures themselves are+owned by 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' and should not be freed. -}+pixbufGetFormats  = liftIO $ do+    result <- gdk_pixbuf_get_formats+    result' <- unpackGSList result+    result'' <- mapM (newBoxed GdkPixbuf.PixbufFormat.PixbufFormat) result'+    g_slist_free result+    return result''++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_stream_async+-- method type : MemberFunction+-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream from which to load the pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the pixbuf is loaded", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_stream_async" gdk_pixbuf_new_from_stream_async :: +    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    IO ()++{- |+Creates a new pixbuf by asynchronously loading an image from an input stream.++For more details see 'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewFromStream', which is the synchronous+version of this function.++When the operation is finished, /@callback@/ will be called in the main thread.+You can then call 'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewFromStreamFinish' to get the result of the operation.++/Since: 2.24/+-}+pixbufNewFromStreamAsync ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>+    a+    {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream' from which to load the pixbuf -}+    -> Maybe (b)+    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}+    -> Maybe (Gio.Callbacks.AsyncReadyCallback)+    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the pixbuf is loaded -}+    -> m ()+pixbufNewFromStreamAsync stream cancellable callback = liftIO $ do+    stream' <- unsafeManagedPtrCastPtr stream+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))+            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))+            poke ptrcallback jCallback'+            return jCallback'+    let userData = nullPtr+    gdk_pixbuf_new_from_stream_async stream' maybeCancellable maybeCallback userData+    touchManagedPtr stream+    whenJust cancellable touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::new_from_stream_at_scale_async+-- method type : MemberFunction+-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream from which to load the pixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width the image should have or -1 to not constrain the width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height the image should have or -1 to not constrain the height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "preserve_aspect_ratio", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to preserve the image's aspect ratio", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the pixbuf is loaded", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_new_from_stream_at_scale_async" gdk_pixbuf_new_from_stream_at_scale_async :: +    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    CInt ->                                 -- preserve_aspect_ratio : TBasicType TBoolean+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    IO ()++{- |+Creates a new pixbuf by asynchronously loading an image from an input stream.++For more details see 'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewFromStreamAtScale', which is the synchronous+version of this function.++When the operation is finished, /@callback@/ will be called in the main thread.+You can then call 'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewFromStreamFinish' to get the result of the operation.++/Since: 2.24/+-}+pixbufNewFromStreamAtScaleAsync ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>+    a+    {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream' from which to load the pixbuf -}+    -> Int32+    {- ^ /@width@/: the width the image should have or -1 to not constrain the width -}+    -> Int32+    {- ^ /@height@/: the height the image should have or -1 to not constrain the height -}+    -> Bool+    {- ^ /@preserveAspectRatio@/: 'True' to preserve the image\'s aspect ratio -}+    -> Maybe (b)+    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}+    -> Maybe (Gio.Callbacks.AsyncReadyCallback)+    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the pixbuf is loaded -}+    -> m ()+pixbufNewFromStreamAtScaleAsync stream width height preserveAspectRatio cancellable callback = liftIO $ do+    stream' <- unsafeManagedPtrCastPtr stream+    let preserveAspectRatio' = (fromIntegral . fromEnum) preserveAspectRatio+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))+            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))+            poke ptrcallback jCallback'+            return jCallback'+    let userData = nullPtr+    gdk_pixbuf_new_from_stream_at_scale_async stream' width height preserveAspectRatio' maybeCancellable maybeCallback userData+    touchManagedPtr stream+    whenJust cancellable touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+#endif++-- method Pixbuf::save_to_stream_finish+-- method type : MemberFunction+-- Args : [Arg {argCName = "async_result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_save_to_stream_finish" gdk_pixbuf_save_to_stream_finish :: +    Ptr Gio.AsyncResult.AsyncResult ->      -- async_result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+Finishes an asynchronous pixbuf save operation started with+@/gdk_pixbuf_save_to_stream_async()/@.++/Since: 2.24/+-}+pixbufSaveToStreamFinish ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>+    a+    {- ^ /@asyncResult@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufSaveToStreamFinish asyncResult = liftIO $ do+    asyncResult' <- unsafeManagedPtrCastPtr asyncResult+    onException (do+        _ <- propagateGError $ gdk_pixbuf_save_to_stream_finish asyncResult'+        touchManagedPtr asyncResult+        return ()+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+#endif++

@@ -0,0 +1,161 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GdkPixbuf.Objects.Pixbuf where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++newtype Pixbuf = Pixbuf (ManagedPtr Pixbuf)+instance GObject Pixbuf where+class (GObject o, O.IsDescendantOf Pixbuf o) => IsPixbuf o+instance (GObject o, O.IsDescendantOf Pixbuf o) => IsPixbuf o+instance O.HasParentTypes Pixbuf+#if ENABLE_OVERLOADING+data PixbufBitsPerSamplePropertyInfo+#endif+#if ENABLE_OVERLOADING+data PixbufColorspacePropertyInfo+#endif+#if ENABLE_OVERLOADING+data PixbufHasAlphaPropertyInfo+#endif+#if ENABLE_OVERLOADING+data PixbufHeightPropertyInfo+#endif+#if ENABLE_OVERLOADING+data PixbufNChannelsPropertyInfo+#endif+#if ENABLE_OVERLOADING+data PixbufPixelBytesPropertyInfo+#endif+#if ENABLE_OVERLOADING+data PixbufPixelsPropertyInfo+#endif+#if ENABLE_OVERLOADING+data PixbufRowstridePropertyInfo+#endif+#if ENABLE_OVERLOADING+data PixbufWidthPropertyInfo+#endif+#if ENABLE_OVERLOADING+data PixbufAddAlphaMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufApplyEmbeddedOrientationMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufCompositeMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufCompositeColorMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufCompositeColorSimpleMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufCopyMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufCopyAreaMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufCopyOptionsMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufFillMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufFlipMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufGetBitsPerSampleMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufGetByteLengthMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufGetColorspaceMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufGetHasAlphaMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufGetHeightMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufGetNChannelsMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufGetOptionMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufGetOptionsMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufGetPixelsMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufGetRowstrideMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufGetWidthMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufNewSubpixbufMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufReadPixelBytesMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufReadPixelsMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufRemoveOptionMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufRotateSimpleMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufSaturateAndPixelateMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufSaveToBuffervMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufSaveToCallbackvMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufSaveToStreamvMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufSaveToStreamvAsyncMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufSavevMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufScaleMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufScaleSimpleMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufSetOptionMethodInfo+#endif

@@ -0,0 +1,673 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++An opaque struct representing an animation.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GdkPixbuf.Objects.PixbufAnimation+    ( ++-- * Exported types+    PixbufAnimation(..)                     ,+    IsPixbufAnimation                       ,+    toPixbufAnimation                       ,+    noPixbufAnimation                       ,+++ -- * Methods+-- ** getHeight #method:getHeight#++#if ENABLE_OVERLOADING+    PixbufAnimationGetHeightMethodInfo      ,+#endif+    pixbufAnimationGetHeight                ,+++-- ** getIter #method:getIter#++#if ENABLE_OVERLOADING+    PixbufAnimationGetIterMethodInfo        ,+#endif+    pixbufAnimationGetIter                  ,+++-- ** getStaticImage #method:getStaticImage#++#if ENABLE_OVERLOADING+    PixbufAnimationGetStaticImageMethodInfo ,+#endif+    pixbufAnimationGetStaticImage           ,+++-- ** getWidth #method:getWidth#++#if ENABLE_OVERLOADING+    PixbufAnimationGetWidthMethodInfo       ,+#endif+    pixbufAnimationGetWidth                 ,+++-- ** isStaticImage #method:isStaticImage#++#if ENABLE_OVERLOADING+    PixbufAnimationIsStaticImageMethodInfo  ,+#endif+    pixbufAnimationIsStaticImage            ,+++-- ** newFromFile #method:newFromFile#++    pixbufAnimationNewFromFile              ,+++-- ** newFromResource #method:newFromResource#++    pixbufAnimationNewFromResource          ,+++-- ** newFromStream #method:newFromStream#++    pixbufAnimationNewFromStream            ,+++-- ** newFromStreamAsync #method:newFromStreamAsync#++    pixbufAnimationNewFromStreamAsync       ,+++-- ** newFromStreamFinish #method:newFromStreamFinish#++    pixbufAnimationNewFromStreamFinish      ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import qualified GI.GLib.Structs.TimeVal as GLib.TimeVal+import qualified GI.GObject.Objects.Object as GObject.Object+import {-# SOURCE #-} qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf+import {-# SOURCE #-} qualified GI.GdkPixbuf.Objects.PixbufAnimationIter as GdkPixbuf.PixbufAnimationIter+import qualified GI.Gio.Callbacks as Gio.Callbacks+import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult+import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable+import qualified GI.Gio.Objects.InputStream as Gio.InputStream++-- | Memory-managed wrapper type.+newtype PixbufAnimation = PixbufAnimation (ManagedPtr PixbufAnimation)+foreign import ccall "gdk_pixbuf_animation_get_type"+    c_gdk_pixbuf_animation_get_type :: IO GType++instance GObject PixbufAnimation where+    gobjectType = c_gdk_pixbuf_animation_get_type+    ++-- | Type class for types which can be safely cast to `PixbufAnimation`, for instance with `toPixbufAnimation`.+class (GObject o, O.IsDescendantOf PixbufAnimation o) => IsPixbufAnimation o+instance (GObject o, O.IsDescendantOf PixbufAnimation o) => IsPixbufAnimation o++instance O.HasParentTypes PixbufAnimation+type instance O.ParentTypes PixbufAnimation = '[GObject.Object.Object]++-- | Cast to `PixbufAnimation`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toPixbufAnimation :: (MonadIO m, IsPixbufAnimation o) => o -> m PixbufAnimation+toPixbufAnimation = liftIO . unsafeCastTo PixbufAnimation++-- | A convenience alias for `Nothing` :: `Maybe` `PixbufAnimation`.+noPixbufAnimation :: Maybe PixbufAnimation+noPixbufAnimation = Nothing++#if ENABLE_OVERLOADING+type family ResolvePixbufAnimationMethod (t :: Symbol) (o :: *) :: * where+    ResolvePixbufAnimationMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolvePixbufAnimationMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolvePixbufAnimationMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolvePixbufAnimationMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolvePixbufAnimationMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolvePixbufAnimationMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolvePixbufAnimationMethod "isStaticImage" o = PixbufAnimationIsStaticImageMethodInfo+    ResolvePixbufAnimationMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolvePixbufAnimationMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolvePixbufAnimationMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolvePixbufAnimationMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolvePixbufAnimationMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolvePixbufAnimationMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolvePixbufAnimationMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolvePixbufAnimationMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolvePixbufAnimationMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolvePixbufAnimationMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolvePixbufAnimationMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolvePixbufAnimationMethod "getHeight" o = PixbufAnimationGetHeightMethodInfo+    ResolvePixbufAnimationMethod "getIter" o = PixbufAnimationGetIterMethodInfo+    ResolvePixbufAnimationMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolvePixbufAnimationMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolvePixbufAnimationMethod "getStaticImage" o = PixbufAnimationGetStaticImageMethodInfo+    ResolvePixbufAnimationMethod "getWidth" o = PixbufAnimationGetWidthMethodInfo+    ResolvePixbufAnimationMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolvePixbufAnimationMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolvePixbufAnimationMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolvePixbufAnimationMethod t PixbufAnimation, O.MethodInfo info PixbufAnimation p) => OL.IsLabel t (PixbufAnimation -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList PixbufAnimation+type instance O.AttributeList PixbufAnimation = PixbufAnimationAttributeList+type PixbufAnimationAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList PixbufAnimation = PixbufAnimationSignalList+type PixbufAnimationSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method PixbufAnimation::new_from_file+-- method type : Constructor+-- Args : [Arg {argCName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of file to load, in the GLib file\n    name encoding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_new_from_file" gdk_pixbuf_animation_new_from_file :: +    CString ->                              -- filename : TBasicType TFileName+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr PixbufAnimation)++{- |+Creates a new animation by loading it from a file. The file format is+detected automatically. If the file\'s format does not support multi-frame+images, then an animation with a single frame will be created. Possible errors+are in the @/GDK_PIXBUF_ERROR/@ and @/G_FILE_ERROR/@ domains.+-}+pixbufAnimationNewFromFile ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    [Char]+    {- ^ /@filename@/: Name of file to load, in the GLib file+    name encoding -}+    -> m PixbufAnimation+    {- ^ __Returns:__ A newly-created animation with a reference count of 1, or 'Nothing'+if any of several error conditions ocurred:  the file could not be opened,+there was no loader for the file\'s format, there was not enough memory to+allocate the image buffer, or the image file contained invalid data. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufAnimationNewFromFile filename = liftIO $ do+    filename' <- stringToCString filename+    onException (do+        result <- propagateGError $ gdk_pixbuf_animation_new_from_file filename'+        checkUnexpectedReturnNULL "pixbufAnimationNewFromFile" result+        result' <- (wrapObject PixbufAnimation) result+        freeMem filename'+        return result'+     ) (do+        freeMem filename'+     )++#if ENABLE_OVERLOADING+#endif++-- method PixbufAnimation::new_from_resource+-- method type : Constructor+-- Args : [Arg {argCName = "resource_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path of the resource file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_new_from_resource" gdk_pixbuf_animation_new_from_resource :: +    CString ->                              -- resource_path : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr PixbufAnimation)++{- |+Creates a new pixbuf animation by loading an image from an resource.++The file format is detected automatically. If 'Nothing' is returned, then+/@error@/ will be set.++/Since: 2.28/+-}+pixbufAnimationNewFromResource ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@resourcePath@/: the path of the resource file -}+    -> m PixbufAnimation+    {- ^ __Returns:__ A newly-created animation, or 'Nothing' if any of several error+conditions occurred: the file could not be opened, the image format is+not supported, there was not enough memory to allocate the image buffer,+the stream contained invalid data, or the operation was cancelled. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufAnimationNewFromResource resourcePath = liftIO $ do+    resourcePath' <- textToCString resourcePath+    onException (do+        result <- propagateGError $ gdk_pixbuf_animation_new_from_resource resourcePath'+        checkUnexpectedReturnNULL "pixbufAnimationNewFromResource" result+        result' <- (wrapObject PixbufAnimation) result+        freeMem resourcePath'+        return result'+     ) (do+        freeMem resourcePath'+     )++#if ENABLE_OVERLOADING+#endif++-- method PixbufAnimation::new_from_stream+-- method type : Constructor+-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream to load the pixbuf from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_new_from_stream" gdk_pixbuf_animation_new_from_stream :: +    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr PixbufAnimation)++{- |+Creates a new animation by loading it from an input stream.++The file format is detected automatically. If 'Nothing' is returned, then+/@error@/ will be set. The /@cancellable@/ can be used to abort the operation+from another thread. If the operation was cancelled, the error+'GI.Gio.Enums.IOErrorEnumCancelled' will be returned. Other possible errors are in+the @/GDK_PIXBUF_ERROR/@ and @/G_IO_ERROR/@ domains.++The stream is not closed.++/Since: 2.28/+-}+pixbufAnimationNewFromStream ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>+    a+    {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream' to load the pixbuf from -}+    -> Maybe (b)+    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}+    -> m PixbufAnimation+    {- ^ __Returns:__ A newly-created pixbuf, or 'Nothing' if any of several error+conditions occurred: the file could not be opened, the image format is+not supported, there was not enough memory to allocate the image buffer,+the stream contained invalid data, or the operation was cancelled. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufAnimationNewFromStream stream cancellable = liftIO $ do+    stream' <- unsafeManagedPtrCastPtr stream+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ gdk_pixbuf_animation_new_from_stream stream' maybeCancellable+        checkUnexpectedReturnNULL "pixbufAnimationNewFromStream" result+        result' <- (wrapObject PixbufAnimation) result+        touchManagedPtr stream+        whenJust cancellable touchManagedPtr+        return result'+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+#endif++-- method PixbufAnimation::new_from_stream_finish+-- method type : Constructor+-- Args : [Arg {argCName = "async_result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_new_from_stream_finish" gdk_pixbuf_animation_new_from_stream_finish :: +    Ptr Gio.AsyncResult.AsyncResult ->      -- async_result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr PixbufAnimation)++{- |+Finishes an asynchronous pixbuf animation creation operation started with+'GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationNewFromStreamAsync'.++/Since: 2.28/+-}+pixbufAnimationNewFromStreamFinish ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>+    a+    {- ^ /@asyncResult@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}+    -> m PixbufAnimation+    {- ^ __Returns:__ a 'GI.GdkPixbuf.Objects.PixbufAnimation.PixbufAnimation' or 'Nothing' on error. Free the returned+object with 'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufAnimationNewFromStreamFinish asyncResult = liftIO $ do+    asyncResult' <- unsafeManagedPtrCastPtr asyncResult+    onException (do+        result <- propagateGError $ gdk_pixbuf_animation_new_from_stream_finish asyncResult'+        checkUnexpectedReturnNULL "pixbufAnimationNewFromStreamFinish" result+        result' <- (wrapObject PixbufAnimation) result+        touchManagedPtr asyncResult+        return result'+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+#endif++-- method PixbufAnimation::get_height+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "animation", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An animation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_get_height" gdk_pixbuf_animation_get_height :: +    Ptr PixbufAnimation ->                  -- animation : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"})+    IO Int32++{- |+Queries the height of the bounding box of a pixbuf animation.+-}+pixbufAnimationGetHeight ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimation a) =>+    a+    {- ^ /@animation@/: An animation. -}+    -> m Int32+    {- ^ __Returns:__ Height of the bounding box of the animation. -}+pixbufAnimationGetHeight animation = liftIO $ do+    animation' <- unsafeManagedPtrCastPtr animation+    result <- gdk_pixbuf_animation_get_height animation'+    touchManagedPtr animation+    return result++#if ENABLE_OVERLOADING+data PixbufAnimationGetHeightMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsPixbufAnimation a) => O.MethodInfo PixbufAnimationGetHeightMethodInfo a signature where+    overloadedMethod _ = pixbufAnimationGetHeight++#endif++-- method PixbufAnimation::get_iter+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "animation", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufAnimation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_time", argType = TInterface (Name {namespace = "GLib", name = "TimeVal"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "time when the animation starts playing", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimationIter"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_get_iter" gdk_pixbuf_animation_get_iter :: +    Ptr PixbufAnimation ->                  -- animation : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"})+    Ptr GLib.TimeVal.TimeVal ->             -- start_time : TInterface (Name {namespace = "GLib", name = "TimeVal"})+    IO (Ptr GdkPixbuf.PixbufAnimationIter.PixbufAnimationIter)++{- |+Get an iterator for displaying an animation. The iterator provides+the frames that should be displayed at a given time. It should be+freed after use with 'GI.GObject.Objects.Object.objectUnref'.++/@startTime@/ would normally come from 'GI.GLib.Functions.getCurrentTime', and marks+the beginning of animation playback. After creating an iterator, you+should immediately display the pixbuf returned by+'GI.GdkPixbuf.Objects.PixbufAnimationIter.pixbufAnimationIterGetPixbuf'. Then, you should install+a timeout (with @/g_timeout_add()/@) or by some other mechanism ensure+that you\'ll update the image after+'GI.GdkPixbuf.Objects.PixbufAnimationIter.pixbufAnimationIterGetDelayTime' milliseconds. Each time+the image is updated, you should reinstall the timeout with the new,+possibly-changed delay time.++As a shortcut, if /@startTime@/ is 'Nothing', the result of+'GI.GLib.Functions.getCurrentTime' will be used automatically.++To update the image (i.e. possibly change the result of+'GI.GdkPixbuf.Objects.PixbufAnimationIter.pixbufAnimationIterGetPixbuf' to a new frame of the animation),+call 'GI.GdkPixbuf.Objects.PixbufAnimationIter.pixbufAnimationIterAdvance'.++If you\'re using 'GI.GdkPixbuf.Objects.PixbufLoader.PixbufLoader', in addition to updating the image+after the delay time, you should also update it whenever you+receive the area_updated signal and+'GI.GdkPixbuf.Objects.PixbufAnimationIter.pixbufAnimationIterOnCurrentlyLoadingFrame' returns+'True'. In this case, the frame currently being fed into the loader+has received new data, so needs to be refreshed. The delay time for+a frame may also be modified after an area_updated signal, for+example if the delay time for a frame is encoded in the data after+the frame itself. So your timeout should be reinstalled after any+area_updated signal.++A delay time of -1 is possible, indicating \"infinite.\"+-}+pixbufAnimationGetIter ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimation a) =>+    a+    {- ^ /@animation@/: a 'GI.GdkPixbuf.Objects.PixbufAnimation.PixbufAnimation' -}+    -> Maybe (GLib.TimeVal.TimeVal)+    {- ^ /@startTime@/: time when the animation starts playing -}+    -> m GdkPixbuf.PixbufAnimationIter.PixbufAnimationIter+    {- ^ __Returns:__ an iterator to move over the animation -}+pixbufAnimationGetIter animation startTime = liftIO $ do+    animation' <- unsafeManagedPtrCastPtr animation+    maybeStartTime <- case startTime of+        Nothing -> return nullPtr+        Just jStartTime -> do+            jStartTime' <- unsafeManagedPtrGetPtr jStartTime+            return jStartTime'+    result <- gdk_pixbuf_animation_get_iter animation' maybeStartTime+    checkUnexpectedReturnNULL "pixbufAnimationGetIter" result+    result' <- (wrapObject GdkPixbuf.PixbufAnimationIter.PixbufAnimationIter) result+    touchManagedPtr animation+    whenJust startTime touchManagedPtr+    return result'++#if ENABLE_OVERLOADING+data PixbufAnimationGetIterMethodInfo+instance (signature ~ (Maybe (GLib.TimeVal.TimeVal) -> m GdkPixbuf.PixbufAnimationIter.PixbufAnimationIter), MonadIO m, IsPixbufAnimation a) => O.MethodInfo PixbufAnimationGetIterMethodInfo a signature where+    overloadedMethod _ = pixbufAnimationGetIter++#endif++-- method PixbufAnimation::get_static_image+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "animation", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufAnimation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_get_static_image" gdk_pixbuf_animation_get_static_image :: +    Ptr PixbufAnimation ->                  -- animation : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"})+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)++{- |+If an animation is really just a plain image (has only one frame),+this function returns that image. If the animation is an animation,+this function returns a reasonable thing to display as a static+unanimated image, which might be the first frame, or something more+sophisticated. If an animation hasn\'t loaded any frames yet, this+function will return 'Nothing'.+-}+pixbufAnimationGetStaticImage ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimation a) =>+    a+    {- ^ /@animation@/: a 'GI.GdkPixbuf.Objects.PixbufAnimation.PixbufAnimation' -}+    -> m GdkPixbuf.Pixbuf.Pixbuf+    {- ^ __Returns:__ unanimated image representing the animation -}+pixbufAnimationGetStaticImage animation = liftIO $ do+    animation' <- unsafeManagedPtrCastPtr animation+    result <- gdk_pixbuf_animation_get_static_image animation'+    checkUnexpectedReturnNULL "pixbufAnimationGetStaticImage" result+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result+    touchManagedPtr animation+    return result'++#if ENABLE_OVERLOADING+data PixbufAnimationGetStaticImageMethodInfo+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsPixbufAnimation a) => O.MethodInfo PixbufAnimationGetStaticImageMethodInfo a signature where+    overloadedMethod _ = pixbufAnimationGetStaticImage++#endif++-- method PixbufAnimation::get_width+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "animation", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An animation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_get_width" gdk_pixbuf_animation_get_width :: +    Ptr PixbufAnimation ->                  -- animation : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"})+    IO Int32++{- |+Queries the width of the bounding box of a pixbuf animation.+-}+pixbufAnimationGetWidth ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimation a) =>+    a+    {- ^ /@animation@/: An animation. -}+    -> m Int32+    {- ^ __Returns:__ Width of the bounding box of the animation. -}+pixbufAnimationGetWidth animation = liftIO $ do+    animation' <- unsafeManagedPtrCastPtr animation+    result <- gdk_pixbuf_animation_get_width animation'+    touchManagedPtr animation+    return result++#if ENABLE_OVERLOADING+data PixbufAnimationGetWidthMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsPixbufAnimation a) => O.MethodInfo PixbufAnimationGetWidthMethodInfo a signature where+    overloadedMethod _ = pixbufAnimationGetWidth++#endif++-- method PixbufAnimation::is_static_image+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "animation", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufAnimation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_is_static_image" gdk_pixbuf_animation_is_static_image :: +    Ptr PixbufAnimation ->                  -- animation : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"})+    IO CInt++{- |+If you load a file with 'GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationNewFromFile' and it+turns out to be a plain, unanimated image, then this function will+return 'True'. Use 'GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationGetStaticImage' to retrieve+the image.+-}+pixbufAnimationIsStaticImage ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimation a) =>+    a+    {- ^ /@animation@/: a 'GI.GdkPixbuf.Objects.PixbufAnimation.PixbufAnimation' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the \"animation\" was really just an image -}+pixbufAnimationIsStaticImage animation = liftIO $ do+    animation' <- unsafeManagedPtrCastPtr animation+    result <- gdk_pixbuf_animation_is_static_image animation'+    let result' = (/= 0) result+    touchManagedPtr animation+    return result'++#if ENABLE_OVERLOADING+data PixbufAnimationIsStaticImageMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsPixbufAnimation a) => O.MethodInfo PixbufAnimationIsStaticImageMethodInfo a signature where+    overloadedMethod _ = pixbufAnimationIsStaticImage++#endif++-- method PixbufAnimation::new_from_stream_async+-- method type : MemberFunction+-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream from which to load the animation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the pixbuf is loaded", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_new_from_stream_async" gdk_pixbuf_animation_new_from_stream_async :: +    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})+    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})+    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    IO ()++{- |+Creates a new animation by asynchronously loading an image from an input stream.++For more details see 'GI.GdkPixbuf.Objects.Pixbuf.pixbufNewFromStream', which is the synchronous+version of this function.++When the operation is finished, /@callback@/ will be called in the main thread.+You can then call 'GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationNewFromStreamFinish' to get the+result of the operation.++/Since: 2.28/+-}+pixbufAnimationNewFromStreamAsync ::+    (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>+    a+    {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream' from which to load the animation -}+    -> Maybe (b)+    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}+    -> Maybe (Gio.Callbacks.AsyncReadyCallback)+    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the pixbuf is loaded -}+    -> m ()+pixbufAnimationNewFromStreamAsync stream cancellable callback = liftIO $ do+    stream' <- unsafeManagedPtrCastPtr stream+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            jCancellable' <- unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    maybeCallback <- case callback of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jCallback -> do+            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))+            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))+            poke ptrcallback jCallback'+            return jCallback'+    let userData = nullPtr+    gdk_pixbuf_animation_new_from_stream_async stream' maybeCancellable maybeCallback userData+    touchManagedPtr stream+    whenJust cancellable touchManagedPtr+    return ()++#if ENABLE_OVERLOADING+#endif++

@@ -0,0 +1,44 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GdkPixbuf.Objects.PixbufAnimation where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++newtype PixbufAnimation = PixbufAnimation (ManagedPtr PixbufAnimation)+instance GObject PixbufAnimation where+class (GObject o, O.IsDescendantOf PixbufAnimation o) => IsPixbufAnimation o+instance (GObject o, O.IsDescendantOf PixbufAnimation o) => IsPixbufAnimation o+instance O.HasParentTypes PixbufAnimation+#if ENABLE_OVERLOADING+data PixbufAnimationGetHeightMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufAnimationGetIterMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufAnimationGetStaticImageMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufAnimationGetWidthMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufAnimationIsStaticImageMethodInfo+#endif

@@ -0,0 +1,351 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++An opaque struct representing an iterator which points to a+certain position in an animation.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GdkPixbuf.Objects.PixbufAnimationIter+    ( ++-- * Exported types+    PixbufAnimationIter(..)                 ,+    IsPixbufAnimationIter                   ,+    toPixbufAnimationIter                   ,+    noPixbufAnimationIter                   ,+++ -- * Methods+-- ** advance #method:advance#++#if ENABLE_OVERLOADING+    PixbufAnimationIterAdvanceMethodInfo    ,+#endif+    pixbufAnimationIterAdvance              ,+++-- ** getDelayTime #method:getDelayTime#++#if ENABLE_OVERLOADING+    PixbufAnimationIterGetDelayTimeMethodInfo,+#endif+    pixbufAnimationIterGetDelayTime         ,+++-- ** getPixbuf #method:getPixbuf#++#if ENABLE_OVERLOADING+    PixbufAnimationIterGetPixbufMethodInfo  ,+#endif+    pixbufAnimationIterGetPixbuf            ,+++-- ** onCurrentlyLoadingFrame #method:onCurrentlyLoadingFrame#++#if ENABLE_OVERLOADING+    PixbufAnimationIterOnCurrentlyLoadingFrameMethodInfo,+#endif+    pixbufAnimationIterOnCurrentlyLoadingFrame,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import qualified GI.GLib.Structs.TimeVal as GLib.TimeVal+import qualified GI.GObject.Objects.Object as GObject.Object+import {-# SOURCE #-} qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf++-- | Memory-managed wrapper type.+newtype PixbufAnimationIter = PixbufAnimationIter (ManagedPtr PixbufAnimationIter)+foreign import ccall "gdk_pixbuf_animation_iter_get_type"+    c_gdk_pixbuf_animation_iter_get_type :: IO GType++instance GObject PixbufAnimationIter where+    gobjectType = c_gdk_pixbuf_animation_iter_get_type+    ++-- | Type class for types which can be safely cast to `PixbufAnimationIter`, for instance with `toPixbufAnimationIter`.+class (GObject o, O.IsDescendantOf PixbufAnimationIter o) => IsPixbufAnimationIter o+instance (GObject o, O.IsDescendantOf PixbufAnimationIter o) => IsPixbufAnimationIter o++instance O.HasParentTypes PixbufAnimationIter+type instance O.ParentTypes PixbufAnimationIter = '[GObject.Object.Object]++-- | Cast to `PixbufAnimationIter`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toPixbufAnimationIter :: (MonadIO m, IsPixbufAnimationIter o) => o -> m PixbufAnimationIter+toPixbufAnimationIter = liftIO . unsafeCastTo PixbufAnimationIter++-- | A convenience alias for `Nothing` :: `Maybe` `PixbufAnimationIter`.+noPixbufAnimationIter :: Maybe PixbufAnimationIter+noPixbufAnimationIter = Nothing++#if ENABLE_OVERLOADING+type family ResolvePixbufAnimationIterMethod (t :: Symbol) (o :: *) :: * where+    ResolvePixbufAnimationIterMethod "advance" o = PixbufAnimationIterAdvanceMethodInfo+    ResolvePixbufAnimationIterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolvePixbufAnimationIterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolvePixbufAnimationIterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolvePixbufAnimationIterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolvePixbufAnimationIterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolvePixbufAnimationIterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolvePixbufAnimationIterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolvePixbufAnimationIterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolvePixbufAnimationIterMethod "onCurrentlyLoadingFrame" o = PixbufAnimationIterOnCurrentlyLoadingFrameMethodInfo+    ResolvePixbufAnimationIterMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolvePixbufAnimationIterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolvePixbufAnimationIterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolvePixbufAnimationIterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolvePixbufAnimationIterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolvePixbufAnimationIterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolvePixbufAnimationIterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolvePixbufAnimationIterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolvePixbufAnimationIterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolvePixbufAnimationIterMethod "getDelayTime" o = PixbufAnimationIterGetDelayTimeMethodInfo+    ResolvePixbufAnimationIterMethod "getPixbuf" o = PixbufAnimationIterGetPixbufMethodInfo+    ResolvePixbufAnimationIterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolvePixbufAnimationIterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolvePixbufAnimationIterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolvePixbufAnimationIterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolvePixbufAnimationIterMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolvePixbufAnimationIterMethod t PixbufAnimationIter, O.MethodInfo info PixbufAnimationIter p) => OL.IsLabel t (PixbufAnimationIter -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList PixbufAnimationIter+type instance O.AttributeList PixbufAnimationIter = PixbufAnimationIterAttributeList+type PixbufAnimationIterAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList PixbufAnimationIter = PixbufAnimationIterSignalList+type PixbufAnimationIterSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method PixbufAnimationIter::advance+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimationIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufAnimationIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "current_time", argType = TInterface (Name {namespace = "GLib", name = "TimeVal"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "current time", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_iter_advance" gdk_pixbuf_animation_iter_advance :: +    Ptr PixbufAnimationIter ->              -- iter : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimationIter"})+    Ptr GLib.TimeVal.TimeVal ->             -- current_time : TInterface (Name {namespace = "GLib", name = "TimeVal"})+    IO CInt++{- |+Possibly advances an animation to a new frame. Chooses the frame based+on the start time passed to 'GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationGetIter'.++/@currentTime@/ would normally come from 'GI.GLib.Functions.getCurrentTime', and+must be greater than or equal to the time passed to+'GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationGetIter', and must increase or remain+unchanged each time 'GI.GdkPixbuf.Objects.PixbufAnimationIter.pixbufAnimationIterGetPixbuf' is+called. That is, you can\'t go backward in time; animations only+play forward.++As a shortcut, pass 'Nothing' for the current time and 'GI.GLib.Functions.getCurrentTime'+will be invoked on your behalf. So you only need to explicitly pass+/@currentTime@/ if you\'re doing something odd like playing the animation+at double speed.++If this function returns 'False', there\'s no need to update the animation+display, assuming the display had been rendered prior to advancing;+if 'True', you need to call 'GI.GdkPixbuf.Objects.PixbufAnimationIter.pixbufAnimationIterGetPixbuf'+and update the display with the new pixbuf.+-}+pixbufAnimationIterAdvance ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimationIter a) =>+    a+    {- ^ /@iter@/: a 'GI.GdkPixbuf.Objects.PixbufAnimationIter.PixbufAnimationIter' -}+    -> Maybe (GLib.TimeVal.TimeVal)+    {- ^ /@currentTime@/: current time -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the image may need updating -}+pixbufAnimationIterAdvance iter currentTime = liftIO $ do+    iter' <- unsafeManagedPtrCastPtr iter+    maybeCurrentTime <- case currentTime of+        Nothing -> return nullPtr+        Just jCurrentTime -> do+            jCurrentTime' <- unsafeManagedPtrGetPtr jCurrentTime+            return jCurrentTime'+    result <- gdk_pixbuf_animation_iter_advance iter' maybeCurrentTime+    let result' = (/= 0) result+    touchManagedPtr iter+    whenJust currentTime touchManagedPtr+    return result'++#if ENABLE_OVERLOADING+data PixbufAnimationIterAdvanceMethodInfo+instance (signature ~ (Maybe (GLib.TimeVal.TimeVal) -> m Bool), MonadIO m, IsPixbufAnimationIter a) => O.MethodInfo PixbufAnimationIterAdvanceMethodInfo a signature where+    overloadedMethod _ = pixbufAnimationIterAdvance++#endif++-- method PixbufAnimationIter::get_delay_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimationIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an animation iterator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_iter_get_delay_time" gdk_pixbuf_animation_iter_get_delay_time :: +    Ptr PixbufAnimationIter ->              -- iter : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimationIter"})+    IO Int32++{- |+Gets the number of milliseconds the current pixbuf should be displayed,+or -1 if the current pixbuf should be displayed forever. @/g_timeout_add()/@+conveniently takes a timeout in milliseconds, so you can use a timeout+to schedule the next update.++Note that some formats, like GIF, might clamp the timeout values in the+image file to avoid updates that are just too quick. The minimum timeout+for GIF images is currently 20 milliseconds.+-}+pixbufAnimationIterGetDelayTime ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimationIter a) =>+    a+    {- ^ /@iter@/: an animation iterator -}+    -> m Int32+    {- ^ __Returns:__ delay time in milliseconds (thousandths of a second) -}+pixbufAnimationIterGetDelayTime iter = liftIO $ do+    iter' <- unsafeManagedPtrCastPtr iter+    result <- gdk_pixbuf_animation_iter_get_delay_time iter'+    touchManagedPtr iter+    return result++#if ENABLE_OVERLOADING+data PixbufAnimationIterGetDelayTimeMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsPixbufAnimationIter a) => O.MethodInfo PixbufAnimationIterGetDelayTimeMethodInfo a signature where+    overloadedMethod _ = pixbufAnimationIterGetDelayTime++#endif++-- method PixbufAnimationIter::get_pixbuf+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimationIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an animation iterator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_iter_get_pixbuf" gdk_pixbuf_animation_iter_get_pixbuf :: +    Ptr PixbufAnimationIter ->              -- iter : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimationIter"})+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)++{- |+Gets the current pixbuf which should be displayed; the pixbuf might not+be the same size as the animation itself+('GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationGetWidth', 'GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationGetHeight').+This pixbuf should be displayed for+'GI.GdkPixbuf.Objects.PixbufAnimationIter.pixbufAnimationIterGetDelayTime' milliseconds. The caller+of this function does not own a reference to the returned pixbuf;+the returned pixbuf will become invalid when the iterator advances+to the next frame, which may happen anytime you call+'GI.GdkPixbuf.Objects.PixbufAnimationIter.pixbufAnimationIterAdvance'. Copy the pixbuf to keep it+(don\'t just add a reference), as it may get recycled as you advance+the iterator.+-}+pixbufAnimationIterGetPixbuf ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimationIter a) =>+    a+    {- ^ /@iter@/: an animation iterator -}+    -> m GdkPixbuf.Pixbuf.Pixbuf+    {- ^ __Returns:__ the pixbuf to be displayed -}+pixbufAnimationIterGetPixbuf iter = liftIO $ do+    iter' <- unsafeManagedPtrCastPtr iter+    result <- gdk_pixbuf_animation_iter_get_pixbuf iter'+    checkUnexpectedReturnNULL "pixbufAnimationIterGetPixbuf" result+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result+    touchManagedPtr iter+    return result'++#if ENABLE_OVERLOADING+data PixbufAnimationIterGetPixbufMethodInfo+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsPixbufAnimationIter a) => O.MethodInfo PixbufAnimationIterGetPixbufMethodInfo a signature where+    overloadedMethod _ = pixbufAnimationIterGetPixbuf++#endif++-- method PixbufAnimationIter::on_currently_loading_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimationIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufAnimationIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_animation_iter_on_currently_loading_frame" gdk_pixbuf_animation_iter_on_currently_loading_frame :: +    Ptr PixbufAnimationIter ->              -- iter : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimationIter"})+    IO CInt++{- |+Used to determine how to respond to the area_updated signal on+'GI.GdkPixbuf.Objects.PixbufLoader.PixbufLoader' when loading an animation. area_updated is emitted+for an area of the frame currently streaming in to the loader. So if+you\'re on the currently loading frame, you need to redraw the screen for+the updated area.+-}+pixbufAnimationIterOnCurrentlyLoadingFrame ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimationIter a) =>+    a+    {- ^ /@iter@/: a 'GI.GdkPixbuf.Objects.PixbufAnimationIter.PixbufAnimationIter' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the frame we\'re on is partially loaded, or the last frame -}+pixbufAnimationIterOnCurrentlyLoadingFrame iter = liftIO $ do+    iter' <- unsafeManagedPtrCastPtr iter+    result <- gdk_pixbuf_animation_iter_on_currently_loading_frame iter'+    let result' = (/= 0) result+    touchManagedPtr iter+    return result'++#if ENABLE_OVERLOADING+data PixbufAnimationIterOnCurrentlyLoadingFrameMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsPixbufAnimationIter a) => O.MethodInfo PixbufAnimationIterOnCurrentlyLoadingFrameMethodInfo a signature where+    overloadedMethod _ = pixbufAnimationIterOnCurrentlyLoadingFrame++#endif++

@@ -0,0 +1,41 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GdkPixbuf.Objects.PixbufAnimationIter where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++newtype PixbufAnimationIter = PixbufAnimationIter (ManagedPtr PixbufAnimationIter)+instance GObject PixbufAnimationIter where+class (GObject o, O.IsDescendantOf PixbufAnimationIter o) => IsPixbufAnimationIter o+instance (GObject o, O.IsDescendantOf PixbufAnimationIter o) => IsPixbufAnimationIter o+instance O.HasParentTypes PixbufAnimationIter+#if ENABLE_OVERLOADING+data PixbufAnimationIterAdvanceMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufAnimationIterGetDelayTimeMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufAnimationIterGetPixbufMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufAnimationIterOnCurrentlyLoadingFrameMethodInfo+#endif

@@ -0,0 +1,1052 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++The GdkPixbufLoader struct contains only private+fields.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GdkPixbuf.Objects.PixbufLoader+    ( ++-- * Exported types+    PixbufLoader(..)                        ,+    IsPixbufLoader                          ,+    toPixbufLoader                          ,+    noPixbufLoader                          ,+++ -- * Methods+-- ** close #method:close#++#if ENABLE_OVERLOADING+    PixbufLoaderCloseMethodInfo             ,+#endif+    pixbufLoaderClose                       ,+++-- ** getAnimation #method:getAnimation#++#if ENABLE_OVERLOADING+    PixbufLoaderGetAnimationMethodInfo      ,+#endif+    pixbufLoaderGetAnimation                ,+++-- ** getFormat #method:getFormat#++#if ENABLE_OVERLOADING+    PixbufLoaderGetFormatMethodInfo         ,+#endif+    pixbufLoaderGetFormat                   ,+++-- ** getPixbuf #method:getPixbuf#++#if ENABLE_OVERLOADING+    PixbufLoaderGetPixbufMethodInfo         ,+#endif+    pixbufLoaderGetPixbuf                   ,+++-- ** new #method:new#++    pixbufLoaderNew                         ,+++-- ** newWithMimeType #method:newWithMimeType#++    pixbufLoaderNewWithMimeType             ,+++-- ** newWithType #method:newWithType#++    pixbufLoaderNewWithType                 ,+++-- ** setSize #method:setSize#++#if ENABLE_OVERLOADING+    PixbufLoaderSetSizeMethodInfo           ,+#endif+    pixbufLoaderSetSize                     ,+++-- ** write #method:write#++#if ENABLE_OVERLOADING+    PixbufLoaderWriteMethodInfo             ,+#endif+    pixbufLoaderWrite                       ,+++-- ** writeBytes #method:writeBytes#++#if ENABLE_OVERLOADING+    PixbufLoaderWriteBytesMethodInfo        ,+#endif+    pixbufLoaderWriteBytes                  ,+++++ -- * Signals+-- ** areaPrepared #signal:areaPrepared#++    C_PixbufLoaderAreaPreparedCallback      ,+    PixbufLoaderAreaPreparedCallback        ,+#if ENABLE_OVERLOADING+    PixbufLoaderAreaPreparedSignalInfo      ,+#endif+    afterPixbufLoaderAreaPrepared           ,+    genClosure_PixbufLoaderAreaPrepared     ,+    mk_PixbufLoaderAreaPreparedCallback     ,+    noPixbufLoaderAreaPreparedCallback      ,+    onPixbufLoaderAreaPrepared              ,+    wrap_PixbufLoaderAreaPreparedCallback   ,+++-- ** areaUpdated #signal:areaUpdated#++    C_PixbufLoaderAreaUpdatedCallback       ,+    PixbufLoaderAreaUpdatedCallback         ,+#if ENABLE_OVERLOADING+    PixbufLoaderAreaUpdatedSignalInfo       ,+#endif+    afterPixbufLoaderAreaUpdated            ,+    genClosure_PixbufLoaderAreaUpdated      ,+    mk_PixbufLoaderAreaUpdatedCallback      ,+    noPixbufLoaderAreaUpdatedCallback       ,+    onPixbufLoaderAreaUpdated               ,+    wrap_PixbufLoaderAreaUpdatedCallback    ,+++-- ** closed #signal:closed#++    C_PixbufLoaderClosedCallback            ,+    PixbufLoaderClosedCallback              ,+#if ENABLE_OVERLOADING+    PixbufLoaderClosedSignalInfo            ,+#endif+    afterPixbufLoaderClosed                 ,+    genClosure_PixbufLoaderClosed           ,+    mk_PixbufLoaderClosedCallback           ,+    noPixbufLoaderClosedCallback            ,+    onPixbufLoaderClosed                    ,+    wrap_PixbufLoaderClosedCallback         ,+++-- ** sizePrepared #signal:sizePrepared#++    C_PixbufLoaderSizePreparedCallback      ,+    PixbufLoaderSizePreparedCallback        ,+#if ENABLE_OVERLOADING+    PixbufLoaderSizePreparedSignalInfo      ,+#endif+    afterPixbufLoaderSizePrepared           ,+    genClosure_PixbufLoaderSizePrepared     ,+    mk_PixbufLoaderSizePreparedCallback     ,+    noPixbufLoaderSizePreparedCallback      ,+    onPixbufLoaderSizePrepared              ,+    wrap_PixbufLoaderSizePreparedCallback   ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import qualified GI.GLib.Structs.Bytes as GLib.Bytes+import qualified GI.GObject.Objects.Object as GObject.Object+import {-# SOURCE #-} qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf+import {-# SOURCE #-} qualified GI.GdkPixbuf.Objects.PixbufAnimation as GdkPixbuf.PixbufAnimation+import {-# SOURCE #-} qualified GI.GdkPixbuf.Structs.PixbufFormat as GdkPixbuf.PixbufFormat++-- | Memory-managed wrapper type.+newtype PixbufLoader = PixbufLoader (ManagedPtr PixbufLoader)+foreign import ccall "gdk_pixbuf_loader_get_type"+    c_gdk_pixbuf_loader_get_type :: IO GType++instance GObject PixbufLoader where+    gobjectType = c_gdk_pixbuf_loader_get_type+    ++-- | Type class for types which can be safely cast to `PixbufLoader`, for instance with `toPixbufLoader`.+class (GObject o, O.IsDescendantOf PixbufLoader o) => IsPixbufLoader o+instance (GObject o, O.IsDescendantOf PixbufLoader o) => IsPixbufLoader o++instance O.HasParentTypes PixbufLoader+type instance O.ParentTypes PixbufLoader = '[GObject.Object.Object]++-- | Cast to `PixbufLoader`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toPixbufLoader :: (MonadIO m, IsPixbufLoader o) => o -> m PixbufLoader+toPixbufLoader = liftIO . unsafeCastTo PixbufLoader++-- | A convenience alias for `Nothing` :: `Maybe` `PixbufLoader`.+noPixbufLoader :: Maybe PixbufLoader+noPixbufLoader = Nothing++#if ENABLE_OVERLOADING+type family ResolvePixbufLoaderMethod (t :: Symbol) (o :: *) :: * where+    ResolvePixbufLoaderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolvePixbufLoaderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolvePixbufLoaderMethod "close" o = PixbufLoaderCloseMethodInfo+    ResolvePixbufLoaderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolvePixbufLoaderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolvePixbufLoaderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolvePixbufLoaderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolvePixbufLoaderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolvePixbufLoaderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolvePixbufLoaderMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolvePixbufLoaderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolvePixbufLoaderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolvePixbufLoaderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolvePixbufLoaderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolvePixbufLoaderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolvePixbufLoaderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolvePixbufLoaderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolvePixbufLoaderMethod "write" o = PixbufLoaderWriteMethodInfo+    ResolvePixbufLoaderMethod "writeBytes" o = PixbufLoaderWriteBytesMethodInfo+    ResolvePixbufLoaderMethod "getAnimation" o = PixbufLoaderGetAnimationMethodInfo+    ResolvePixbufLoaderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolvePixbufLoaderMethod "getFormat" o = PixbufLoaderGetFormatMethodInfo+    ResolvePixbufLoaderMethod "getPixbuf" o = PixbufLoaderGetPixbufMethodInfo+    ResolvePixbufLoaderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolvePixbufLoaderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolvePixbufLoaderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolvePixbufLoaderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolvePixbufLoaderMethod "setSize" o = PixbufLoaderSetSizeMethodInfo+    ResolvePixbufLoaderMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolvePixbufLoaderMethod t PixbufLoader, O.MethodInfo info PixbufLoader p) => OL.IsLabel t (PixbufLoader -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- signal PixbufLoader::area-prepared+{- |+This signal is emitted when the pixbuf loader has allocated the+pixbuf in the desired size.  After this signal is emitted,+applications can call 'GI.GdkPixbuf.Objects.PixbufLoader.pixbufLoaderGetPixbuf' to fetch+the partially-loaded pixbuf.+-}+type PixbufLoaderAreaPreparedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `PixbufLoaderAreaPreparedCallback`@.+noPixbufLoaderAreaPreparedCallback :: Maybe PixbufLoaderAreaPreparedCallback+noPixbufLoaderAreaPreparedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_PixbufLoaderAreaPreparedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_PixbufLoaderAreaPreparedCallback`.+foreign import ccall "wrapper"+    mk_PixbufLoaderAreaPreparedCallback :: C_PixbufLoaderAreaPreparedCallback -> IO (FunPtr C_PixbufLoaderAreaPreparedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_PixbufLoaderAreaPrepared :: MonadIO m => PixbufLoaderAreaPreparedCallback -> m (GClosure C_PixbufLoaderAreaPreparedCallback)+genClosure_PixbufLoaderAreaPrepared cb = liftIO $ do+    let cb' = wrap_PixbufLoaderAreaPreparedCallback cb+    mk_PixbufLoaderAreaPreparedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `PixbufLoaderAreaPreparedCallback` into a `C_PixbufLoaderAreaPreparedCallback`.+wrap_PixbufLoaderAreaPreparedCallback ::+    PixbufLoaderAreaPreparedCallback ->+    C_PixbufLoaderAreaPreparedCallback+wrap_PixbufLoaderAreaPreparedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@area-prepared@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' pixbufLoader #areaPrepared callback+@+-}+onPixbufLoaderAreaPrepared :: (IsPixbufLoader a, MonadIO m) => a -> PixbufLoaderAreaPreparedCallback -> m SignalHandlerId+onPixbufLoaderAreaPrepared obj cb = liftIO $ do+    let cb' = wrap_PixbufLoaderAreaPreparedCallback cb+    cb'' <- mk_PixbufLoaderAreaPreparedCallback cb'+    connectSignalFunPtr obj "area-prepared" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@area-prepared@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' pixbufLoader #areaPrepared callback+@+-}+afterPixbufLoaderAreaPrepared :: (IsPixbufLoader a, MonadIO m) => a -> PixbufLoaderAreaPreparedCallback -> m SignalHandlerId+afterPixbufLoaderAreaPrepared obj cb = liftIO $ do+    let cb' = wrap_PixbufLoaderAreaPreparedCallback cb+    cb'' <- mk_PixbufLoaderAreaPreparedCallback cb'+    connectSignalFunPtr obj "area-prepared" cb'' SignalConnectAfter+++-- signal PixbufLoader::area-updated+{- |+This signal is emitted when a significant area of the image being+loaded has been updated.  Normally it means that a complete+scanline has been read in, but it could be a different area as+well.  Applications can use this signal to know when to repaint+areas of an image that is being loaded.+-}+type PixbufLoaderAreaUpdatedCallback =+    Int32+    {- ^ /@x@/: X offset of upper-left corner of the updated area. -}+    -> Int32+    {- ^ /@y@/: Y offset of upper-left corner of the updated area. -}+    -> Int32+    {- ^ /@width@/: Width of updated area. -}+    -> Int32+    {- ^ /@height@/: Height of updated area. -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `PixbufLoaderAreaUpdatedCallback`@.+noPixbufLoaderAreaUpdatedCallback :: Maybe PixbufLoaderAreaUpdatedCallback+noPixbufLoaderAreaUpdatedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_PixbufLoaderAreaUpdatedCallback =+    Ptr () ->                               -- object+    Int32 ->+    Int32 ->+    Int32 ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_PixbufLoaderAreaUpdatedCallback`.+foreign import ccall "wrapper"+    mk_PixbufLoaderAreaUpdatedCallback :: C_PixbufLoaderAreaUpdatedCallback -> IO (FunPtr C_PixbufLoaderAreaUpdatedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_PixbufLoaderAreaUpdated :: MonadIO m => PixbufLoaderAreaUpdatedCallback -> m (GClosure C_PixbufLoaderAreaUpdatedCallback)+genClosure_PixbufLoaderAreaUpdated cb = liftIO $ do+    let cb' = wrap_PixbufLoaderAreaUpdatedCallback cb+    mk_PixbufLoaderAreaUpdatedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `PixbufLoaderAreaUpdatedCallback` into a `C_PixbufLoaderAreaUpdatedCallback`.+wrap_PixbufLoaderAreaUpdatedCallback ::+    PixbufLoaderAreaUpdatedCallback ->+    C_PixbufLoaderAreaUpdatedCallback+wrap_PixbufLoaderAreaUpdatedCallback _cb _ x y width height _ = do+    _cb  x y width height+++{- |+Connect a signal handler for the “@area-updated@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' pixbufLoader #areaUpdated callback+@+-}+onPixbufLoaderAreaUpdated :: (IsPixbufLoader a, MonadIO m) => a -> PixbufLoaderAreaUpdatedCallback -> m SignalHandlerId+onPixbufLoaderAreaUpdated obj cb = liftIO $ do+    let cb' = wrap_PixbufLoaderAreaUpdatedCallback cb+    cb'' <- mk_PixbufLoaderAreaUpdatedCallback cb'+    connectSignalFunPtr obj "area-updated" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@area-updated@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' pixbufLoader #areaUpdated callback+@+-}+afterPixbufLoaderAreaUpdated :: (IsPixbufLoader a, MonadIO m) => a -> PixbufLoaderAreaUpdatedCallback -> m SignalHandlerId+afterPixbufLoaderAreaUpdated obj cb = liftIO $ do+    let cb' = wrap_PixbufLoaderAreaUpdatedCallback cb+    cb'' <- mk_PixbufLoaderAreaUpdatedCallback cb'+    connectSignalFunPtr obj "area-updated" cb'' SignalConnectAfter+++-- signal PixbufLoader::closed+{- |+This signal is emitted when 'GI.GdkPixbuf.Objects.PixbufLoader.pixbufLoaderClose' is called.+It can be used by different parts of an application to receive+notification when an image loader is closed by the code that+drives it.+-}+type PixbufLoaderClosedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `PixbufLoaderClosedCallback`@.+noPixbufLoaderClosedCallback :: Maybe PixbufLoaderClosedCallback+noPixbufLoaderClosedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_PixbufLoaderClosedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_PixbufLoaderClosedCallback`.+foreign import ccall "wrapper"+    mk_PixbufLoaderClosedCallback :: C_PixbufLoaderClosedCallback -> IO (FunPtr C_PixbufLoaderClosedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_PixbufLoaderClosed :: MonadIO m => PixbufLoaderClosedCallback -> m (GClosure C_PixbufLoaderClosedCallback)+genClosure_PixbufLoaderClosed cb = liftIO $ do+    let cb' = wrap_PixbufLoaderClosedCallback cb+    mk_PixbufLoaderClosedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `PixbufLoaderClosedCallback` into a `C_PixbufLoaderClosedCallback`.+wrap_PixbufLoaderClosedCallback ::+    PixbufLoaderClosedCallback ->+    C_PixbufLoaderClosedCallback+wrap_PixbufLoaderClosedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@closed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' pixbufLoader #closed callback+@+-}+onPixbufLoaderClosed :: (IsPixbufLoader a, MonadIO m) => a -> PixbufLoaderClosedCallback -> m SignalHandlerId+onPixbufLoaderClosed obj cb = liftIO $ do+    let cb' = wrap_PixbufLoaderClosedCallback cb+    cb'' <- mk_PixbufLoaderClosedCallback cb'+    connectSignalFunPtr obj "closed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@closed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' pixbufLoader #closed callback+@+-}+afterPixbufLoaderClosed :: (IsPixbufLoader a, MonadIO m) => a -> PixbufLoaderClosedCallback -> m SignalHandlerId+afterPixbufLoaderClosed obj cb = liftIO $ do+    let cb' = wrap_PixbufLoaderClosedCallback cb+    cb'' <- mk_PixbufLoaderClosedCallback cb'+    connectSignalFunPtr obj "closed" cb'' SignalConnectAfter+++-- signal PixbufLoader::size-prepared+{- |+This signal is emitted when the pixbuf loader has been fed the+initial amount of data that is required to figure out the size+of the image that it will create.  Applications can call+'GI.GdkPixbuf.Objects.PixbufLoader.pixbufLoaderSetSize' in response to this signal to set+the desired size to which the image should be scaled.+-}+type PixbufLoaderSizePreparedCallback =+    Int32+    {- ^ /@width@/: the original width of the image -}+    -> Int32+    {- ^ /@height@/: the original height of the image -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `PixbufLoaderSizePreparedCallback`@.+noPixbufLoaderSizePreparedCallback :: Maybe PixbufLoaderSizePreparedCallback+noPixbufLoaderSizePreparedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_PixbufLoaderSizePreparedCallback =+    Ptr () ->                               -- object+    Int32 ->+    Int32 ->+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_PixbufLoaderSizePreparedCallback`.+foreign import ccall "wrapper"+    mk_PixbufLoaderSizePreparedCallback :: C_PixbufLoaderSizePreparedCallback -> IO (FunPtr C_PixbufLoaderSizePreparedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_PixbufLoaderSizePrepared :: MonadIO m => PixbufLoaderSizePreparedCallback -> m (GClosure C_PixbufLoaderSizePreparedCallback)+genClosure_PixbufLoaderSizePrepared cb = liftIO $ do+    let cb' = wrap_PixbufLoaderSizePreparedCallback cb+    mk_PixbufLoaderSizePreparedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `PixbufLoaderSizePreparedCallback` into a `C_PixbufLoaderSizePreparedCallback`.+wrap_PixbufLoaderSizePreparedCallback ::+    PixbufLoaderSizePreparedCallback ->+    C_PixbufLoaderSizePreparedCallback+wrap_PixbufLoaderSizePreparedCallback _cb _ width height _ = do+    _cb  width height+++{- |+Connect a signal handler for the “@size-prepared@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' pixbufLoader #sizePrepared callback+@+-}+onPixbufLoaderSizePrepared :: (IsPixbufLoader a, MonadIO m) => a -> PixbufLoaderSizePreparedCallback -> m SignalHandlerId+onPixbufLoaderSizePrepared obj cb = liftIO $ do+    let cb' = wrap_PixbufLoaderSizePreparedCallback cb+    cb'' <- mk_PixbufLoaderSizePreparedCallback cb'+    connectSignalFunPtr obj "size-prepared" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@size-prepared@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' pixbufLoader #sizePrepared callback+@+-}+afterPixbufLoaderSizePrepared :: (IsPixbufLoader a, MonadIO m) => a -> PixbufLoaderSizePreparedCallback -> m SignalHandlerId+afterPixbufLoaderSizePrepared obj cb = liftIO $ do+    let cb' = wrap_PixbufLoaderSizePreparedCallback cb+    cb'' <- mk_PixbufLoaderSizePreparedCallback cb'+    connectSignalFunPtr obj "size-prepared" cb'' SignalConnectAfter+++#if ENABLE_OVERLOADING+instance O.HasAttributeList PixbufLoader+type instance O.AttributeList PixbufLoader = PixbufLoaderAttributeList+type PixbufLoaderAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+data PixbufLoaderAreaPreparedSignalInfo+instance SignalInfo PixbufLoaderAreaPreparedSignalInfo where+    type HaskellCallbackType PixbufLoaderAreaPreparedSignalInfo = PixbufLoaderAreaPreparedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_PixbufLoaderAreaPreparedCallback cb+        cb'' <- mk_PixbufLoaderAreaPreparedCallback cb'+        connectSignalFunPtr obj "area-prepared" cb'' connectMode++data PixbufLoaderAreaUpdatedSignalInfo+instance SignalInfo PixbufLoaderAreaUpdatedSignalInfo where+    type HaskellCallbackType PixbufLoaderAreaUpdatedSignalInfo = PixbufLoaderAreaUpdatedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_PixbufLoaderAreaUpdatedCallback cb+        cb'' <- mk_PixbufLoaderAreaUpdatedCallback cb'+        connectSignalFunPtr obj "area-updated" cb'' connectMode++data PixbufLoaderClosedSignalInfo+instance SignalInfo PixbufLoaderClosedSignalInfo where+    type HaskellCallbackType PixbufLoaderClosedSignalInfo = PixbufLoaderClosedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_PixbufLoaderClosedCallback cb+        cb'' <- mk_PixbufLoaderClosedCallback cb'+        connectSignalFunPtr obj "closed" cb'' connectMode++data PixbufLoaderSizePreparedSignalInfo+instance SignalInfo PixbufLoaderSizePreparedSignalInfo where+    type HaskellCallbackType PixbufLoaderSizePreparedSignalInfo = PixbufLoaderSizePreparedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_PixbufLoaderSizePreparedCallback cb+        cb'' <- mk_PixbufLoaderSizePreparedCallback cb'+        connectSignalFunPtr obj "size-prepared" cb'' connectMode++type instance O.SignalList PixbufLoader = PixbufLoaderSignalList+type PixbufLoaderSignalList = ('[ '("areaPrepared", PixbufLoaderAreaPreparedSignalInfo), '("areaUpdated", PixbufLoaderAreaUpdatedSignalInfo), '("closed", PixbufLoaderClosedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sizePrepared", PixbufLoaderSizePreparedSignalInfo)] :: [(Symbol, *)])++#endif++-- method PixbufLoader::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_loader_new" gdk_pixbuf_loader_new :: +    IO (Ptr PixbufLoader)++{- |+Creates a new pixbuf loader object.+-}+pixbufLoaderNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m PixbufLoader+    {- ^ __Returns:__ A newly-created pixbuf loader. -}+pixbufLoaderNew  = liftIO $ do+    result <- gdk_pixbuf_loader_new+    checkUnexpectedReturnNULL "pixbufLoaderNew" result+    result' <- (wrapObject PixbufLoader) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method PixbufLoader::new_with_mime_type+-- method type : Constructor+-- Args : [Arg {argCName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the mime type to be loaded", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_loader_new_with_mime_type" gdk_pixbuf_loader_new_with_mime_type :: +    CString ->                              -- mime_type : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr PixbufLoader)++{- |+Creates a new pixbuf loader object that always attempts to parse+image data as if it were an image of mime type /@mimeType@/, instead of+identifying the type automatically. Useful if you want an error if+the image isn\'t the expected mime type, for loading image formats+that can\'t be reliably identified by looking at the data, or if+the user manually forces a specific mime type.++The list of supported mime types depends on what image loaders+are installed, but typically \"image\/png\", \"image\/jpeg\", \"image\/gif\",+\"image\/tiff\" and \"image\/x-xpixmap\" are among the supported mime types.+To obtain the full list of supported mime types, call+'GI.GdkPixbuf.Structs.PixbufFormat.pixbufFormatGetMimeTypes' on each of the 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat'+structs returned by 'GI.GdkPixbuf.Objects.Pixbuf.pixbufGetFormats'.++/Since: 2.4/+-}+pixbufLoaderNewWithMimeType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@mimeType@/: the mime type to be loaded -}+    -> m PixbufLoader+    {- ^ __Returns:__ A newly-created pixbuf loader. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufLoaderNewWithMimeType mimeType = liftIO $ do+    mimeType' <- textToCString mimeType+    onException (do+        result <- propagateGError $ gdk_pixbuf_loader_new_with_mime_type mimeType'+        checkUnexpectedReturnNULL "pixbufLoaderNewWithMimeType" result+        result' <- (wrapObject PixbufLoader) result+        freeMem mimeType'+        return result'+     ) (do+        freeMem mimeType'+     )++#if ENABLE_OVERLOADING+#endif++-- method PixbufLoader::new_with_type+-- method type : Constructor+-- Args : [Arg {argCName = "image_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of the image format to be loaded with the image", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"}))+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_loader_new_with_type" gdk_pixbuf_loader_new_with_type :: +    CString ->                              -- image_type : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr PixbufLoader)++{- |+Creates a new pixbuf loader object that always attempts to parse+image data as if it were an image of type /@imageType@/, instead of+identifying the type automatically. Useful if you want an error if+the image isn\'t the expected type, for loading image formats+that can\'t be reliably identified by looking at the data, or if+the user manually forces a specific type.++The list of supported image formats depends on what image loaders+are installed, but typically \"png\", \"jpeg\", \"gif\", \"tiff\" and+\"xpm\" are among the supported formats. To obtain the full list of+supported image formats, call 'GI.GdkPixbuf.Structs.PixbufFormat.pixbufFormatGetName' on each+of the 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' structs returned by 'GI.GdkPixbuf.Objects.Pixbuf.pixbufGetFormats'.+-}+pixbufLoaderNewWithType ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@imageType@/: name of the image format to be loaded with the image -}+    -> m PixbufLoader+    {- ^ __Returns:__ A newly-created pixbuf loader. /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufLoaderNewWithType imageType = liftIO $ do+    imageType' <- textToCString imageType+    onException (do+        result <- propagateGError $ gdk_pixbuf_loader_new_with_type imageType'+        checkUnexpectedReturnNULL "pixbufLoaderNewWithType" result+        result' <- (wrapObject PixbufLoader) result+        freeMem imageType'+        return result'+     ) (do+        freeMem imageType'+     )++#if ENABLE_OVERLOADING+#endif++-- method PixbufLoader::close+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf loader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_loader_close" gdk_pixbuf_loader_close :: +    Ptr PixbufLoader ->                     -- loader : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"})+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+Informs a pixbuf loader that no further writes with+'GI.GdkPixbuf.Objects.PixbufLoader.pixbufLoaderWrite' will occur, so that it can free its+internal loading structures. Also, tries to parse any data that+hasn\'t yet been parsed; if the remaining data is partial or+corrupt, an error will be returned.  If 'False' is returned, /@error@/+will be set to an error from the @/GDK_PIXBUF_ERROR/@ or @/G_FILE_ERROR/@+domains. If you\'re just cancelling a load rather than expecting it+to be finished, passing 'Nothing' for /@error@/ to ignore it is+reasonable.++Remember that this does not unref the loader, so if you plan not to+use it anymore, please 'GI.GObject.Objects.Object.objectUnref' it.+-}+pixbufLoaderClose ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufLoader a) =>+    a+    {- ^ /@loader@/: A pixbuf loader. -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufLoaderClose loader = liftIO $ do+    loader' <- unsafeManagedPtrCastPtr loader+    onException (do+        _ <- propagateGError $ gdk_pixbuf_loader_close loader'+        touchManagedPtr loader+        return ()+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+data PixbufLoaderCloseMethodInfo+instance (signature ~ (m ()), MonadIO m, IsPixbufLoader a) => O.MethodInfo PixbufLoaderCloseMethodInfo a signature where+    overloadedMethod _ = pixbufLoaderClose++#endif++-- method PixbufLoader::get_animation+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf loader", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufAnimation"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_loader_get_animation" gdk_pixbuf_loader_get_animation :: +    Ptr PixbufLoader ->                     -- loader : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"})+    IO (Ptr GdkPixbuf.PixbufAnimation.PixbufAnimation)++{- |+Queries the 'GI.GdkPixbuf.Objects.PixbufAnimation.PixbufAnimation' that a pixbuf loader is currently creating.+In general it only makes sense to call this function after the \"area-prepared\"+signal has been emitted by the loader. If the loader doesn\'t have enough+bytes yet (hasn\'t emitted the \"area-prepared\" signal) this function will+return 'Nothing'.+-}+pixbufLoaderGetAnimation ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufLoader a) =>+    a+    {- ^ /@loader@/: A pixbuf loader -}+    -> m GdkPixbuf.PixbufAnimation.PixbufAnimation+    {- ^ __Returns:__ The 'GI.GdkPixbuf.Objects.PixbufAnimation.PixbufAnimation' that the loader is loading, or 'Nothing' if+not enough data has been read to determine the information. -}+pixbufLoaderGetAnimation loader = liftIO $ do+    loader' <- unsafeManagedPtrCastPtr loader+    result <- gdk_pixbuf_loader_get_animation loader'+    checkUnexpectedReturnNULL "pixbufLoaderGetAnimation" result+    result' <- (newObject GdkPixbuf.PixbufAnimation.PixbufAnimation) result+    touchManagedPtr loader+    return result'++#if ENABLE_OVERLOADING+data PixbufLoaderGetAnimationMethodInfo+instance (signature ~ (m GdkPixbuf.PixbufAnimation.PixbufAnimation), MonadIO m, IsPixbufLoader a) => O.MethodInfo PixbufLoaderGetAnimationMethodInfo a signature where+    overloadedMethod _ = pixbufLoaderGetAnimation++#endif++-- method PixbufLoader::get_format+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf loader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_loader_get_format" gdk_pixbuf_loader_get_format :: +    Ptr PixbufLoader ->                     -- loader : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"})+    IO (Ptr GdkPixbuf.PixbufFormat.PixbufFormat)++{- |+Obtains the available information about the format of the+currently loading image file.++/Since: 2.2/+-}+pixbufLoaderGetFormat ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufLoader a) =>+    a+    {- ^ /@loader@/: A pixbuf loader. -}+    -> m (Maybe GdkPixbuf.PixbufFormat.PixbufFormat)+    {- ^ __Returns:__ A 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' or+'Nothing'. The return value is owned by GdkPixbuf and should not be+freed. -}+pixbufLoaderGetFormat loader = liftIO $ do+    loader' <- unsafeManagedPtrCastPtr loader+    result <- gdk_pixbuf_loader_get_format loader'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newBoxed GdkPixbuf.PixbufFormat.PixbufFormat) result'+        return result''+    touchManagedPtr loader+    return maybeResult++#if ENABLE_OVERLOADING+data PixbufLoaderGetFormatMethodInfo+instance (signature ~ (m (Maybe GdkPixbuf.PixbufFormat.PixbufFormat)), MonadIO m, IsPixbufLoader a) => O.MethodInfo PixbufLoaderGetFormatMethodInfo a signature where+    overloadedMethod _ = pixbufLoaderGetFormat++#endif++-- method PixbufLoader::get_pixbuf+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf loader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_loader_get_pixbuf" gdk_pixbuf_loader_get_pixbuf :: +    Ptr PixbufLoader ->                     -- loader : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"})+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)++{- |+Queries the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' that a pixbuf loader is currently creating.+In general it only makes sense to call this function after the+\"area-prepared\" signal has been emitted by the loader; this means+that enough data has been read to know the size of the image that+will be allocated.  If the loader has not received enough data via+'GI.GdkPixbuf.Objects.PixbufLoader.pixbufLoaderWrite', then this function returns 'Nothing'.  The+returned pixbuf will be the same in all future calls to the loader,+so simply calling 'GI.GObject.Objects.Object.objectRef' should be sufficient to continue+using it.  Additionally, if the loader is an animation, it will+return the \"static image\" of the animation+(see 'GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationGetStaticImage').+-}+pixbufLoaderGetPixbuf ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufLoader a) =>+    a+    {- ^ /@loader@/: A pixbuf loader. -}+    -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)+    {- ^ __Returns:__ The 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' that the loader is creating, or 'Nothing' if not+enough data has been read to determine how to create the image buffer. -}+pixbufLoaderGetPixbuf loader = liftIO $ do+    loader' <- unsafeManagedPtrCastPtr loader+    result <- gdk_pixbuf_loader_get_pixbuf loader'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result'+        return result''+    touchManagedPtr loader+    return maybeResult++#if ENABLE_OVERLOADING+data PixbufLoaderGetPixbufMethodInfo+instance (signature ~ (m (Maybe GdkPixbuf.Pixbuf.Pixbuf)), MonadIO m, IsPixbufLoader a) => O.MethodInfo PixbufLoaderGetPixbufMethodInfo a signature where+    overloadedMethod _ = pixbufLoaderGetPixbuf++#endif++-- method PixbufLoader::set_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf loader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The desired width of the image being loaded.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The desired height of the image being loaded.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_loader_set_size" gdk_pixbuf_loader_set_size :: +    Ptr PixbufLoader ->                     -- loader : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"})+    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    IO ()++{- |+Causes the image to be scaled while it is loaded. The desired+image size can be determined relative to the original size of+the image by calling 'GI.GdkPixbuf.Objects.PixbufLoader.pixbufLoaderSetSize' from a+signal handler for the ::size-prepared signal.++Attempts to set the desired image size  are ignored after the+emission of the ::size-prepared signal.++/Since: 2.2/+-}+pixbufLoaderSetSize ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufLoader a) =>+    a+    {- ^ /@loader@/: A pixbuf loader. -}+    -> Int32+    {- ^ /@width@/: The desired width of the image being loaded. -}+    -> Int32+    {- ^ /@height@/: The desired height of the image being loaded. -}+    -> m ()+pixbufLoaderSetSize loader width height = liftIO $ do+    loader' <- unsafeManagedPtrCastPtr loader+    gdk_pixbuf_loader_set_size loader' width height+    touchManagedPtr loader+    return ()++#if ENABLE_OVERLOADING+data PixbufLoaderSetSizeMethodInfo+instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsPixbufLoader a) => O.MethodInfo PixbufLoaderSetSizeMethodInfo a signature where+    overloadedMethod _ = pixbufLoaderSetSize++#endif++-- method PixbufLoader::write+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf loader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Pointer to image data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length of the @buf buffer in bytes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Length of the @buf buffer in bytes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_loader_write" gdk_pixbuf_loader_write :: +    Ptr PixbufLoader ->                     -- loader : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"})+    Ptr Word8 ->                            -- buf : TCArray False (-1) 2 (TBasicType TUInt8)+    Word64 ->                               -- count : TBasicType TUInt64+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+This will cause a pixbuf loader to parse the next /@count@/ bytes of+an image.  It will return 'True' if the data was loaded successfully,+and 'False' if an error occurred.  In the latter case, the loader+will be closed, and will not accept further writes. If 'False' is+returned, /@error@/ will be set to an error from the @/GDK_PIXBUF_ERROR/@+or @/G_FILE_ERROR/@ domains.+-}+pixbufLoaderWrite ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufLoader a) =>+    a+    {- ^ /@loader@/: A pixbuf loader. -}+    -> ByteString+    {- ^ /@buf@/: Pointer to image data. -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufLoaderWrite loader buf = liftIO $ do+    let count = fromIntegral $ B.length buf+    loader' <- unsafeManagedPtrCastPtr loader+    buf' <- packByteString buf+    onException (do+        _ <- propagateGError $ gdk_pixbuf_loader_write loader' buf' count+        touchManagedPtr loader+        freeMem buf'+        return ()+     ) (do+        freeMem buf'+     )++#if ENABLE_OVERLOADING+data PixbufLoaderWriteMethodInfo+instance (signature ~ (ByteString -> m ()), MonadIO m, IsPixbufLoader a) => O.MethodInfo PixbufLoaderWriteMethodInfo a signature where+    overloadedMethod _ = pixbufLoaderWrite++#endif++-- method PixbufLoader::write_bytes+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pixbuf loader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The image data as a #GBytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : True+-- Skip return : False++foreign import ccall "gdk_pixbuf_loader_write_bytes" gdk_pixbuf_loader_write_bytes :: +    Ptr PixbufLoader ->                     -- loader : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufLoader"})+    Ptr GLib.Bytes.Bytes ->                 -- buffer : TInterface (Name {namespace = "GLib", name = "Bytes"})+    Ptr (Ptr GError) ->                     -- error+    IO CInt++{- |+This will cause a pixbuf loader to parse a buffer inside a 'GI.GLib.Structs.Bytes.Bytes'+for an image.  It will return 'True' if the data was loaded successfully,+and 'False' if an error occurred.  In the latter case, the loader+will be closed, and will not accept further writes. If 'False' is+returned, /@error@/ will be set to an error from the @/GDK_PIXBUF_ERROR/@+or @/G_FILE_ERROR/@ domains.++See also: 'GI.GdkPixbuf.Objects.PixbufLoader.pixbufLoaderWrite'++/Since: 2.30/+-}+pixbufLoaderWriteBytes ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufLoader a) =>+    a+    {- ^ /@loader@/: A pixbuf loader. -}+    -> GLib.Bytes.Bytes+    {- ^ /@buffer@/: The image data as a 'GI.GLib.Structs.Bytes.Bytes' -}+    -> m ()+    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}+pixbufLoaderWriteBytes loader buffer = liftIO $ do+    loader' <- unsafeManagedPtrCastPtr loader+    buffer' <- unsafeManagedPtrGetPtr buffer+    onException (do+        _ <- propagateGError $ gdk_pixbuf_loader_write_bytes loader' buffer'+        touchManagedPtr loader+        touchManagedPtr buffer+        return ()+     ) (do+        return ()+     )++#if ENABLE_OVERLOADING+data PixbufLoaderWriteBytesMethodInfo+instance (signature ~ (GLib.Bytes.Bytes -> m ()), MonadIO m, IsPixbufLoader a) => O.MethodInfo PixbufLoaderWriteBytesMethodInfo a signature where+    overloadedMethod _ = pixbufLoaderWriteBytes++#endif++

@@ -0,0 +1,62 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GdkPixbuf.Objects.PixbufLoader where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++newtype PixbufLoader = PixbufLoader (ManagedPtr PixbufLoader)+instance GObject PixbufLoader where+class (GObject o, O.IsDescendantOf PixbufLoader o) => IsPixbufLoader o+instance (GObject o, O.IsDescendantOf PixbufLoader o) => IsPixbufLoader o+instance O.HasParentTypes PixbufLoader+#if ENABLE_OVERLOADING+data PixbufLoaderAreaPreparedSignalInfo+#endif+#if ENABLE_OVERLOADING+data PixbufLoaderAreaUpdatedSignalInfo+#endif+#if ENABLE_OVERLOADING+data PixbufLoaderClosedSignalInfo+#endif+#if ENABLE_OVERLOADING+data PixbufLoaderSizePreparedSignalInfo+#endif+#if ENABLE_OVERLOADING+data PixbufLoaderCloseMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufLoaderGetAnimationMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufLoaderGetFormatMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufLoaderGetPixbufMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufLoaderSetSizeMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufLoaderWriteMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufLoaderWriteBytesMethodInfo+#endif

@@ -0,0 +1,390 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++An opaque struct representing a simple animation.+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GdkPixbuf.Objects.PixbufSimpleAnim+    ( ++-- * Exported types+    PixbufSimpleAnim(..)                    ,+    IsPixbufSimpleAnim                      ,+    toPixbufSimpleAnim                      ,+    noPixbufSimpleAnim                      ,+++ -- * Methods+-- ** addFrame #method:addFrame#++#if ENABLE_OVERLOADING+    PixbufSimpleAnimAddFrameMethodInfo      ,+#endif+    pixbufSimpleAnimAddFrame                ,+++-- ** getLoop #method:getLoop#++#if ENABLE_OVERLOADING+    PixbufSimpleAnimGetLoopMethodInfo       ,+#endif+    pixbufSimpleAnimGetLoop                 ,+++-- ** new #method:new#++    pixbufSimpleAnimNew                     ,+++-- ** setLoop #method:setLoop#++#if ENABLE_OVERLOADING+    PixbufSimpleAnimSetLoopMethodInfo       ,+#endif+    pixbufSimpleAnimSetLoop                 ,+++++ -- * Properties+-- ** loop #attr:loop#+{- | Whether the animation should loop when it reaches the end.++/Since: 2.18/+-}+#if ENABLE_OVERLOADING+    PixbufSimpleAnimLoopPropertyInfo        ,+#endif+    constructPixbufSimpleAnimLoop           ,+    getPixbufSimpleAnimLoop                 ,+#if ENABLE_OVERLOADING+    pixbufSimpleAnimLoop                    ,+#endif+    setPixbufSimpleAnimLoop                 ,+++++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import qualified GI.GObject.Objects.Object as GObject.Object+import {-# SOURCE #-} qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf+import {-# SOURCE #-} qualified GI.GdkPixbuf.Objects.PixbufAnimation as GdkPixbuf.PixbufAnimation++-- | Memory-managed wrapper type.+newtype PixbufSimpleAnim = PixbufSimpleAnim (ManagedPtr PixbufSimpleAnim)+foreign import ccall "gdk_pixbuf_simple_anim_get_type"+    c_gdk_pixbuf_simple_anim_get_type :: IO GType++instance GObject PixbufSimpleAnim where+    gobjectType = c_gdk_pixbuf_simple_anim_get_type+    ++-- | Type class for types which can be safely cast to `PixbufSimpleAnim`, for instance with `toPixbufSimpleAnim`.+class (GObject o, O.IsDescendantOf PixbufSimpleAnim o) => IsPixbufSimpleAnim o+instance (GObject o, O.IsDescendantOf PixbufSimpleAnim o) => IsPixbufSimpleAnim o++instance O.HasParentTypes PixbufSimpleAnim+type instance O.ParentTypes PixbufSimpleAnim = '[GdkPixbuf.PixbufAnimation.PixbufAnimation, GObject.Object.Object]++-- | Cast to `PixbufSimpleAnim`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toPixbufSimpleAnim :: (MonadIO m, IsPixbufSimpleAnim o) => o -> m PixbufSimpleAnim+toPixbufSimpleAnim = liftIO . unsafeCastTo PixbufSimpleAnim++-- | A convenience alias for `Nothing` :: `Maybe` `PixbufSimpleAnim`.+noPixbufSimpleAnim :: Maybe PixbufSimpleAnim+noPixbufSimpleAnim = Nothing++#if ENABLE_OVERLOADING+type family ResolvePixbufSimpleAnimMethod (t :: Symbol) (o :: *) :: * where+    ResolvePixbufSimpleAnimMethod "addFrame" o = PixbufSimpleAnimAddFrameMethodInfo+    ResolvePixbufSimpleAnimMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolvePixbufSimpleAnimMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolvePixbufSimpleAnimMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolvePixbufSimpleAnimMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolvePixbufSimpleAnimMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolvePixbufSimpleAnimMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolvePixbufSimpleAnimMethod "isStaticImage" o = GdkPixbuf.PixbufAnimation.PixbufAnimationIsStaticImageMethodInfo+    ResolvePixbufSimpleAnimMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolvePixbufSimpleAnimMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolvePixbufSimpleAnimMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolvePixbufSimpleAnimMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolvePixbufSimpleAnimMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolvePixbufSimpleAnimMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolvePixbufSimpleAnimMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolvePixbufSimpleAnimMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolvePixbufSimpleAnimMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolvePixbufSimpleAnimMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolvePixbufSimpleAnimMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolvePixbufSimpleAnimMethod "getHeight" o = GdkPixbuf.PixbufAnimation.PixbufAnimationGetHeightMethodInfo+    ResolvePixbufSimpleAnimMethod "getIter" o = GdkPixbuf.PixbufAnimation.PixbufAnimationGetIterMethodInfo+    ResolvePixbufSimpleAnimMethod "getLoop" o = PixbufSimpleAnimGetLoopMethodInfo+    ResolvePixbufSimpleAnimMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolvePixbufSimpleAnimMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolvePixbufSimpleAnimMethod "getStaticImage" o = GdkPixbuf.PixbufAnimation.PixbufAnimationGetStaticImageMethodInfo+    ResolvePixbufSimpleAnimMethod "getWidth" o = GdkPixbuf.PixbufAnimation.PixbufAnimationGetWidthMethodInfo+    ResolvePixbufSimpleAnimMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolvePixbufSimpleAnimMethod "setLoop" o = PixbufSimpleAnimSetLoopMethodInfo+    ResolvePixbufSimpleAnimMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolvePixbufSimpleAnimMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolvePixbufSimpleAnimMethod t PixbufSimpleAnim, O.MethodInfo info PixbufSimpleAnim p) => OL.IsLabel t (PixbufSimpleAnim -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- VVV Prop "loop"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@loop@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' pixbufSimpleAnim #loop+@+-}+getPixbufSimpleAnimLoop :: (MonadIO m, IsPixbufSimpleAnim o) => o -> m Bool+getPixbufSimpleAnimLoop obj = liftIO $ B.Properties.getObjectPropertyBool obj "loop"++{- |+Set the value of the “@loop@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' pixbufSimpleAnim [ #loop 'Data.GI.Base.Attributes.:=' value ]+@+-}+setPixbufSimpleAnimLoop :: (MonadIO m, IsPixbufSimpleAnim o) => o -> Bool -> m ()+setPixbufSimpleAnimLoop obj val = liftIO $ B.Properties.setObjectPropertyBool obj "loop" val++{- |+Construct a `GValueConstruct` with valid value for the “@loop@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructPixbufSimpleAnimLoop :: (IsPixbufSimpleAnim o) => Bool -> IO (GValueConstruct o)+constructPixbufSimpleAnimLoop val = B.Properties.constructObjectPropertyBool "loop" val++#if ENABLE_OVERLOADING+data PixbufSimpleAnimLoopPropertyInfo+instance AttrInfo PixbufSimpleAnimLoopPropertyInfo where+    type AttrAllowedOps PixbufSimpleAnimLoopPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PixbufSimpleAnimLoopPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PixbufSimpleAnimLoopPropertyInfo = IsPixbufSimpleAnim+    type AttrGetType PixbufSimpleAnimLoopPropertyInfo = Bool+    type AttrLabel PixbufSimpleAnimLoopPropertyInfo = "loop"+    type AttrOrigin PixbufSimpleAnimLoopPropertyInfo = PixbufSimpleAnim+    attrGet _ = getPixbufSimpleAnimLoop+    attrSet _ = setPixbufSimpleAnimLoop+    attrConstruct _ = constructPixbufSimpleAnimLoop+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList PixbufSimpleAnim+type instance O.AttributeList PixbufSimpleAnim = PixbufSimpleAnimAttributeList+type PixbufSimpleAnimAttributeList = ('[ '("loop", PixbufSimpleAnimLoopPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+pixbufSimpleAnimLoop :: AttrLabelProxy "loop"+pixbufSimpleAnimLoop = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList PixbufSimpleAnim = PixbufSimpleAnimSignalList+type PixbufSimpleAnimSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method PixbufSimpleAnim::new+-- method type : Constructor+-- Args : [Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width of the animation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height of the animation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the speed of the animation, in frames per second", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "PixbufSimpleAnim"}))+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_simple_anim_new" gdk_pixbuf_simple_anim_new :: +    Int32 ->                                -- width : TBasicType TInt+    Int32 ->                                -- height : TBasicType TInt+    CFloat ->                               -- rate : TBasicType TFloat+    IO (Ptr PixbufSimpleAnim)++{- |+Creates a new, empty animation.++/Since: 2.8/+-}+pixbufSimpleAnimNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    Int32+    {- ^ /@width@/: the width of the animation -}+    -> Int32+    {- ^ /@height@/: the height of the animation -}+    -> Float+    {- ^ /@rate@/: the speed of the animation, in frames per second -}+    -> m PixbufSimpleAnim+    {- ^ __Returns:__ a newly allocated 'GI.GdkPixbuf.Objects.PixbufSimpleAnim.PixbufSimpleAnim' -}+pixbufSimpleAnimNew width height rate = liftIO $ do+    let rate' = realToFrac rate+    result <- gdk_pixbuf_simple_anim_new width height rate'+    checkUnexpectedReturnNULL "pixbufSimpleAnimNew" result+    result' <- (wrapObject PixbufSimpleAnim) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method PixbufSimpleAnim::add_frame+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "animation", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufSimpleAnim"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufSimpleAnim", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the pixbuf to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_simple_anim_add_frame" gdk_pixbuf_simple_anim_add_frame :: +    Ptr PixbufSimpleAnim ->                 -- animation : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufSimpleAnim"})+    Ptr GdkPixbuf.Pixbuf.Pixbuf ->          -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})+    IO ()++{- |+Adds a new frame to /@animation@/. The /@pixbuf@/ must+have the dimensions specified when the animation+was constructed.++/Since: 2.8/+-}+pixbufSimpleAnimAddFrame ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufSimpleAnim a, GdkPixbuf.Pixbuf.IsPixbuf b) =>+    a+    {- ^ /@animation@/: a 'GI.GdkPixbuf.Objects.PixbufSimpleAnim.PixbufSimpleAnim' -}+    -> b+    {- ^ /@pixbuf@/: the pixbuf to add -}+    -> m ()+pixbufSimpleAnimAddFrame animation pixbuf = liftIO $ do+    animation' <- unsafeManagedPtrCastPtr animation+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf+    gdk_pixbuf_simple_anim_add_frame animation' pixbuf'+    touchManagedPtr animation+    touchManagedPtr pixbuf+    return ()++#if ENABLE_OVERLOADING+data PixbufSimpleAnimAddFrameMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsPixbufSimpleAnim a, GdkPixbuf.Pixbuf.IsPixbuf b) => O.MethodInfo PixbufSimpleAnimAddFrameMethodInfo a signature where+    overloadedMethod _ = pixbufSimpleAnimAddFrame++#endif++-- method PixbufSimpleAnim::get_loop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "animation", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufSimpleAnim"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufSimpleAnim", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_simple_anim_get_loop" gdk_pixbuf_simple_anim_get_loop :: +    Ptr PixbufSimpleAnim ->                 -- animation : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufSimpleAnim"})+    IO CInt++{- |+Gets whether /@animation@/ should loop indefinitely when it reaches the end.++/Since: 2.18/+-}+pixbufSimpleAnimGetLoop ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufSimpleAnim a) =>+    a+    {- ^ /@animation@/: a 'GI.GdkPixbuf.Objects.PixbufSimpleAnim.PixbufSimpleAnim' -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the animation loops forever, 'False' otherwise -}+pixbufSimpleAnimGetLoop animation = liftIO $ do+    animation' <- unsafeManagedPtrCastPtr animation+    result <- gdk_pixbuf_simple_anim_get_loop animation'+    let result' = (/= 0) result+    touchManagedPtr animation+    return result'++#if ENABLE_OVERLOADING+data PixbufSimpleAnimGetLoopMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsPixbufSimpleAnim a) => O.MethodInfo PixbufSimpleAnimGetLoopMethodInfo a signature where+    overloadedMethod _ = pixbufSimpleAnimGetLoop++#endif++-- method PixbufSimpleAnim::set_loop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "animation", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufSimpleAnim"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufSimpleAnim", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "loop", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to loop the animation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "gdk_pixbuf_simple_anim_set_loop" gdk_pixbuf_simple_anim_set_loop :: +    Ptr PixbufSimpleAnim ->                 -- animation : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufSimpleAnim"})+    CInt ->                                 -- loop : TBasicType TBoolean+    IO ()++{- |+Sets whether /@animation@/ should loop indefinitely when it reaches the end.++/Since: 2.18/+-}+pixbufSimpleAnimSetLoop ::+    (B.CallStack.HasCallStack, MonadIO m, IsPixbufSimpleAnim a) =>+    a+    {- ^ /@animation@/: a 'GI.GdkPixbuf.Objects.PixbufSimpleAnim.PixbufSimpleAnim' -}+    -> Bool+    {- ^ /@loop@/: whether to loop the animation -}+    -> m ()+pixbufSimpleAnimSetLoop animation loop = liftIO $ do+    animation' <- unsafeManagedPtrCastPtr animation+    let loop' = (fromIntegral . fromEnum) loop+    gdk_pixbuf_simple_anim_set_loop animation' loop'+    touchManagedPtr animation+    return ()++#if ENABLE_OVERLOADING+data PixbufSimpleAnimSetLoopMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, IsPixbufSimpleAnim a) => O.MethodInfo PixbufSimpleAnimSetLoopMethodInfo a signature where+    overloadedMethod _ = pixbufSimpleAnimSetLoop++#endif++

@@ -0,0 +1,41 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GdkPixbuf.Objects.PixbufSimpleAnim where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++newtype PixbufSimpleAnim = PixbufSimpleAnim (ManagedPtr PixbufSimpleAnim)+instance GObject PixbufSimpleAnim where+class (GObject o, O.IsDescendantOf PixbufSimpleAnim o) => IsPixbufSimpleAnim o+instance (GObject o, O.IsDescendantOf PixbufSimpleAnim o) => IsPixbufSimpleAnim o+instance O.HasParentTypes PixbufSimpleAnim+#if ENABLE_OVERLOADING+data PixbufSimpleAnimLoopPropertyInfo+#endif+#if ENABLE_OVERLOADING+data PixbufSimpleAnimAddFrameMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufSimpleAnimGetLoopMethodInfo+#endif+#if ENABLE_OVERLOADING+data PixbufSimpleAnimSetLoopMethodInfo+#endif

@@ -0,0 +1,126 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GdkPixbuf.Objects.PixbufSimpleAnimIter+    ( ++-- * Exported types+    PixbufSimpleAnimIter(..)                ,+    IsPixbufSimpleAnimIter                  ,+    toPixbufSimpleAnimIter                  ,+    noPixbufSimpleAnimIter                  ,+++    ) where++import Data.GI.Base.ShortPrelude+import qualified Data.GI.Base.ShortPrelude as SP+import qualified Data.GI.Base.Overloading as O+import qualified Prelude as P++import qualified Data.GI.Base.Attributes as GI.Attributes+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+import qualified Data.GI.Base.GVariant as B.GVariant+import qualified Data.GI.Base.GValue as B.GValue+import qualified Data.GI.Base.GParamSpec as B.GParamSpec+import qualified Data.GI.Base.CallStack as B.CallStack+import qualified Data.GI.Base.Properties as B.Properties+import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+import qualified Foreign.Ptr as FP+import qualified GHC.OverloadedLabels as OL++import qualified GI.GObject.Objects.Object as GObject.Object+import {-# SOURCE #-} qualified GI.GdkPixbuf.Objects.PixbufAnimationIter as GdkPixbuf.PixbufAnimationIter++-- | Memory-managed wrapper type.+newtype PixbufSimpleAnimIter = PixbufSimpleAnimIter (ManagedPtr PixbufSimpleAnimIter)+foreign import ccall "gdk_pixbuf_simple_anim_iter_get_type"+    c_gdk_pixbuf_simple_anim_iter_get_type :: IO GType++instance GObject PixbufSimpleAnimIter where+    gobjectType = c_gdk_pixbuf_simple_anim_iter_get_type+    ++-- | Type class for types which can be safely cast to `PixbufSimpleAnimIter`, for instance with `toPixbufSimpleAnimIter`.+class (GObject o, O.IsDescendantOf PixbufSimpleAnimIter o) => IsPixbufSimpleAnimIter o+instance (GObject o, O.IsDescendantOf PixbufSimpleAnimIter o) => IsPixbufSimpleAnimIter o++instance O.HasParentTypes PixbufSimpleAnimIter+type instance O.ParentTypes PixbufSimpleAnimIter = '[GdkPixbuf.PixbufAnimationIter.PixbufAnimationIter, GObject.Object.Object]++-- | Cast to `PixbufSimpleAnimIter`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toPixbufSimpleAnimIter :: (MonadIO m, IsPixbufSimpleAnimIter o) => o -> m PixbufSimpleAnimIter+toPixbufSimpleAnimIter = liftIO . unsafeCastTo PixbufSimpleAnimIter++-- | A convenience alias for `Nothing` :: `Maybe` `PixbufSimpleAnimIter`.+noPixbufSimpleAnimIter :: Maybe PixbufSimpleAnimIter+noPixbufSimpleAnimIter = Nothing++#if ENABLE_OVERLOADING+type family ResolvePixbufSimpleAnimIterMethod (t :: Symbol) (o :: *) :: * where+    ResolvePixbufSimpleAnimIterMethod "advance" o = GdkPixbuf.PixbufAnimationIter.PixbufAnimationIterAdvanceMethodInfo+    ResolvePixbufSimpleAnimIterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolvePixbufSimpleAnimIterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolvePixbufSimpleAnimIterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolvePixbufSimpleAnimIterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolvePixbufSimpleAnimIterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolvePixbufSimpleAnimIterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolvePixbufSimpleAnimIterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolvePixbufSimpleAnimIterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolvePixbufSimpleAnimIterMethod "onCurrentlyLoadingFrame" o = GdkPixbuf.PixbufAnimationIter.PixbufAnimationIterOnCurrentlyLoadingFrameMethodInfo+    ResolvePixbufSimpleAnimIterMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolvePixbufSimpleAnimIterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolvePixbufSimpleAnimIterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolvePixbufSimpleAnimIterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolvePixbufSimpleAnimIterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolvePixbufSimpleAnimIterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolvePixbufSimpleAnimIterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolvePixbufSimpleAnimIterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolvePixbufSimpleAnimIterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolvePixbufSimpleAnimIterMethod "getDelayTime" o = GdkPixbuf.PixbufAnimationIter.PixbufAnimationIterGetDelayTimeMethodInfo+    ResolvePixbufSimpleAnimIterMethod "getPixbuf" o = GdkPixbuf.PixbufAnimationIter.PixbufAnimationIterGetPixbufMethodInfo+    ResolvePixbufSimpleAnimIterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolvePixbufSimpleAnimIterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolvePixbufSimpleAnimIterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolvePixbufSimpleAnimIterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolvePixbufSimpleAnimIterMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolvePixbufSimpleAnimIterMethod t PixbufSimpleAnimIter, O.MethodInfo info PixbufSimpleAnimIter p) => OL.IsLabel t (PixbufSimpleAnimIter -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList PixbufSimpleAnimIter+type instance O.AttributeList PixbufSimpleAnimIter = PixbufSimpleAnimIterAttributeList+type PixbufSimpleAnimIterAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList PixbufSimpleAnimIter = PixbufSimpleAnimIterSignalList+type PixbufSimpleAnimIterSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++