{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Structure describing the t'GI.Gst.Structs.StaticPadTemplate.StaticPadTemplate'.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gst.Structs.StaticPadTemplate
    ( 

-- * Exported types
    StaticPadTemplate(..)                   ,
    newZeroStaticPadTemplate                ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveStaticPadTemplateMethod          ,
#endif


-- ** get #method:get#

#if defined(ENABLE_OVERLOADING)
    StaticPadTemplateGetMethodInfo          ,
#endif
    staticPadTemplateGet                    ,


-- ** getCaps #method:getCaps#

#if defined(ENABLE_OVERLOADING)
    StaticPadTemplateGetCapsMethodInfo      ,
#endif
    staticPadTemplateGetCaps                ,




 -- * Properties
-- ** direction #attr:direction#
-- | the direction of the template

    getStaticPadTemplateDirection           ,
    setStaticPadTemplateDirection           ,
#if defined(ENABLE_OVERLOADING)
    staticPadTemplate_direction             ,
#endif


-- ** nameTemplate #attr:nameTemplate#
-- | the name of the template

    clearStaticPadTemplateNameTemplate      ,
    getStaticPadTemplateNameTemplate        ,
    setStaticPadTemplateNameTemplate        ,
#if defined(ENABLE_OVERLOADING)
    staticPadTemplate_nameTemplate          ,
#endif


-- ** presence #attr:presence#
-- | the presence of the template

    getStaticPadTemplatePresence            ,
    setStaticPadTemplatePresence            ,
#if defined(ENABLE_OVERLOADING)
    staticPadTemplate_presence              ,
#endif


-- ** staticCaps #attr:staticCaps#
-- | the caps of the template.

    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

-- | Memory-managed wrapper type.
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


-- | Construct a `StaticPadTemplate` struct initialized to zero.
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


-- | Get the value of the “@name_template@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' staticPadTemplate #nameTemplate
-- @
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

-- | Set the value of the “@name_template@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' staticPadTemplate [ #nameTemplate 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Set the value of the “@name_template@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #nameTemplate
-- @
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


-- | Get the value of the “@direction@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' staticPadTemplate #direction
-- @
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'

-- | Set the value of the “@direction@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' staticPadTemplate [ #direction 'Data.GI.Base.Attributes.:=' value ]
-- @
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


-- | Get the value of the “@presence@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' staticPadTemplate #presence
-- @
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'

-- | Set the value of the “@presence@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' staticPadTemplate [ #presence 'Data.GI.Base.Attributes.:=' value ]
-- @
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


-- | Get the value of the “@static_caps@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' staticPadTemplate #staticCaps
-- @
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

-- method StaticPadTemplate::get
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pad_template"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "StaticPadTemplate" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the static pad template"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "PadTemplate" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_static_pad_template_get" gst_static_pad_template_get :: 
    Ptr StaticPadTemplate ->                -- pad_template : TInterface (Name {namespace = "Gst", name = "StaticPadTemplate"})
    IO (Ptr Gst.PadTemplate.PadTemplate)

-- | Converts a t'GI.Gst.Structs.StaticPadTemplate.StaticPadTemplate' into a t'GI.Gst.Objects.PadTemplate.PadTemplate'.
staticPadTemplateGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StaticPadTemplate
    -- ^ /@padTemplate@/: the static pad template
    -> m (Maybe Gst.PadTemplate.PadTemplate)
    -- ^ __Returns:__ a new t'GI.Gst.Objects.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

-- method StaticPadTemplate::get_caps
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "templ"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "StaticPadTemplate" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GstStaticPadTemplate to get capabilities of."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Caps" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_static_pad_template_get_caps" gst_static_pad_template_get_caps :: 
    Ptr StaticPadTemplate ->                -- templ : TInterface (Name {namespace = "Gst", name = "StaticPadTemplate"})
    IO (Ptr Gst.Caps.Caps)

-- | Gets the capabilities of the static pad template.
staticPadTemplateGetCaps ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StaticPadTemplate
    -- ^ /@templ@/: a t'GI.Gst.Structs.StaticPadTemplate.StaticPadTemplate' to get capabilities of.
    -> m Gst.Caps.Caps
    -- ^ __Returns:__ the t'GI.Gst.Structs.Caps.Caps' of the static pad template.
    -- Unref after usage. Since the core holds an additional
    -- ref to the returned caps, use @/gst_caps_make_writable()/@
    -- on the returned caps to modify it.
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