#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Gst.Structs.MiniObject
(
MiniObject(..) ,
newZeroMiniObject ,
noMiniObject ,
#if ENABLE_OVERLOADING
MiniObjectGetQdataMethodInfo ,
#endif
miniObjectGetQdata ,
#if ENABLE_OVERLOADING
MiniObjectIsWritableMethodInfo ,
#endif
miniObjectIsWritable ,
#if ENABLE_OVERLOADING
MiniObjectLockMethodInfo ,
#endif
miniObjectLock ,
#if ENABLE_OVERLOADING
MiniObjectSetQdataMethodInfo ,
#endif
miniObjectSetQdata ,
#if ENABLE_OVERLOADING
MiniObjectStealQdataMethodInfo ,
#endif
miniObjectStealQdata ,
#if ENABLE_OVERLOADING
MiniObjectUnlockMethodInfo ,
#endif
miniObjectUnlock ,
clearMiniObjectDispose ,
getMiniObjectDispose ,
#if ENABLE_OVERLOADING
miniObject_dispose ,
#endif
setMiniObjectDispose ,
getMiniObjectFlags ,
#if ENABLE_OVERLOADING
miniObject_flags ,
#endif
setMiniObjectFlags ,
clearMiniObjectFree ,
getMiniObjectFree ,
#if ENABLE_OVERLOADING
miniObject_free ,
#endif
setMiniObjectFree ,
getMiniObjectLockstate ,
#if ENABLE_OVERLOADING
miniObject_lockstate ,
#endif
setMiniObjectLockstate ,
getMiniObjectRefcount ,
#if ENABLE_OVERLOADING
miniObject_refcount ,
#endif
setMiniObjectRefcount ,
getMiniObjectType ,
#if ENABLE_OVERLOADING
miniObject_type ,
#endif
setMiniObjectType ,
) 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.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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
newtype MiniObject = MiniObject (ManagedPtr MiniObject)
instance WrappedPtr MiniObject where
wrappedPtrCalloc = callocBytes 64
wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 64 >=> wrapPtr MiniObject)
wrappedPtrFree = Just ptr_to_g_free
newZeroMiniObject :: MonadIO m => m MiniObject
newZeroMiniObject = liftIO $ wrappedPtrCalloc >>= wrapPtr MiniObject
instance tag ~ 'AttrSet => Constructible MiniObject tag where
new _ attrs = do
o <- newZeroMiniObject
GI.Attributes.set o attrs
return o
noMiniObject :: Maybe MiniObject
noMiniObject = Nothing
getMiniObjectType :: MonadIO m => MiniObject -> m GType
getMiniObjectType s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 0) :: IO CGType
let val' = GType val
return val'
setMiniObjectType :: MonadIO m => MiniObject -> GType -> m ()
setMiniObjectType s val = liftIO $ withManagedPtr s $ \ptr -> do
let val' = gtypeToCGType val
poke (ptr `plusPtr` 0) (val' :: CGType)
#if ENABLE_OVERLOADING
data MiniObjectTypeFieldInfo
instance AttrInfo MiniObjectTypeFieldInfo where
type AttrAllowedOps MiniObjectTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MiniObjectTypeFieldInfo = (~) GType
type AttrBaseTypeConstraint MiniObjectTypeFieldInfo = (~) MiniObject
type AttrGetType MiniObjectTypeFieldInfo = GType
type AttrLabel MiniObjectTypeFieldInfo = "type"
type AttrOrigin MiniObjectTypeFieldInfo = MiniObject
attrGet _ = getMiniObjectType
attrSet _ = setMiniObjectType
attrConstruct = undefined
attrClear _ = undefined
miniObject_type :: AttrLabelProxy "type"
miniObject_type = AttrLabelProxy
#endif
getMiniObjectRefcount :: MonadIO m => MiniObject -> m Int32
getMiniObjectRefcount s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 8) :: IO Int32
return val
setMiniObjectRefcount :: MonadIO m => MiniObject -> Int32 -> m ()
setMiniObjectRefcount s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 8) (val :: Int32)
#if ENABLE_OVERLOADING
data MiniObjectRefcountFieldInfo
instance AttrInfo MiniObjectRefcountFieldInfo where
type AttrAllowedOps MiniObjectRefcountFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MiniObjectRefcountFieldInfo = (~) Int32
type AttrBaseTypeConstraint MiniObjectRefcountFieldInfo = (~) MiniObject
type AttrGetType MiniObjectRefcountFieldInfo = Int32
type AttrLabel MiniObjectRefcountFieldInfo = "refcount"
type AttrOrigin MiniObjectRefcountFieldInfo = MiniObject
attrGet _ = getMiniObjectRefcount
attrSet _ = setMiniObjectRefcount
attrConstruct = undefined
attrClear _ = undefined
miniObject_refcount :: AttrLabelProxy "refcount"
miniObject_refcount = AttrLabelProxy
#endif
getMiniObjectLockstate :: MonadIO m => MiniObject -> m Int32
getMiniObjectLockstate s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 12) :: IO Int32
return val
setMiniObjectLockstate :: MonadIO m => MiniObject -> Int32 -> m ()
setMiniObjectLockstate s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 12) (val :: Int32)
#if ENABLE_OVERLOADING
data MiniObjectLockstateFieldInfo
instance AttrInfo MiniObjectLockstateFieldInfo where
type AttrAllowedOps MiniObjectLockstateFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MiniObjectLockstateFieldInfo = (~) Int32
type AttrBaseTypeConstraint MiniObjectLockstateFieldInfo = (~) MiniObject
type AttrGetType MiniObjectLockstateFieldInfo = Int32
type AttrLabel MiniObjectLockstateFieldInfo = "lockstate"
type AttrOrigin MiniObjectLockstateFieldInfo = MiniObject
attrGet _ = getMiniObjectLockstate
attrSet _ = setMiniObjectLockstate
attrConstruct = undefined
attrClear _ = undefined
miniObject_lockstate :: AttrLabelProxy "lockstate"
miniObject_lockstate = AttrLabelProxy
#endif
getMiniObjectFlags :: MonadIO m => MiniObject -> m Word32
getMiniObjectFlags s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 16) :: IO Word32
return val
setMiniObjectFlags :: MonadIO m => MiniObject -> Word32 -> m ()
setMiniObjectFlags s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 16) (val :: Word32)
#if ENABLE_OVERLOADING
data MiniObjectFlagsFieldInfo
instance AttrInfo MiniObjectFlagsFieldInfo where
type AttrAllowedOps MiniObjectFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MiniObjectFlagsFieldInfo = (~) Word32
type AttrBaseTypeConstraint MiniObjectFlagsFieldInfo = (~) MiniObject
type AttrGetType MiniObjectFlagsFieldInfo = Word32
type AttrLabel MiniObjectFlagsFieldInfo = "flags"
type AttrOrigin MiniObjectFlagsFieldInfo = MiniObject
attrGet _ = getMiniObjectFlags
attrSet _ = setMiniObjectFlags
attrConstruct = undefined
attrClear _ = undefined
miniObject_flags :: AttrLabelProxy "flags"
miniObject_flags = AttrLabelProxy
#endif
getMiniObjectDispose :: MonadIO m => MiniObject -> m (Maybe Gst.Callbacks.MiniObjectDisposeFunction)
getMiniObjectDispose s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 32) :: IO (FunPtr Gst.Callbacks.C_MiniObjectDisposeFunction)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gst.Callbacks.dynamic_MiniObjectDisposeFunction val'
return val''
return result
setMiniObjectDispose :: MonadIO m => MiniObject -> FunPtr Gst.Callbacks.C_MiniObjectDisposeFunction -> m ()
setMiniObjectDispose s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 32) (val :: FunPtr Gst.Callbacks.C_MiniObjectDisposeFunction)
clearMiniObjectDispose :: MonadIO m => MiniObject -> m ()
clearMiniObjectDispose s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 32) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_MiniObjectDisposeFunction)
#if ENABLE_OVERLOADING
data MiniObjectDisposeFieldInfo
instance AttrInfo MiniObjectDisposeFieldInfo where
type AttrAllowedOps MiniObjectDisposeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MiniObjectDisposeFieldInfo = (~) (FunPtr Gst.Callbacks.C_MiniObjectDisposeFunction)
type AttrBaseTypeConstraint MiniObjectDisposeFieldInfo = (~) MiniObject
type AttrGetType MiniObjectDisposeFieldInfo = Maybe Gst.Callbacks.MiniObjectDisposeFunction
type AttrLabel MiniObjectDisposeFieldInfo = "dispose"
type AttrOrigin MiniObjectDisposeFieldInfo = MiniObject
attrGet _ = getMiniObjectDispose
attrSet _ = setMiniObjectDispose
attrConstruct = undefined
attrClear _ = clearMiniObjectDispose
miniObject_dispose :: AttrLabelProxy "dispose"
miniObject_dispose = AttrLabelProxy
#endif
getMiniObjectFree :: MonadIO m => MiniObject -> m (Maybe Gst.Callbacks.MiniObjectFreeFunction)
getMiniObjectFree s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 40) :: IO (FunPtr Gst.Callbacks.C_MiniObjectFreeFunction)
result <- SP.convertFunPtrIfNonNull val $ \val' -> do
let val'' = Gst.Callbacks.dynamic_MiniObjectFreeFunction val'
return val''
return result
setMiniObjectFree :: MonadIO m => MiniObject -> FunPtr Gst.Callbacks.C_MiniObjectFreeFunction -> m ()
setMiniObjectFree s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 40) (val :: FunPtr Gst.Callbacks.C_MiniObjectFreeFunction)
clearMiniObjectFree :: MonadIO m => MiniObject -> m ()
clearMiniObjectFree s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 40) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_MiniObjectFreeFunction)
#if ENABLE_OVERLOADING
data MiniObjectFreeFieldInfo
instance AttrInfo MiniObjectFreeFieldInfo where
type AttrAllowedOps MiniObjectFreeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MiniObjectFreeFieldInfo = (~) (FunPtr Gst.Callbacks.C_MiniObjectFreeFunction)
type AttrBaseTypeConstraint MiniObjectFreeFieldInfo = (~) MiniObject
type AttrGetType MiniObjectFreeFieldInfo = Maybe Gst.Callbacks.MiniObjectFreeFunction
type AttrLabel MiniObjectFreeFieldInfo = "free"
type AttrOrigin MiniObjectFreeFieldInfo = MiniObject
attrGet _ = getMiniObjectFree
attrSet _ = setMiniObjectFree
attrConstruct = undefined
attrClear _ = clearMiniObjectFree
miniObject_free :: AttrLabelProxy "free"
miniObject_free = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList MiniObject
type instance O.AttributeList MiniObject = MiniObjectAttributeList
type MiniObjectAttributeList = ('[ '("type", MiniObjectTypeFieldInfo), '("refcount", MiniObjectRefcountFieldInfo), '("lockstate", MiniObjectLockstateFieldInfo), '("flags", MiniObjectFlagsFieldInfo), '("dispose", MiniObjectDisposeFieldInfo), '("free", MiniObjectFreeFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_mini_object_get_qdata" gst_mini_object_get_qdata ::
Ptr MiniObject ->
Word32 ->
IO (Ptr ())
miniObjectGetQdata ::
(B.CallStack.HasCallStack, MonadIO m) =>
MiniObject
-> Word32
-> m (Ptr ())
miniObjectGetQdata object quark = liftIO $ do
object' <- unsafeManagedPtrGetPtr object
result <- gst_mini_object_get_qdata object' quark
touchManagedPtr object
return result
#if ENABLE_OVERLOADING
data MiniObjectGetQdataMethodInfo
instance (signature ~ (Word32 -> m (Ptr ())), MonadIO m) => O.MethodInfo MiniObjectGetQdataMethodInfo MiniObject signature where
overloadedMethod _ = miniObjectGetQdata
#endif
foreign import ccall "gst_mini_object_is_writable" gst_mini_object_is_writable ::
Ptr MiniObject ->
IO CInt
miniObjectIsWritable ::
(B.CallStack.HasCallStack, MonadIO m) =>
MiniObject
-> m Bool
miniObjectIsWritable miniObject = liftIO $ do
miniObject' <- unsafeManagedPtrGetPtr miniObject
result <- gst_mini_object_is_writable miniObject'
let result' = (/= 0) result
touchManagedPtr miniObject
return result'
#if ENABLE_OVERLOADING
data MiniObjectIsWritableMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo MiniObjectIsWritableMethodInfo MiniObject signature where
overloadedMethod _ = miniObjectIsWritable
#endif
foreign import ccall "gst_mini_object_lock" gst_mini_object_lock ::
Ptr MiniObject ->
CUInt ->
IO CInt
miniObjectLock ::
(B.CallStack.HasCallStack, MonadIO m) =>
MiniObject
-> [Gst.Flags.LockFlags]
-> m Bool
miniObjectLock object flags = liftIO $ do
object' <- unsafeManagedPtrGetPtr object
let flags' = gflagsToWord flags
result <- gst_mini_object_lock object' flags'
let result' = (/= 0) result
touchManagedPtr object
return result'
#if ENABLE_OVERLOADING
data MiniObjectLockMethodInfo
instance (signature ~ ([Gst.Flags.LockFlags] -> m Bool), MonadIO m) => O.MethodInfo MiniObjectLockMethodInfo MiniObject signature where
overloadedMethod _ = miniObjectLock
#endif
foreign import ccall "gst_mini_object_set_qdata" gst_mini_object_set_qdata ::
Ptr MiniObject ->
Word32 ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
miniObjectSetQdata ::
(B.CallStack.HasCallStack, MonadIO m) =>
MiniObject
-> Word32
-> Ptr ()
-> GLib.Callbacks.DestroyNotify
-> m ()
miniObjectSetQdata object quark data_ destroy = liftIO $ do
object' <- unsafeManagedPtrGetPtr object
ptrdestroy <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
destroy' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrdestroy) destroy)
poke ptrdestroy destroy'
gst_mini_object_set_qdata object' quark data_ destroy'
touchManagedPtr object
return ()
#if ENABLE_OVERLOADING
data MiniObjectSetQdataMethodInfo
instance (signature ~ (Word32 -> Ptr () -> GLib.Callbacks.DestroyNotify -> m ()), MonadIO m) => O.MethodInfo MiniObjectSetQdataMethodInfo MiniObject signature where
overloadedMethod _ = miniObjectSetQdata
#endif
foreign import ccall "gst_mini_object_steal_qdata" gst_mini_object_steal_qdata ::
Ptr MiniObject ->
Word32 ->
IO (Ptr ())
miniObjectStealQdata ::
(B.CallStack.HasCallStack, MonadIO m) =>
MiniObject
-> Word32
-> m (Ptr ())
miniObjectStealQdata object quark = liftIO $ do
object' <- unsafeManagedPtrGetPtr object
result <- gst_mini_object_steal_qdata object' quark
touchManagedPtr object
return result
#if ENABLE_OVERLOADING
data MiniObjectStealQdataMethodInfo
instance (signature ~ (Word32 -> m (Ptr ())), MonadIO m) => O.MethodInfo MiniObjectStealQdataMethodInfo MiniObject signature where
overloadedMethod _ = miniObjectStealQdata
#endif
foreign import ccall "gst_mini_object_unlock" gst_mini_object_unlock ::
Ptr MiniObject ->
CUInt ->
IO ()
miniObjectUnlock ::
(B.CallStack.HasCallStack, MonadIO m) =>
MiniObject
-> [Gst.Flags.LockFlags]
-> m ()
miniObjectUnlock object flags = liftIO $ do
object' <- unsafeManagedPtrGetPtr object
let flags' = gflagsToWord flags
gst_mini_object_unlock object' flags'
touchManagedPtr object
return ()
#if ENABLE_OVERLOADING
data MiniObjectUnlockMethodInfo
instance (signature ~ ([Gst.Flags.LockFlags] -> m ()), MonadIO m) => O.MethodInfo MiniObjectUnlockMethodInfo MiniObject signature where
overloadedMethod _ = miniObjectUnlock
#endif
#if ENABLE_OVERLOADING
type family ResolveMiniObjectMethod (t :: Symbol) (o :: *) :: * where
ResolveMiniObjectMethod "isWritable" o = MiniObjectIsWritableMethodInfo
ResolveMiniObjectMethod "lock" o = MiniObjectLockMethodInfo
ResolveMiniObjectMethod "stealQdata" o = MiniObjectStealQdataMethodInfo
ResolveMiniObjectMethod "unlock" o = MiniObjectUnlockMethodInfo
ResolveMiniObjectMethod "getQdata" o = MiniObjectGetQdataMethodInfo
ResolveMiniObjectMethod "setQdata" o = MiniObjectSetQdataMethodInfo
ResolveMiniObjectMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMiniObjectMethod t MiniObject, O.MethodInfo info MiniObject p) => O.IsLabelProxy t (MiniObject -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveMiniObjectMethod t MiniObject, O.MethodInfo info MiniObject p) => O.IsLabel t (MiniObject -> 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
#endif