{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Structs.StaticPadTemplate
(
StaticPadTemplate(..) ,
newZeroStaticPadTemplate ,
#if defined(ENABLE_OVERLOADING)
ResolveStaticPadTemplateMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
StaticPadTemplateGetMethodInfo ,
#endif
staticPadTemplateGet ,
#if defined(ENABLE_OVERLOADING)
StaticPadTemplateGetCapsMethodInfo ,
#endif
staticPadTemplateGetCaps ,
getStaticPadTemplateDirection ,
setStaticPadTemplateDirection ,
#if defined(ENABLE_OVERLOADING)
staticPadTemplate_direction ,
#endif
clearStaticPadTemplateNameTemplate ,
getStaticPadTemplateNameTemplate ,
setStaticPadTemplateNameTemplate ,
#if defined(ENABLE_OVERLOADING)
staticPadTemplate_nameTemplate ,
#endif
getStaticPadTemplatePresence ,
setStaticPadTemplatePresence ,
#if defined(ENABLE_OVERLOADING)
staticPadTemplate_presence ,
#endif
getStaticPadTemplateStaticCaps ,
#if defined(ENABLE_OVERLOADING)
staticPadTemplate_staticCaps ,
#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.BasicTypes as B.Types
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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 {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Objects.PadTemplate as Gst.PadTemplate
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.Gst.Structs.StaticCaps as Gst.StaticCaps
newtype StaticPadTemplate = StaticPadTemplate (SP.ManagedPtr StaticPadTemplate)
deriving (StaticPadTemplate -> StaticPadTemplate -> Bool
(StaticPadTemplate -> StaticPadTemplate -> Bool)
-> (StaticPadTemplate -> StaticPadTemplate -> Bool)
-> Eq StaticPadTemplate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StaticPadTemplate -> StaticPadTemplate -> Bool
$c/= :: StaticPadTemplate -> StaticPadTemplate -> Bool
== :: StaticPadTemplate -> StaticPadTemplate -> Bool
$c== :: StaticPadTemplate -> StaticPadTemplate -> Bool
Eq)
instance SP.ManagedPtrNewtype StaticPadTemplate where
toManagedPtr :: StaticPadTemplate -> ManagedPtr StaticPadTemplate
toManagedPtr (StaticPadTemplate ManagedPtr StaticPadTemplate
p) = ManagedPtr StaticPadTemplate
p
instance BoxedPtr StaticPadTemplate where
boxedPtrCopy :: StaticPadTemplate -> IO StaticPadTemplate
boxedPtrCopy = \StaticPadTemplate
p -> StaticPadTemplate
-> (Ptr StaticPadTemplate -> IO StaticPadTemplate)
-> IO StaticPadTemplate
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr StaticPadTemplate
p (Int -> Ptr StaticPadTemplate -> IO (Ptr StaticPadTemplate)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
64 (Ptr StaticPadTemplate -> IO (Ptr StaticPadTemplate))
-> (Ptr StaticPadTemplate -> IO StaticPadTemplate)
-> Ptr StaticPadTemplate
-> IO StaticPadTemplate
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr StaticPadTemplate -> StaticPadTemplate)
-> Ptr StaticPadTemplate -> IO StaticPadTemplate
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr StaticPadTemplate -> StaticPadTemplate
StaticPadTemplate)
boxedPtrFree :: StaticPadTemplate -> IO ()
boxedPtrFree = \StaticPadTemplate
x -> StaticPadTemplate -> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr StaticPadTemplate
x Ptr StaticPadTemplate -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr StaticPadTemplate where
boxedPtrCalloc :: IO (Ptr StaticPadTemplate)
boxedPtrCalloc = Int -> IO (Ptr StaticPadTemplate)
forall a. Int -> IO (Ptr a)
callocBytes Int
64
newZeroStaticPadTemplate :: MonadIO m => m StaticPadTemplate
newZeroStaticPadTemplate :: m StaticPadTemplate
newZeroStaticPadTemplate = IO StaticPadTemplate -> m StaticPadTemplate
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StaticPadTemplate -> m StaticPadTemplate)
-> IO StaticPadTemplate -> m StaticPadTemplate
forall a b. (a -> b) -> a -> b
$ IO (Ptr StaticPadTemplate)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr StaticPadTemplate)
-> (Ptr StaticPadTemplate -> IO StaticPadTemplate)
-> IO StaticPadTemplate
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr StaticPadTemplate -> StaticPadTemplate)
-> Ptr StaticPadTemplate -> IO StaticPadTemplate
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr StaticPadTemplate -> StaticPadTemplate
StaticPadTemplate
instance tag ~ 'AttrSet => Constructible StaticPadTemplate tag where
new :: (ManagedPtr StaticPadTemplate -> StaticPadTemplate)
-> [AttrOp StaticPadTemplate tag] -> m StaticPadTemplate
new ManagedPtr StaticPadTemplate -> StaticPadTemplate
_ [AttrOp StaticPadTemplate tag]
attrs = do
StaticPadTemplate
o <- m StaticPadTemplate
forall (m :: * -> *). MonadIO m => m StaticPadTemplate
newZeroStaticPadTemplate
StaticPadTemplate -> [AttrOp StaticPadTemplate 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set StaticPadTemplate
o [AttrOp StaticPadTemplate tag]
[AttrOp StaticPadTemplate 'AttrSet]
attrs
StaticPadTemplate -> m StaticPadTemplate
forall (m :: * -> *) a. Monad m => a -> m a
return StaticPadTemplate
o
getStaticPadTemplateNameTemplate :: MonadIO m => StaticPadTemplate -> m (Maybe T.Text)
getStaticPadTemplateNameTemplate :: StaticPadTemplate -> m (Maybe Text)
getStaticPadTemplateNameTemplate StaticPadTemplate
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate
-> (Ptr StaticPadTemplate -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr StaticPadTemplate -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setStaticPadTemplateNameTemplate :: MonadIO m => StaticPadTemplate -> CString -> m ()
setStaticPadTemplateNameTemplate :: StaticPadTemplate -> CString -> m ()
setStaticPadTemplateNameTemplate StaticPadTemplate
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate -> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO ()) -> IO ())
-> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
val :: CString)
clearStaticPadTemplateNameTemplate :: MonadIO m => StaticPadTemplate -> m ()
clearStaticPadTemplateNameTemplate :: StaticPadTemplate -> m ()
clearStaticPadTemplateNameTemplate StaticPadTemplate
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate -> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO ()) -> IO ())
-> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data StaticPadTemplateNameTemplateFieldInfo
instance AttrInfo StaticPadTemplateNameTemplateFieldInfo where
type AttrBaseTypeConstraint StaticPadTemplateNameTemplateFieldInfo = (~) StaticPadTemplate
type AttrAllowedOps StaticPadTemplateNameTemplateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint StaticPadTemplateNameTemplateFieldInfo = (~) CString
type AttrTransferTypeConstraint StaticPadTemplateNameTemplateFieldInfo = (~)CString
type AttrTransferType StaticPadTemplateNameTemplateFieldInfo = CString
type AttrGetType StaticPadTemplateNameTemplateFieldInfo = Maybe T.Text
type AttrLabel StaticPadTemplateNameTemplateFieldInfo = "name_template"
type AttrOrigin StaticPadTemplateNameTemplateFieldInfo = StaticPadTemplate
attrGet = getStaticPadTemplateNameTemplate
attrSet = setStaticPadTemplateNameTemplate
attrConstruct = undefined
attrClear = clearStaticPadTemplateNameTemplate
attrTransfer _ v = do
return v
staticPadTemplate_nameTemplate :: AttrLabelProxy "nameTemplate"
staticPadTemplate_nameTemplate = AttrLabelProxy
#endif
getStaticPadTemplateDirection :: MonadIO m => StaticPadTemplate -> m Gst.Enums.PadDirection
getStaticPadTemplateDirection :: StaticPadTemplate -> m PadDirection
getStaticPadTemplateDirection StaticPadTemplate
s = IO PadDirection -> m PadDirection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadDirection -> m PadDirection)
-> IO PadDirection -> m PadDirection
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate
-> (Ptr StaticPadTemplate -> IO PadDirection) -> IO PadDirection
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO PadDirection) -> IO PadDirection)
-> (Ptr StaticPadTemplate -> IO PadDirection) -> IO PadDirection
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CUInt
let val' :: PadDirection
val' = (Int -> PadDirection
forall a. Enum a => Int -> a
toEnum (Int -> PadDirection) -> (CUInt -> Int) -> CUInt -> PadDirection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
PadDirection -> IO PadDirection
forall (m :: * -> *) a. Monad m => a -> m a
return PadDirection
val'
setStaticPadTemplateDirection :: MonadIO m => StaticPadTemplate -> Gst.Enums.PadDirection -> m ()
setStaticPadTemplateDirection :: StaticPadTemplate -> PadDirection -> m ()
setStaticPadTemplateDirection StaticPadTemplate
s PadDirection
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate -> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO ()) -> IO ())
-> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PadDirection -> Int) -> PadDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PadDirection -> Int
forall a. Enum a => a -> Int
fromEnum) PadDirection
val
Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data StaticPadTemplateDirectionFieldInfo
instance AttrInfo StaticPadTemplateDirectionFieldInfo where
type AttrBaseTypeConstraint StaticPadTemplateDirectionFieldInfo = (~) StaticPadTemplate
type AttrAllowedOps StaticPadTemplateDirectionFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint StaticPadTemplateDirectionFieldInfo = (~) Gst.Enums.PadDirection
type AttrTransferTypeConstraint StaticPadTemplateDirectionFieldInfo = (~)Gst.Enums.PadDirection
type AttrTransferType StaticPadTemplateDirectionFieldInfo = Gst.Enums.PadDirection
type AttrGetType StaticPadTemplateDirectionFieldInfo = Gst.Enums.PadDirection
type AttrLabel StaticPadTemplateDirectionFieldInfo = "direction"
type AttrOrigin StaticPadTemplateDirectionFieldInfo = StaticPadTemplate
attrGet = getStaticPadTemplateDirection
attrSet = setStaticPadTemplateDirection
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
staticPadTemplate_direction :: AttrLabelProxy "direction"
staticPadTemplate_direction = AttrLabelProxy
#endif
getStaticPadTemplatePresence :: MonadIO m => StaticPadTemplate -> m Gst.Enums.PadPresence
getStaticPadTemplatePresence :: StaticPadTemplate -> m PadPresence
getStaticPadTemplatePresence StaticPadTemplate
s = IO PadPresence -> m PadPresence
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadPresence -> m PadPresence)
-> IO PadPresence -> m PadPresence
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate
-> (Ptr StaticPadTemplate -> IO PadPresence) -> IO PadPresence
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO PadPresence) -> IO PadPresence)
-> (Ptr StaticPadTemplate -> IO PadPresence) -> IO PadPresence
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO CUInt
let val' :: PadPresence
val' = (Int -> PadPresence
forall a. Enum a => Int -> a
toEnum (Int -> PadPresence) -> (CUInt -> Int) -> CUInt -> PadPresence
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
PadPresence -> IO PadPresence
forall (m :: * -> *) a. Monad m => a -> m a
return PadPresence
val'
setStaticPadTemplatePresence :: MonadIO m => StaticPadTemplate -> Gst.Enums.PadPresence -> m ()
setStaticPadTemplatePresence :: StaticPadTemplate -> PadPresence -> m ()
setStaticPadTemplatePresence StaticPadTemplate
s PadPresence
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate -> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO ()) -> IO ())
-> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PadPresence -> Int) -> PadPresence -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PadPresence -> Int
forall a. Enum a => a -> Int
fromEnum) PadPresence
val
Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data StaticPadTemplatePresenceFieldInfo
instance AttrInfo StaticPadTemplatePresenceFieldInfo where
type AttrBaseTypeConstraint StaticPadTemplatePresenceFieldInfo = (~) StaticPadTemplate
type AttrAllowedOps StaticPadTemplatePresenceFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint StaticPadTemplatePresenceFieldInfo = (~) Gst.Enums.PadPresence
type AttrTransferTypeConstraint StaticPadTemplatePresenceFieldInfo = (~)Gst.Enums.PadPresence
type AttrTransferType StaticPadTemplatePresenceFieldInfo = Gst.Enums.PadPresence
type AttrGetType StaticPadTemplatePresenceFieldInfo = Gst.Enums.PadPresence
type AttrLabel StaticPadTemplatePresenceFieldInfo = "presence"
type AttrOrigin StaticPadTemplatePresenceFieldInfo = StaticPadTemplate
attrGet = getStaticPadTemplatePresence
attrSet = setStaticPadTemplatePresence
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
staticPadTemplate_presence :: AttrLabelProxy "presence"
staticPadTemplate_presence = AttrLabelProxy
#endif
getStaticPadTemplateStaticCaps :: MonadIO m => StaticPadTemplate -> m Gst.StaticCaps.StaticCaps
getStaticPadTemplateStaticCaps :: StaticPadTemplate -> m StaticCaps
getStaticPadTemplateStaticCaps StaticPadTemplate
s = IO StaticCaps -> m StaticCaps
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StaticCaps -> m StaticCaps) -> IO StaticCaps -> m StaticCaps
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate
-> (Ptr StaticPadTemplate -> IO StaticCaps) -> IO StaticCaps
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO StaticCaps) -> IO StaticCaps)
-> (Ptr StaticPadTemplate -> IO StaticCaps) -> IO StaticCaps
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
let val :: Ptr StaticCaps
val = Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr StaticCaps
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: (Ptr Gst.StaticCaps.StaticCaps)
StaticCaps
val' <- ((ManagedPtr StaticCaps -> StaticCaps)
-> Ptr StaticCaps -> IO StaticCaps
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr StaticCaps -> StaticCaps
Gst.StaticCaps.StaticCaps) Ptr StaticCaps
val
StaticCaps -> IO StaticCaps
forall (m :: * -> *) a. Monad m => a -> m a
return StaticCaps
val'
#if defined(ENABLE_OVERLOADING)
data StaticPadTemplateStaticCapsFieldInfo
instance AttrInfo StaticPadTemplateStaticCapsFieldInfo where
type AttrBaseTypeConstraint StaticPadTemplateStaticCapsFieldInfo = (~) StaticPadTemplate
type AttrAllowedOps StaticPadTemplateStaticCapsFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint StaticPadTemplateStaticCapsFieldInfo = (~) (Ptr Gst.StaticCaps.StaticCaps)
type AttrTransferTypeConstraint StaticPadTemplateStaticCapsFieldInfo = (~)(Ptr Gst.StaticCaps.StaticCaps)
type AttrTransferType StaticPadTemplateStaticCapsFieldInfo = (Ptr Gst.StaticCaps.StaticCaps)
type AttrGetType StaticPadTemplateStaticCapsFieldInfo = Gst.StaticCaps.StaticCaps
type AttrLabel StaticPadTemplateStaticCapsFieldInfo = "static_caps"
type AttrOrigin StaticPadTemplateStaticCapsFieldInfo = StaticPadTemplate
attrGet = getStaticPadTemplateStaticCaps
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
staticPadTemplate_staticCaps :: AttrLabelProxy "staticCaps"
staticPadTemplate_staticCaps = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList StaticPadTemplate
type instance O.AttributeList StaticPadTemplate = StaticPadTemplateAttributeList
type StaticPadTemplateAttributeList = ('[ '("nameTemplate", StaticPadTemplateNameTemplateFieldInfo), '("direction", StaticPadTemplateDirectionFieldInfo), '("presence", StaticPadTemplatePresenceFieldInfo), '("staticCaps", StaticPadTemplateStaticCapsFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_static_pad_template_get" gst_static_pad_template_get ::
Ptr StaticPadTemplate ->
IO (Ptr Gst.PadTemplate.PadTemplate)
staticPadTemplateGet ::
(B.CallStack.HasCallStack, MonadIO m) =>
StaticPadTemplate
-> m (Maybe Gst.PadTemplate.PadTemplate)
staticPadTemplateGet :: StaticPadTemplate -> m (Maybe PadTemplate)
staticPadTemplateGet StaticPadTemplate
padTemplate = IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe PadTemplate) -> m (Maybe PadTemplate))
-> IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall a b. (a -> b) -> a -> b
$ do
Ptr StaticPadTemplate
padTemplate' <- StaticPadTemplate -> IO (Ptr StaticPadTemplate)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StaticPadTemplate
padTemplate
Ptr PadTemplate
result <- Ptr StaticPadTemplate -> IO (Ptr PadTemplate)
gst_static_pad_template_get Ptr StaticPadTemplate
padTemplate'
Maybe PadTemplate
maybeResult <- Ptr PadTemplate
-> (Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr PadTemplate
result ((Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate))
-> (Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate)
forall a b. (a -> b) -> a -> b
$ \Ptr PadTemplate
result' -> do
PadTemplate
result'' <- ((ManagedPtr PadTemplate -> PadTemplate)
-> Ptr PadTemplate -> IO PadTemplate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PadTemplate -> PadTemplate
Gst.PadTemplate.PadTemplate) Ptr PadTemplate
result'
PadTemplate -> IO PadTemplate
forall (m :: * -> *) a. Monad m => a -> m a
return PadTemplate
result''
StaticPadTemplate -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StaticPadTemplate
padTemplate
Maybe PadTemplate -> IO (Maybe PadTemplate)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PadTemplate
maybeResult
#if defined(ENABLE_OVERLOADING)
data StaticPadTemplateGetMethodInfo
instance (signature ~ (m (Maybe Gst.PadTemplate.PadTemplate)), MonadIO m) => O.MethodInfo StaticPadTemplateGetMethodInfo StaticPadTemplate signature where
overloadedMethod = staticPadTemplateGet
#endif
foreign import ccall "gst_static_pad_template_get_caps" gst_static_pad_template_get_caps ::
Ptr StaticPadTemplate ->
IO (Ptr Gst.Caps.Caps)
staticPadTemplateGetCaps ::
(B.CallStack.HasCallStack, MonadIO m) =>
StaticPadTemplate
-> m Gst.Caps.Caps
staticPadTemplateGetCaps :: StaticPadTemplate -> m Caps
staticPadTemplateGetCaps StaticPadTemplate
templ = IO Caps -> m Caps
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Caps -> m Caps) -> IO Caps -> m Caps
forall a b. (a -> b) -> a -> b
$ do
Ptr StaticPadTemplate
templ' <- StaticPadTemplate -> IO (Ptr StaticPadTemplate)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StaticPadTemplate
templ
Ptr Caps
result <- Ptr StaticPadTemplate -> IO (Ptr Caps)
gst_static_pad_template_get_caps Ptr StaticPadTemplate
templ'
Text -> Ptr Caps -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"staticPadTemplateGetCaps" Ptr Caps
result
Caps
result' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
StaticPadTemplate -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StaticPadTemplate
templ
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'
#if defined(ENABLE_OVERLOADING)
data StaticPadTemplateGetCapsMethodInfo
instance (signature ~ (m Gst.Caps.Caps), MonadIO m) => O.MethodInfo StaticPadTemplateGetCapsMethodInfo StaticPadTemplate signature where
overloadedMethod = staticPadTemplateGetCaps
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveStaticPadTemplateMethod (t :: Symbol) (o :: *) :: * where
ResolveStaticPadTemplateMethod "get" o = StaticPadTemplateGetMethodInfo
ResolveStaticPadTemplateMethod "getCaps" o = StaticPadTemplateGetCapsMethodInfo
ResolveStaticPadTemplateMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveStaticPadTemplateMethod t StaticPadTemplate, O.MethodInfo info StaticPadTemplate p) => OL.IsLabel t (StaticPadTemplate -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif