diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -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. diff --git a/GI/GdkPixbuf.hs b/GI/GdkPixbuf.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf.hs @@ -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 + diff --git a/GI/GdkPixbuf/Callbacks.hs b/GI/GdkPixbuf/Callbacks.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Callbacks.hs @@ -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 + + + diff --git a/GI/GdkPixbuf/Constants.hs b/GI/GdkPixbuf/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Constants.hs @@ -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 + + diff --git a/GI/GdkPixbuf/Enums.hs b/GI/GdkPixbuf/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Enums.hs @@ -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 + + diff --git a/GI/GdkPixbuf/Enums.hs-boot b/GI/GdkPixbuf/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Enums.hs-boot @@ -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 diff --git a/GI/GdkPixbuf/Objects.hs b/GI/GdkPixbuf/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects.hs @@ -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 + + + diff --git a/GI/GdkPixbuf/Objects/Pixbuf.hs b/GI/GdkPixbuf/Objects/Pixbuf.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/Pixbuf.hs @@ -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 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 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 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 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 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 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 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 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 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. + +<> +-} +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 + + diff --git a/GI/GdkPixbuf/Objects/Pixbuf.hs-boot b/GI/GdkPixbuf/Objects/Pixbuf.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/Pixbuf.hs-boot @@ -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 diff --git a/GI/GdkPixbuf/Objects/PixbufAnimation.hs b/GI/GdkPixbuf/Objects/PixbufAnimation.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/PixbufAnimation.hs @@ -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 + + diff --git a/GI/GdkPixbuf/Objects/PixbufAnimation.hs-boot b/GI/GdkPixbuf/Objects/PixbufAnimation.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/PixbufAnimation.hs-boot @@ -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 diff --git a/GI/GdkPixbuf/Objects/PixbufAnimationIter.hs b/GI/GdkPixbuf/Objects/PixbufAnimationIter.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/PixbufAnimationIter.hs @@ -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 + + diff --git a/GI/GdkPixbuf/Objects/PixbufAnimationIter.hs-boot b/GI/GdkPixbuf/Objects/PixbufAnimationIter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/PixbufAnimationIter.hs-boot @@ -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 diff --git a/GI/GdkPixbuf/Objects/PixbufLoader.hs b/GI/GdkPixbuf/Objects/PixbufLoader.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/PixbufLoader.hs @@ -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 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 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 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 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 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 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 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 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 + + diff --git a/GI/GdkPixbuf/Objects/PixbufLoader.hs-boot b/GI/GdkPixbuf/Objects/PixbufLoader.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/PixbufLoader.hs-boot @@ -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 diff --git a/GI/GdkPixbuf/Objects/PixbufSimpleAnim.hs b/GI/GdkPixbuf/Objects/PixbufSimpleAnim.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/PixbufSimpleAnim.hs @@ -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 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 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 + + diff --git a/GI/GdkPixbuf/Objects/PixbufSimpleAnim.hs-boot b/GI/GdkPixbuf/Objects/PixbufSimpleAnim.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/PixbufSimpleAnim.hs-boot @@ -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 diff --git a/GI/GdkPixbuf/Objects/PixbufSimpleAnimIter.hs b/GI/GdkPixbuf/Objects/PixbufSimpleAnimIter.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/PixbufSimpleAnimIter.hs @@ -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 + + diff --git a/GI/GdkPixbuf/Objects/PixbufSimpleAnimIter.hs-boot b/GI/GdkPixbuf/Objects/PixbufSimpleAnimIter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Objects/PixbufSimpleAnimIter.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkPixbuf.Objects.PixbufSimpleAnimIter 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 PixbufSimpleAnimIter = PixbufSimpleAnimIter (ManagedPtr PixbufSimpleAnimIter) +instance GObject PixbufSimpleAnimIter where +class (GObject o, O.IsDescendantOf PixbufSimpleAnimIter o) => IsPixbufSimpleAnimIter o +instance (GObject o, O.IsDescendantOf PixbufSimpleAnimIter o) => IsPixbufSimpleAnimIter o +instance O.HasParentTypes PixbufSimpleAnimIter diff --git a/GI/GdkPixbuf/Structs.hs b/GI/GdkPixbuf/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Structs.hs @@ -0,0 +1,41 @@ + + +{- | +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.Structs + ( module GI.GdkPixbuf.Structs.PixbufFormat, + + + ) where + +import GI.GdkPixbuf.Structs.PixbufFormat + +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 + + + diff --git a/GI/GdkPixbuf/Structs/PixbufFormat.hs b/GI/GdkPixbuf/Structs/PixbufFormat.hs new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Structs/PixbufFormat.hs @@ -0,0 +1,667 @@ + + +{- | +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.Structs.PixbufFormat + ( + +-- * Exported types + PixbufFormat(..) , + noPixbufFormat , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + PixbufFormatCopyMethodInfo , +#endif + pixbufFormatCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + PixbufFormatFreeMethodInfo , +#endif + pixbufFormatFree , + + +-- ** getDescription #method:getDescription# + +#if ENABLE_OVERLOADING + PixbufFormatGetDescriptionMethodInfo , +#endif + pixbufFormatGetDescription , + + +-- ** getExtensions #method:getExtensions# + +#if ENABLE_OVERLOADING + PixbufFormatGetExtensionsMethodInfo , +#endif + pixbufFormatGetExtensions , + + +-- ** getLicense #method:getLicense# + +#if ENABLE_OVERLOADING + PixbufFormatGetLicenseMethodInfo , +#endif + pixbufFormatGetLicense , + + +-- ** getMimeTypes #method:getMimeTypes# + +#if ENABLE_OVERLOADING + PixbufFormatGetMimeTypesMethodInfo , +#endif + pixbufFormatGetMimeTypes , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + PixbufFormatGetNameMethodInfo , +#endif + pixbufFormatGetName , + + +-- ** isDisabled #method:isDisabled# + +#if ENABLE_OVERLOADING + PixbufFormatIsDisabledMethodInfo , +#endif + pixbufFormatIsDisabled , + + +-- ** isSaveOptionSupported #method:isSaveOptionSupported# + +#if ENABLE_OVERLOADING + PixbufFormatIsSaveOptionSupportedMethodInfo, +#endif + pixbufFormatIsSaveOptionSupported , + + +-- ** isScalable #method:isScalable# + +#if ENABLE_OVERLOADING + PixbufFormatIsScalableMethodInfo , +#endif + pixbufFormatIsScalable , + + +-- ** isWritable #method:isWritable# + +#if ENABLE_OVERLOADING + PixbufFormatIsWritableMethodInfo , +#endif + pixbufFormatIsWritable , + + +-- ** setDisabled #method:setDisabled# + +#if ENABLE_OVERLOADING + PixbufFormatSetDisabledMethodInfo , +#endif + pixbufFormatSetDisabled , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype PixbufFormat = PixbufFormat (ManagedPtr PixbufFormat) +foreign import ccall "gdk_pixbuf_format_get_type" c_gdk_pixbuf_format_get_type :: + IO GType + +instance BoxedObject PixbufFormat where + boxedType _ = c_gdk_pixbuf_format_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `PixbufFormat`. +noPixbufFormat :: Maybe PixbufFormat +noPixbufFormat = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList PixbufFormat +type instance O.AttributeList PixbufFormat = PixbufFormatAttributeList +type PixbufFormatAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method PixbufFormat::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", 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_format_copy" gdk_pixbuf_format_copy :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + IO (Ptr PixbufFormat) + +{- | +Creates a copy of /@format@/ + +/Since: 2.22/ +-} +pixbufFormatCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> m PixbufFormat + {- ^ __Returns:__ the newly allocated copy of a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat'. Use + 'GI.GdkPixbuf.Structs.PixbufFormat.pixbufFormatFree' to free the resources when done -} +pixbufFormatCopy format = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + result <- gdk_pixbuf_format_copy format' + checkUnexpectedReturnNULL "pixbufFormatCopy" result + result' <- (wrapBoxed PixbufFormat) result + touchManagedPtr format + return result' + +#if ENABLE_OVERLOADING +data PixbufFormatCopyMethodInfo +instance (signature ~ (m PixbufFormat), MonadIO m) => O.MethodInfo PixbufFormatCopyMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatCopy + +#endif + +-- method PixbufFormat::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", 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_format_free" gdk_pixbuf_format_free :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + IO () + +{- | +Frees the resources allocated when copying a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' +using 'GI.GdkPixbuf.Structs.PixbufFormat.pixbufFormatCopy' + +/Since: 2.22/ +-} +pixbufFormatFree :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> m () +pixbufFormatFree format = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + gdk_pixbuf_format_free format' + touchManagedPtr format + return () + +#if ENABLE_OVERLOADING +data PixbufFormatFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo PixbufFormatFreeMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatFree + +#endif + +-- method PixbufFormat::get_description +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", 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_format_get_description" gdk_pixbuf_format_get_description :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + IO CString + +{- | +Returns a description of the format. + +/Since: 2.2/ +-} +pixbufFormatGetDescription :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> m T.Text + {- ^ __Returns:__ a description of the format. -} +pixbufFormatGetDescription format = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + result <- gdk_pixbuf_format_get_description format' + checkUnexpectedReturnNULL "pixbufFormatGetDescription" result + result' <- cstringToText result + freeMem result + touchManagedPtr format + return result' + +#if ENABLE_OVERLOADING +data PixbufFormatGetDescriptionMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo PixbufFormatGetDescriptionMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatGetDescription + +#endif + +-- method PixbufFormat::get_extensions +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_pixbuf_format_get_extensions" gdk_pixbuf_format_get_extensions :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + IO (Ptr CString) + +{- | +Returns the filename extensions typically used for files in the +given format. + +/Since: 2.2/ +-} +pixbufFormatGetExtensions :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> m [T.Text] + {- ^ __Returns:__ a 'Nothing'-terminated array of filename extensions which must be +freed with 'GI.GLib.Functions.strfreev' when it is no longer needed. -} +pixbufFormatGetExtensions format = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + result <- gdk_pixbuf_format_get_extensions format' + checkUnexpectedReturnNULL "pixbufFormatGetExtensions" result + result' <- unpackZeroTerminatedUTF8CArray result + mapZeroTerminatedCArray freeMem result + freeMem result + touchManagedPtr format + return result' + +#if ENABLE_OVERLOADING +data PixbufFormatGetExtensionsMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m) => O.MethodInfo PixbufFormatGetExtensionsMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatGetExtensions + +#endif + +-- method PixbufFormat::get_license +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", 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_format_get_license" gdk_pixbuf_format_get_license :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + IO CString + +{- | +Returns information about the license of the image loader for the format. The +returned string should be a shorthand for a wellknown license, e.g. \"LGPL\", +\"GPL\", \"QPL\", \"GPL\/QPL\", or \"other\" to indicate some other license. This +string should be freed with 'GI.GLib.Functions.free' when it\'s no longer needed. + +/Since: 2.6/ +-} +pixbufFormatGetLicense :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> m T.Text + {- ^ __Returns:__ a string describing the license of /@format@/. -} +pixbufFormatGetLicense format = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + result <- gdk_pixbuf_format_get_license format' + checkUnexpectedReturnNULL "pixbufFormatGetLicense" result + result' <- cstringToText result + freeMem result + touchManagedPtr format + return result' + +#if ENABLE_OVERLOADING +data PixbufFormatGetLicenseMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo PixbufFormatGetLicenseMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatGetLicense + +#endif + +-- method PixbufFormat::get_mime_types +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_pixbuf_format_get_mime_types" gdk_pixbuf_format_get_mime_types :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + IO (Ptr CString) + +{- | +Returns the mime types supported by the format. + +/Since: 2.2/ +-} +pixbufFormatGetMimeTypes :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> m [T.Text] + {- ^ __Returns:__ a 'Nothing'-terminated array of mime types which must be freed with +'GI.GLib.Functions.strfreev' when it is no longer needed. -} +pixbufFormatGetMimeTypes format = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + result <- gdk_pixbuf_format_get_mime_types format' + checkUnexpectedReturnNULL "pixbufFormatGetMimeTypes" result + result' <- unpackZeroTerminatedUTF8CArray result + mapZeroTerminatedCArray freeMem result + freeMem result + touchManagedPtr format + return result' + +#if ENABLE_OVERLOADING +data PixbufFormatGetMimeTypesMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m) => O.MethodInfo PixbufFormatGetMimeTypesMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatGetMimeTypes + +#endif + +-- method PixbufFormat::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", 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_format_get_name" gdk_pixbuf_format_get_name :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + IO CString + +{- | +Returns the name of the format. + +/Since: 2.2/ +-} +pixbufFormatGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> m T.Text + {- ^ __Returns:__ the name of the format. -} +pixbufFormatGetName format = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + result <- gdk_pixbuf_format_get_name format' + checkUnexpectedReturnNULL "pixbufFormatGetName" result + result' <- cstringToText result + freeMem result + touchManagedPtr format + return result' + +#if ENABLE_OVERLOADING +data PixbufFormatGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo PixbufFormatGetNameMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatGetName + +#endif + +-- method PixbufFormat::is_disabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", 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_format_is_disabled" gdk_pixbuf_format_is_disabled :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + IO CInt + +{- | +Returns whether this image format is disabled. See +'GI.GdkPixbuf.Structs.PixbufFormat.pixbufFormatSetDisabled'. + +/Since: 2.6/ +-} +pixbufFormatIsDisabled :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> m Bool + {- ^ __Returns:__ whether this image format is disabled. -} +pixbufFormatIsDisabled format = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + result <- gdk_pixbuf_format_is_disabled format' + let result' = (/= 0) result + touchManagedPtr format + return result' + +#if ENABLE_OVERLOADING +data PixbufFormatIsDisabledMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo PixbufFormatIsDisabledMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatIsDisabled + +#endif + +-- method PixbufFormat::is_save_option_supported +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option_key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of an option", 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_format_is_save_option_supported" gdk_pixbuf_format_is_save_option_supported :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + CString -> -- option_key : TBasicType TUTF8 + IO CInt + +{- | +Returns 'True' if the save option specified by /@optionKey@/ is supported when +saving a pixbuf using the module implementing /@format@/. +See @/gdk_pixbuf_save()/@ for more information about option keys. + +/Since: 2.36/ +-} +pixbufFormatIsSaveOptionSupported :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> T.Text + {- ^ /@optionKey@/: the name of an option -} + -> m Bool + {- ^ __Returns:__ 'True' if the specified option is supported -} +pixbufFormatIsSaveOptionSupported format optionKey = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + optionKey' <- textToCString optionKey + result <- gdk_pixbuf_format_is_save_option_supported format' optionKey' + let result' = (/= 0) result + touchManagedPtr format + freeMem optionKey' + return result' + +#if ENABLE_OVERLOADING +data PixbufFormatIsSaveOptionSupportedMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo PixbufFormatIsSaveOptionSupportedMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatIsSaveOptionSupported + +#endif + +-- method PixbufFormat::is_scalable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", 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_format_is_scalable" gdk_pixbuf_format_is_scalable :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + IO CInt + +{- | +Returns whether this image format is scalable. If a file is in a +scalable format, it is preferable to load it at the desired size, +rather than loading it at the default size and scaling the +resulting pixbuf to the desired size. + +/Since: 2.6/ +-} +pixbufFormatIsScalable :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> m Bool + {- ^ __Returns:__ whether this image format is scalable. -} +pixbufFormatIsScalable format = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + result <- gdk_pixbuf_format_is_scalable format' + let result' = (/= 0) result + touchManagedPtr format + return result' + +#if ENABLE_OVERLOADING +data PixbufFormatIsScalableMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo PixbufFormatIsScalableMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatIsScalable + +#endif + +-- method PixbufFormat::is_writable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", 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_format_is_writable" gdk_pixbuf_format_is_writable :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + IO CInt + +{- | +Returns whether pixbufs can be saved in the given format. + +/Since: 2.2/ +-} +pixbufFormatIsWritable :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> m Bool + {- ^ __Returns:__ whether pixbufs can be saved in the given format. -} +pixbufFormatIsWritable format = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + result <- gdk_pixbuf_format_is_writable format' + let result' = (/= 0) result + touchManagedPtr format + return result' + +#if ENABLE_OVERLOADING +data PixbufFormatIsWritableMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo PixbufFormatIsWritableMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatIsWritable + +#endif + +-- method PixbufFormat::set_disabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "format", argType = TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbufFormat", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to disable the format @format", 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_format_set_disabled" gdk_pixbuf_format_set_disabled :: + Ptr PixbufFormat -> -- format : TInterface (Name {namespace = "GdkPixbuf", name = "PixbufFormat"}) + CInt -> -- disabled : TBasicType TBoolean + IO () + +{- | +Disables or enables an image format. If a format is disabled, +gdk-pixbuf won\'t use the image loader for this format to load +images. Applications can use this to avoid using image loaders +with an inappropriate license, see 'GI.GdkPixbuf.Structs.PixbufFormat.pixbufFormatGetLicense'. + +/Since: 2.6/ +-} +pixbufFormatSetDisabled :: + (B.CallStack.HasCallStack, MonadIO m) => + PixbufFormat + {- ^ /@format@/: a 'GI.GdkPixbuf.Structs.PixbufFormat.PixbufFormat' -} + -> Bool + {- ^ /@disabled@/: 'True' to disable the format /@format@/ -} + -> m () +pixbufFormatSetDisabled format disabled = liftIO $ do + format' <- unsafeManagedPtrGetPtr format + let disabled' = (fromIntegral . fromEnum) disabled + gdk_pixbuf_format_set_disabled format' disabled' + touchManagedPtr format + return () + +#if ENABLE_OVERLOADING +data PixbufFormatSetDisabledMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo PixbufFormatSetDisabledMethodInfo PixbufFormat signature where + overloadedMethod _ = pixbufFormatSetDisabled + +#endif + +#if ENABLE_OVERLOADING +type family ResolvePixbufFormatMethod (t :: Symbol) (o :: *) :: * where + ResolvePixbufFormatMethod "copy" o = PixbufFormatCopyMethodInfo + ResolvePixbufFormatMethod "free" o = PixbufFormatFreeMethodInfo + ResolvePixbufFormatMethod "isDisabled" o = PixbufFormatIsDisabledMethodInfo + ResolvePixbufFormatMethod "isSaveOptionSupported" o = PixbufFormatIsSaveOptionSupportedMethodInfo + ResolvePixbufFormatMethod "isScalable" o = PixbufFormatIsScalableMethodInfo + ResolvePixbufFormatMethod "isWritable" o = PixbufFormatIsWritableMethodInfo + ResolvePixbufFormatMethod "getDescription" o = PixbufFormatGetDescriptionMethodInfo + ResolvePixbufFormatMethod "getExtensions" o = PixbufFormatGetExtensionsMethodInfo + ResolvePixbufFormatMethod "getLicense" o = PixbufFormatGetLicenseMethodInfo + ResolvePixbufFormatMethod "getMimeTypes" o = PixbufFormatGetMimeTypesMethodInfo + ResolvePixbufFormatMethod "getName" o = PixbufFormatGetNameMethodInfo + ResolvePixbufFormatMethod "setDisabled" o = PixbufFormatSetDisabledMethodInfo + ResolvePixbufFormatMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePixbufFormatMethod t PixbufFormat, O.MethodInfo info PixbufFormat p) => OL.IsLabel t (PixbufFormat -> 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 + + diff --git a/GI/GdkPixbuf/Structs/PixbufFormat.hs-boot b/GI/GdkPixbuf/Structs/PixbufFormat.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkPixbuf/Structs/PixbufFormat.hs-boot @@ -0,0 +1,62 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkPixbuf.Structs.PixbufFormat 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 PixbufFormat = PixbufFormat (ManagedPtr PixbufFormat) +instance BoxedObject PixbufFormat where +#if ENABLE_OVERLOADING +data PixbufFormatCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data PixbufFormatFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data PixbufFormatGetDescriptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data PixbufFormatGetExtensionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data PixbufFormatGetLicenseMethodInfo +#endif +#if ENABLE_OVERLOADING +data PixbufFormatGetMimeTypesMethodInfo +#endif +#if ENABLE_OVERLOADING +data PixbufFormatGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data PixbufFormatIsDisabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data PixbufFormatIsSaveOptionSupportedMethodInfo +#endif +#if ENABLE_OVERLOADING +data PixbufFormatIsScalableMethodInfo +#endif +#if ENABLE_OVERLOADING +data PixbufFormatIsWritableMethodInfo +#endif +#if ENABLE_OVERLOADING +data PixbufFormatSetDisabledMethodInfo +#endif diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.18/docs/GI-GdkPixbuf.html](https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.18/docs/GI-GdkPixbuf.html) +[https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.19/docs/GI-GdkPixbuf.html](https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.19/docs/GI-GdkPixbuf.html) For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki). diff --git a/gi-gdkpixbuf.cabal b/gi-gdkpixbuf.cabal --- a/gi-gdkpixbuf.cabal +++ b/gi-gdkpixbuf.cabal @@ -1,5 +1,5 @@ name: gi-gdkpixbuf -version: 2.0.18 +version: 2.0.19 synopsis: GdkPixbuf bindings description: Bindings for GdkPixbuf, autogenerated by haskell-gi. homepage: https://github.com/haskell-gi/haskell-gi @@ -14,20 +14,20 @@ extra-source-files: README.md ChangeLog.md stack.yaml GdkPixbuf.overrides custom-setup - setup-depends: base >= 4.7 && < 5, + setup-depends: base >= 4.9 && < 5, Cabal >= 1.24, - haskell-gi >= 0.21.1 && < 0.22 + haskell-gi >= 0.21.0 && < 0.23 library default-language: Haskell2010 - default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts + default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses other-extensions: PatternSynonyms, ViewPatterns ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations pkgconfig-depends: gdk-pixbuf-2.0 build-depends: base >= 4.7 && <5, - haskell-gi-base == 0.21.*, - haskell-gi >= 0.21.1 && < 0.22, + haskell-gi-base >= 0.21.0 && < 0.23, + haskell-gi >= 0.21.0 && < 0.23, haskell-gi-overloading < 1.1, gi-gio == 2.0.*, gi-gobject == 2.0.*, @@ -41,3 +41,17 @@ -- see https://ghc.haskell.org/trac/ghc/ticket/14382 if impl(ghc == 8.2.*) build-depends: haskell-gi-overloading == 0.0 + + exposed-modules: GI.GdkPixbuf, + GI.GdkPixbuf.Callbacks, + GI.GdkPixbuf.Constants, + GI.GdkPixbuf.Enums, + GI.GdkPixbuf.Objects, + GI.GdkPixbuf.Objects.Pixbuf, + GI.GdkPixbuf.Objects.PixbufAnimation, + GI.GdkPixbuf.Objects.PixbufAnimationIter, + GI.GdkPixbuf.Objects.PixbufLoader, + GI.GdkPixbuf.Objects.PixbufSimpleAnim, + GI.GdkPixbuf.Objects.PixbufSimpleAnimIter, + GI.GdkPixbuf.Structs, + GI.GdkPixbuf.Structs.PixbufFormat diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-12.10 +resolver: lts-13.7