{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GdkPixbuf.Objects.PixbufAnimation
(
PixbufAnimation(..) ,
IsPixbufAnimation ,
toPixbufAnimation ,
#if defined(ENABLE_OVERLOADING)
ResolvePixbufAnimationMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
PixbufAnimationGetHeightMethodInfo ,
#endif
pixbufAnimationGetHeight ,
#if defined(ENABLE_OVERLOADING)
PixbufAnimationGetIterMethodInfo ,
#endif
pixbufAnimationGetIter ,
#if defined(ENABLE_OVERLOADING)
PixbufAnimationGetStaticImageMethodInfo ,
#endif
pixbufAnimationGetStaticImage ,
#if defined(ENABLE_OVERLOADING)
PixbufAnimationGetWidthMethodInfo ,
#endif
pixbufAnimationGetWidth ,
#if defined(ENABLE_OVERLOADING)
PixbufAnimationIsStaticImageMethodInfo ,
#endif
pixbufAnimationIsStaticImage ,
pixbufAnimationNewFromFile ,
pixbufAnimationNewFromResource ,
pixbufAnimationNewFromStream ,
pixbufAnimationNewFromStreamAsync ,
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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.Records as R
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
newtype PixbufAnimation = PixbufAnimation (SP.ManagedPtr PixbufAnimation)
deriving (PixbufAnimation -> PixbufAnimation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PixbufAnimation -> PixbufAnimation -> Bool
$c/= :: PixbufAnimation -> PixbufAnimation -> Bool
== :: PixbufAnimation -> PixbufAnimation -> Bool
$c== :: PixbufAnimation -> PixbufAnimation -> Bool
Eq)
instance SP.ManagedPtrNewtype PixbufAnimation where
toManagedPtr :: PixbufAnimation -> ManagedPtr PixbufAnimation
toManagedPtr (PixbufAnimation ManagedPtr PixbufAnimation
p) = ManagedPtr PixbufAnimation
p
foreign import ccall "gdk_pixbuf_animation_get_type"
c_gdk_pixbuf_animation_get_type :: IO B.Types.GType
instance B.Types.TypedObject PixbufAnimation where
glibType :: IO GType
glibType = IO GType
c_gdk_pixbuf_animation_get_type
instance B.Types.GObject PixbufAnimation
class (SP.GObject o, O.IsDescendantOf PixbufAnimation o) => IsPixbufAnimation o
instance (SP.GObject o, O.IsDescendantOf PixbufAnimation o) => IsPixbufAnimation o
instance O.HasParentTypes PixbufAnimation
type instance O.ParentTypes PixbufAnimation = '[GObject.Object.Object]
toPixbufAnimation :: (MIO.MonadIO m, IsPixbufAnimation o) => o -> m PixbufAnimation
toPixbufAnimation :: forall (m :: * -> *) o.
(MonadIO m, IsPixbufAnimation o) =>
o -> m PixbufAnimation
toPixbufAnimation = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr PixbufAnimation -> PixbufAnimation
PixbufAnimation
instance B.GValue.IsGValue (Maybe PixbufAnimation) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gdk_pixbuf_animation_get_type
gvalueSet_ :: Ptr GValue -> Maybe PixbufAnimation -> IO ()
gvalueSet_ Ptr GValue
gv Maybe PixbufAnimation
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr PixbufAnimation)
gvalueSet_ Ptr GValue
gv (P.Just PixbufAnimation
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr PixbufAnimation
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe PixbufAnimation)
gvalueGet_ Ptr GValue
gv = do
Ptr PixbufAnimation
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr PixbufAnimation)
if Ptr PixbufAnimation
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr PixbufAnimation -> PixbufAnimation
PixbufAnimation Ptr PixbufAnimation
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolvePixbufAnimationMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolvePixbufAnimationMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolvePixbufAnimationMethod t PixbufAnimation, O.OverloadedMethod info PixbufAnimation p) => OL.IsLabel t (PixbufAnimation -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolvePixbufAnimationMethod t PixbufAnimation, O.OverloadedMethod info PixbufAnimation p, R.HasField t PixbufAnimation p) => R.HasField t PixbufAnimation p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolvePixbufAnimationMethod t PixbufAnimation, O.OverloadedMethodInfo info PixbufAnimation) => OL.IsLabel t (O.MethodProxy info PixbufAnimation) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList PixbufAnimation
type instance O.AttributeList PixbufAnimation = PixbufAnimationAttributeList
type PixbufAnimationAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList PixbufAnimation = PixbufAnimationSignalList
type PixbufAnimationSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gdk_pixbuf_animation_new_from_file" gdk_pixbuf_animation_new_from_file ::
CString ->
Ptr (Ptr GError) ->
IO (Ptr PixbufAnimation)
pixbufAnimationNewFromFile ::
(B.CallStack.HasCallStack, MonadIO m) =>
[Char]
-> m (Maybe PixbufAnimation)
pixbufAnimationNewFromFile :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[Char] -> m (Maybe PixbufAnimation)
pixbufAnimationNewFromFile [Char]
filename = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
filename' <- [Char] -> IO CString
stringToCString [Char]
filename
forall a b. IO a -> IO b -> IO a
onException (do
Ptr PixbufAnimation
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr PixbufAnimation)
gdk_pixbuf_animation_new_from_file CString
filename'
Maybe PixbufAnimation
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr PixbufAnimation
result forall a b. (a -> b) -> a -> b
$ \Ptr PixbufAnimation
result' -> do
PixbufAnimation
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PixbufAnimation -> PixbufAnimation
PixbufAnimation) Ptr PixbufAnimation
result'
forall (m :: * -> *) a. Monad m => a -> m a
return PixbufAnimation
result''
forall a. Ptr a -> IO ()
freeMem CString
filename'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PixbufAnimation
maybeResult
) (do
forall a. Ptr a -> IO ()
freeMem CString
filename'
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gdk_pixbuf_animation_new_from_resource" gdk_pixbuf_animation_new_from_resource ::
CString ->
Ptr (Ptr GError) ->
IO (Ptr PixbufAnimation)
pixbufAnimationNewFromResource ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe PixbufAnimation)
pixbufAnimationNewFromResource :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe PixbufAnimation)
pixbufAnimationNewFromResource Text
resourcePath = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
CString
resourcePath' <- Text -> IO CString
textToCString Text
resourcePath
forall a b. IO a -> IO b -> IO a
onException (do
Ptr PixbufAnimation
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr PixbufAnimation)
gdk_pixbuf_animation_new_from_resource CString
resourcePath'
Maybe PixbufAnimation
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr PixbufAnimation
result forall a b. (a -> b) -> a -> b
$ \Ptr PixbufAnimation
result' -> do
PixbufAnimation
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PixbufAnimation -> PixbufAnimation
PixbufAnimation) Ptr PixbufAnimation
result'
forall (m :: * -> *) a. Monad m => a -> m a
return PixbufAnimation
result''
forall a. Ptr a -> IO ()
freeMem CString
resourcePath'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PixbufAnimation
maybeResult
) (do
forall a. Ptr a -> IO ()
freeMem CString
resourcePath'
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gdk_pixbuf_animation_new_from_stream" gdk_pixbuf_animation_new_from_stream ::
Ptr Gio.InputStream.InputStream ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO (Ptr PixbufAnimation)
pixbufAnimationNewFromStream ::
(B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m (Maybe PixbufAnimation)
pixbufAnimationNewFromStream :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a -> Maybe b -> m (Maybe PixbufAnimation)
pixbufAnimationNewFromStream a
stream Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
Ptr PixbufAnimation
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream
-> Ptr Cancellable -> Ptr (Ptr GError) -> IO (Ptr PixbufAnimation)
gdk_pixbuf_animation_new_from_stream Ptr InputStream
stream' Ptr Cancellable
maybeCancellable
Maybe PixbufAnimation
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr PixbufAnimation
result forall a b. (a -> b) -> a -> b
$ \Ptr PixbufAnimation
result' -> do
PixbufAnimation
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PixbufAnimation -> PixbufAnimation
PixbufAnimation) Ptr PixbufAnimation
result'
forall (m :: * -> *) a. Monad m => a -> m a
return PixbufAnimation
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PixbufAnimation
maybeResult
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gdk_pixbuf_animation_new_from_stream_finish" gdk_pixbuf_animation_new_from_stream_finish ::
Ptr Gio.AsyncResult.AsyncResult ->
Ptr (Ptr GError) ->
IO (Ptr PixbufAnimation)
pixbufAnimationNewFromStreamFinish ::
(B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>
a
-> m (Maybe PixbufAnimation)
pixbufAnimationNewFromStreamFinish :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncResult a) =>
a -> m (Maybe PixbufAnimation)
pixbufAnimationNewFromStreamFinish a
asyncResult = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr AsyncResult
asyncResult' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
asyncResult
forall a b. IO a -> IO b -> IO a
onException (do
Ptr PixbufAnimation
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr AsyncResult -> Ptr (Ptr GError) -> IO (Ptr PixbufAnimation)
gdk_pixbuf_animation_new_from_stream_finish Ptr AsyncResult
asyncResult'
Maybe PixbufAnimation
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr PixbufAnimation
result forall a b. (a -> b) -> a -> b
$ \Ptr PixbufAnimation
result' -> do
PixbufAnimation
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PixbufAnimation -> PixbufAnimation
PixbufAnimation) Ptr PixbufAnimation
result'
forall (m :: * -> *) a. Monad m => a -> m a
return PixbufAnimation
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
asyncResult
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PixbufAnimation
maybeResult
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gdk_pixbuf_animation_get_height" gdk_pixbuf_animation_get_height ::
Ptr PixbufAnimation ->
IO Int32
pixbufAnimationGetHeight ::
(B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimation a) =>
a
-> m Int32
pixbufAnimationGetHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPixbufAnimation a) =>
a -> m Int32
pixbufAnimationGetHeight a
animation = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr PixbufAnimation
animation' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
animation
Int32
result <- Ptr PixbufAnimation -> IO Int32
gdk_pixbuf_animation_get_height Ptr PixbufAnimation
animation'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
animation
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data PixbufAnimationGetHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsPixbufAnimation a) => O.OverloadedMethod PixbufAnimationGetHeightMethodInfo a signature where
overloadedMethod = pixbufAnimationGetHeight
instance O.OverloadedMethodInfo PixbufAnimationGetHeightMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationGetHeight",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.29/docs/GI-GdkPixbuf-Objects-PixbufAnimation.html#v:pixbufAnimationGetHeight"
})
#endif
foreign import ccall "gdk_pixbuf_animation_get_iter" gdk_pixbuf_animation_get_iter ::
Ptr PixbufAnimation ->
Ptr GLib.TimeVal.TimeVal ->
IO (Ptr GdkPixbuf.PixbufAnimationIter.PixbufAnimationIter)
pixbufAnimationGetIter ::
(B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimation a) =>
a
-> Maybe (GLib.TimeVal.TimeVal)
-> m GdkPixbuf.PixbufAnimationIter.PixbufAnimationIter
pixbufAnimationGetIter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPixbufAnimation a) =>
a -> Maybe TimeVal -> m PixbufAnimationIter
pixbufAnimationGetIter a
animation Maybe TimeVal
startTime = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr PixbufAnimation
animation' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
animation
Ptr TimeVal
maybeStartTime <- case Maybe TimeVal
startTime of
Maybe TimeVal
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just TimeVal
jStartTime -> do
Ptr TimeVal
jStartTime' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TimeVal
jStartTime
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TimeVal
jStartTime'
Ptr PixbufAnimationIter
result <- Ptr PixbufAnimation -> Ptr TimeVal -> IO (Ptr PixbufAnimationIter)
gdk_pixbuf_animation_get_iter Ptr PixbufAnimation
animation' Ptr TimeVal
maybeStartTime
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pixbufAnimationGetIter" Ptr PixbufAnimationIter
result
PixbufAnimationIter
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PixbufAnimationIter -> PixbufAnimationIter
GdkPixbuf.PixbufAnimationIter.PixbufAnimationIter) Ptr PixbufAnimationIter
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
animation
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe TimeVal
startTime forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return PixbufAnimationIter
result'
#if defined(ENABLE_OVERLOADING)
data PixbufAnimationGetIterMethodInfo
instance (signature ~ (Maybe (GLib.TimeVal.TimeVal) -> m GdkPixbuf.PixbufAnimationIter.PixbufAnimationIter), MonadIO m, IsPixbufAnimation a) => O.OverloadedMethod PixbufAnimationGetIterMethodInfo a signature where
overloadedMethod = pixbufAnimationGetIter
instance O.OverloadedMethodInfo PixbufAnimationGetIterMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationGetIter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.29/docs/GI-GdkPixbuf-Objects-PixbufAnimation.html#v:pixbufAnimationGetIter"
})
#endif
foreign import ccall "gdk_pixbuf_animation_get_static_image" gdk_pixbuf_animation_get_static_image ::
Ptr PixbufAnimation ->
IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)
pixbufAnimationGetStaticImage ::
(B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimation a) =>
a
-> m GdkPixbuf.Pixbuf.Pixbuf
pixbufAnimationGetStaticImage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPixbufAnimation a) =>
a -> m Pixbuf
pixbufAnimationGetStaticImage a
animation = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr PixbufAnimation
animation' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
animation
Ptr Pixbuf
result <- Ptr PixbufAnimation -> IO (Ptr Pixbuf)
gdk_pixbuf_animation_get_static_image Ptr PixbufAnimation
animation'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pixbufAnimationGetStaticImage" Ptr Pixbuf
result
Pixbuf
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pixbuf -> Pixbuf
GdkPixbuf.Pixbuf.Pixbuf) Ptr Pixbuf
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
animation
forall (m :: * -> *) a. Monad m => a -> m a
return Pixbuf
result'
#if defined(ENABLE_OVERLOADING)
data PixbufAnimationGetStaticImageMethodInfo
instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsPixbufAnimation a) => O.OverloadedMethod PixbufAnimationGetStaticImageMethodInfo a signature where
overloadedMethod = pixbufAnimationGetStaticImage
instance O.OverloadedMethodInfo PixbufAnimationGetStaticImageMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationGetStaticImage",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.29/docs/GI-GdkPixbuf-Objects-PixbufAnimation.html#v:pixbufAnimationGetStaticImage"
})
#endif
foreign import ccall "gdk_pixbuf_animation_get_width" gdk_pixbuf_animation_get_width ::
Ptr PixbufAnimation ->
IO Int32
pixbufAnimationGetWidth ::
(B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimation a) =>
a
-> m Int32
pixbufAnimationGetWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPixbufAnimation a) =>
a -> m Int32
pixbufAnimationGetWidth a
animation = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr PixbufAnimation
animation' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
animation
Int32
result <- Ptr PixbufAnimation -> IO Int32
gdk_pixbuf_animation_get_width Ptr PixbufAnimation
animation'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
animation
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data PixbufAnimationGetWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsPixbufAnimation a) => O.OverloadedMethod PixbufAnimationGetWidthMethodInfo a signature where
overloadedMethod = pixbufAnimationGetWidth
instance O.OverloadedMethodInfo PixbufAnimationGetWidthMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationGetWidth",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.29/docs/GI-GdkPixbuf-Objects-PixbufAnimation.html#v:pixbufAnimationGetWidth"
})
#endif
foreign import ccall "gdk_pixbuf_animation_is_static_image" gdk_pixbuf_animation_is_static_image ::
Ptr PixbufAnimation ->
IO CInt
pixbufAnimationIsStaticImage ::
(B.CallStack.HasCallStack, MonadIO m, IsPixbufAnimation a) =>
a
-> m Bool
pixbufAnimationIsStaticImage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPixbufAnimation a) =>
a -> m Bool
pixbufAnimationIsStaticImage a
animation = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr PixbufAnimation
animation' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
animation
CInt
result <- Ptr PixbufAnimation -> IO CInt
gdk_pixbuf_animation_is_static_image Ptr PixbufAnimation
animation'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
animation
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PixbufAnimationIsStaticImageMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPixbufAnimation a) => O.OverloadedMethod PixbufAnimationIsStaticImageMethodInfo a signature where
overloadedMethod = pixbufAnimationIsStaticImage
instance O.OverloadedMethodInfo PixbufAnimationIsStaticImageMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GdkPixbuf.Objects.PixbufAnimation.pixbufAnimationIsStaticImage",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdkpixbuf-2.0.29/docs/GI-GdkPixbuf-Objects-PixbufAnimation.html#v:pixbufAnimationIsStaticImage"
})
#endif
foreign import ccall "gdk_pixbuf_animation_new_from_stream_async" gdk_pixbuf_animation_new_from_stream_async ::
Ptr Gio.InputStream.InputStream ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
pixbufAnimationNewFromStreamAsync ::
(B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
pixbufAnimationNewFromStreamAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a -> Maybe b -> Maybe AsyncReadyCallback -> m ()
pixbufAnimationNewFromStreamAsync a
stream Maybe b
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
Ptr InputStream
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
gdk_pixbuf_animation_new_from_stream_async Ptr InputStream
stream' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif