{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Interfaces.Seekable
(
Seekable(..) ,
IsSeekable ,
toSeekable ,
#if defined(ENABLE_OVERLOADING)
ResolveSeekableMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
SeekableCanSeekMethodInfo ,
#endif
seekableCanSeek ,
#if defined(ENABLE_OVERLOADING)
SeekableCanTruncateMethodInfo ,
#endif
seekableCanTruncate ,
#if defined(ENABLE_OVERLOADING)
SeekableSeekMethodInfo ,
#endif
seekableSeek ,
#if defined(ENABLE_OVERLOADING)
SeekableTellMethodInfo ,
#endif
seekableTell ,
#if defined(ENABLE_OVERLOADING)
SeekableTruncateMethodInfo ,
#endif
seekableTruncate ,
) 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.Kind as DK
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.Enums as GLib.Enums
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
newtype Seekable = Seekable (SP.ManagedPtr Seekable)
deriving (Seekable -> Seekable -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Seekable -> Seekable -> Bool
$c/= :: Seekable -> Seekable -> Bool
== :: Seekable -> Seekable -> Bool
$c== :: Seekable -> Seekable -> Bool
Eq)
instance SP.ManagedPtrNewtype Seekable where
toManagedPtr :: Seekable -> ManagedPtr Seekable
toManagedPtr (Seekable ManagedPtr Seekable
p) = ManagedPtr Seekable
p
foreign import ccall "g_seekable_get_type"
c_g_seekable_get_type :: IO B.Types.GType
instance B.Types.TypedObject Seekable where
glibType :: IO GType
glibType = IO GType
c_g_seekable_get_type
instance B.Types.GObject Seekable
class (SP.GObject o, O.IsDescendantOf Seekable o) => IsSeekable o
instance (SP.GObject o, O.IsDescendantOf Seekable o) => IsSeekable o
instance O.HasParentTypes Seekable
type instance O.ParentTypes Seekable = '[GObject.Object.Object]
toSeekable :: (MIO.MonadIO m, IsSeekable o) => o -> m Seekable
toSeekable :: forall (m :: * -> *) o.
(MonadIO m, IsSeekable o) =>
o -> m Seekable
toSeekable = 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 Seekable -> Seekable
Seekable
instance B.GValue.IsGValue (Maybe Seekable) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_seekable_get_type
gvalueSet_ :: Ptr GValue -> Maybe Seekable -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Seekable
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 Seekable)
gvalueSet_ Ptr GValue
gv (P.Just Seekable
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Seekable
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Seekable)
gvalueGet_ Ptr GValue
gv = do
Ptr Seekable
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Seekable)
if Ptr Seekable
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 Seekable -> Seekable
Seekable Ptr Seekable
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Seekable
type instance O.AttributeList Seekable = SeekableAttributeList
type SeekableAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveSeekableMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveSeekableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveSeekableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveSeekableMethod "canSeek" o = SeekableCanSeekMethodInfo
ResolveSeekableMethod "canTruncate" o = SeekableCanTruncateMethodInfo
ResolveSeekableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveSeekableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveSeekableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveSeekableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveSeekableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveSeekableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveSeekableMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveSeekableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveSeekableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveSeekableMethod "seek" o = SeekableSeekMethodInfo
ResolveSeekableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveSeekableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveSeekableMethod "tell" o = SeekableTellMethodInfo
ResolveSeekableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveSeekableMethod "truncate" o = SeekableTruncateMethodInfo
ResolveSeekableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveSeekableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveSeekableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveSeekableMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveSeekableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveSeekableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveSeekableMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveSeekableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveSeekableMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveSeekableMethod t Seekable, O.OverloadedMethod info Seekable p) => OL.IsLabel t (Seekable -> 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 ~ ResolveSeekableMethod t Seekable, O.OverloadedMethod info Seekable p, R.HasField t Seekable p) => R.HasField t Seekable p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveSeekableMethod t Seekable, O.OverloadedMethodInfo info Seekable) => OL.IsLabel t (O.MethodProxy info Seekable) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "g_seekable_can_seek" g_seekable_can_seek ::
Ptr Seekable ->
IO CInt
seekableCanSeek ::
(B.CallStack.HasCallStack, MonadIO m, IsSeekable a) =>
a
-> m Bool
seekableCanSeek :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSeekable a) =>
a -> m Bool
seekableCanSeek a
seekable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Seekable
seekable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seekable
CInt
result <- Ptr Seekable -> IO CInt
g_seekable_can_seek Ptr Seekable
seekable'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
seekable
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data SeekableCanSeekMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSeekable a) => O.OverloadedMethod SeekableCanSeekMethodInfo a signature where
overloadedMethod = seekableCanSeek
instance O.OverloadedMethodInfo SeekableCanSeekMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Seekable.seekableCanSeek",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Seekable.html#v:seekableCanSeek"
})
#endif
foreign import ccall "g_seekable_can_truncate" g_seekable_can_truncate ::
Ptr Seekable ->
IO CInt
seekableCanTruncate ::
(B.CallStack.HasCallStack, MonadIO m, IsSeekable a) =>
a
-> m Bool
seekableCanTruncate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSeekable a) =>
a -> m Bool
seekableCanTruncate a
seekable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Seekable
seekable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seekable
CInt
result <- Ptr Seekable -> IO CInt
g_seekable_can_truncate Ptr Seekable
seekable'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
seekable
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data SeekableCanTruncateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSeekable a) => O.OverloadedMethod SeekableCanTruncateMethodInfo a signature where
overloadedMethod = seekableCanTruncate
instance O.OverloadedMethodInfo SeekableCanTruncateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Seekable.seekableCanTruncate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Seekable.html#v:seekableCanTruncate"
})
#endif
foreign import ccall "g_seekable_seek" g_seekable_seek ::
Ptr Seekable ->
Int64 ->
CUInt ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
seekableSeek ::
(B.CallStack.HasCallStack, MonadIO m, IsSeekable a, Gio.Cancellable.IsCancellable b) =>
a
-> Int64
-> GLib.Enums.SeekType
-> Maybe (b)
-> m ()
seekableSeek :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSeekable a, IsCancellable b) =>
a -> Int64 -> SeekType -> Maybe b -> m ()
seekableSeek a
seekable Int64
offset SeekType
type_ Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Seekable
seekable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seekable
let type_' :: CUInt
type_' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) SeekType
type_
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
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Seekable
-> Int64 -> CUInt -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
g_seekable_seek Ptr Seekable
seekable' Int64
offset CUInt
type_' Ptr Cancellable
maybeCancellable
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
seekable
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 ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data SeekableSeekMethodInfo
instance (signature ~ (Int64 -> GLib.Enums.SeekType -> Maybe (b) -> m ()), MonadIO m, IsSeekable a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod SeekableSeekMethodInfo a signature where
overloadedMethod = seekableSeek
instance O.OverloadedMethodInfo SeekableSeekMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Seekable.seekableSeek",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Seekable.html#v:seekableSeek"
})
#endif
foreign import ccall "g_seekable_tell" g_seekable_tell ::
Ptr Seekable ->
IO Int64
seekableTell ::
(B.CallStack.HasCallStack, MonadIO m, IsSeekable a) =>
a
-> m Int64
seekableTell :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSeekable a) =>
a -> m Int64
seekableTell a
seekable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Seekable
seekable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seekable
Int64
result <- Ptr Seekable -> IO Int64
g_seekable_tell Ptr Seekable
seekable'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
seekable
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
#if defined(ENABLE_OVERLOADING)
data SeekableTellMethodInfo
instance (signature ~ (m Int64), MonadIO m, IsSeekable a) => O.OverloadedMethod SeekableTellMethodInfo a signature where
overloadedMethod = seekableTell
instance O.OverloadedMethodInfo SeekableTellMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Seekable.seekableTell",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Seekable.html#v:seekableTell"
})
#endif
foreign import ccall "g_seekable_truncate" g_seekable_truncate ::
Ptr Seekable ->
Int64 ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
seekableTruncate ::
(B.CallStack.HasCallStack, MonadIO m, IsSeekable a, Gio.Cancellable.IsCancellable b) =>
a
-> Int64
-> Maybe (b)
-> m ()
seekableTruncate :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSeekable a, IsCancellable b) =>
a -> Int64 -> Maybe b -> m ()
seekableTruncate a
seekable Int64
offset Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Seekable
seekable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seekable
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
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Seekable
-> Int64 -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
g_seekable_truncate Ptr Seekable
seekable' Int64
offset Ptr Cancellable
maybeCancellable
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
seekable
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 ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data SeekableTruncateMethodInfo
instance (signature ~ (Int64 -> Maybe (b) -> m ()), MonadIO m, IsSeekable a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod SeekableTruncateMethodInfo a signature where
overloadedMethod = seekableTruncate
instance O.OverloadedMethodInfo SeekableTruncateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Seekable.seekableTruncate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Seekable.html#v:seekableTruncate"
})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Seekable = SeekableSignalList
type SeekableSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif