{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

Structure describing the 'GI.Gst.Structs.StaticPadTemplate.StaticPadTemplate'.
-}

module GI.Gst.Structs.StaticPadTemplate
    ( 

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


 -- * Methods
-- ** get #method:get#
    StaticPadTemplateGetMethodInfo          ,
    staticPadTemplateGet                    ,


-- ** getCaps #method:getCaps#
    StaticPadTemplateGetCapsMethodInfo      ,
    staticPadTemplateGetCaps                ,




 -- * Properties
-- ** direction #attr:direction#
    getStaticPadTemplateDirection           ,
    setStaticPadTemplateDirection           ,
    staticPadTemplate_direction             ,


-- ** nameTemplate #attr:nameTemplate#
    clearStaticPadTemplateNameTemplate      ,
    getStaticPadTemplateNameTemplate        ,
    setStaticPadTemplateNameTemplate        ,
    staticPadTemplate_nameTemplate          ,


-- ** presence #attr:presence#
    getStaticPadTemplatePresence            ,
    setStaticPadTemplatePresence            ,
    staticPadTemplate_presence              ,


-- ** staticCaps #attr:staticCaps#
    getStaticPadTemplateStaticCaps          ,
    staticPadTemplate_staticCaps            ,




    ) 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.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 {-# 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 (ManagedPtr StaticPadTemplate)
instance WrappedPtr StaticPadTemplate where
    wrappedPtrCalloc = callocBytes 64
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 64 >=> wrapPtr StaticPadTemplate)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `StaticPadTemplate` struct initialized to zero.
newZeroStaticPadTemplate :: MonadIO m => m StaticPadTemplate
newZeroStaticPadTemplate = liftIO $ wrappedPtrCalloc >>= wrapPtr StaticPadTemplate

instance tag ~ 'AttrSet => Constructible StaticPadTemplate tag where
    new _ attrs = do
        o <- newZeroStaticPadTemplate
        GI.Attributes.set o attrs
        return o


noStaticPadTemplate :: Maybe StaticPadTemplate
noStaticPadTemplate = Nothing

getStaticPadTemplateNameTemplate :: MonadIO m => StaticPadTemplate -> m (Maybe T.Text)
getStaticPadTemplateNameTemplate s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

setStaticPadTemplateNameTemplate :: MonadIO m => StaticPadTemplate -> CString -> m ()
setStaticPadTemplateNameTemplate s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CString)

clearStaticPadTemplateNameTemplate :: MonadIO m => StaticPadTemplate -> m ()
clearStaticPadTemplateNameTemplate s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: CString)

data StaticPadTemplateNameTemplateFieldInfo
instance AttrInfo StaticPadTemplateNameTemplateFieldInfo where
    type AttrAllowedOps StaticPadTemplateNameTemplateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint StaticPadTemplateNameTemplateFieldInfo = (~) CString
    type AttrBaseTypeConstraint StaticPadTemplateNameTemplateFieldInfo = (~) StaticPadTemplate
    type AttrGetType StaticPadTemplateNameTemplateFieldInfo = Maybe T.Text
    type AttrLabel StaticPadTemplateNameTemplateFieldInfo = "name_template"
    type AttrOrigin StaticPadTemplateNameTemplateFieldInfo = StaticPadTemplate
    attrGet _ = getStaticPadTemplateNameTemplate
    attrSet _ = setStaticPadTemplateNameTemplate
    attrConstruct = undefined
    attrClear _ = clearStaticPadTemplateNameTemplate

staticPadTemplate_nameTemplate :: AttrLabelProxy "nameTemplate"
staticPadTemplate_nameTemplate = AttrLabelProxy


getStaticPadTemplateDirection :: MonadIO m => StaticPadTemplate -> m Gst.Enums.PadDirection
getStaticPadTemplateDirection s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

setStaticPadTemplateDirection :: MonadIO m => StaticPadTemplate -> Gst.Enums.PadDirection -> m ()
setStaticPadTemplateDirection s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 8) (val' :: CUInt)

data StaticPadTemplateDirectionFieldInfo
instance AttrInfo StaticPadTemplateDirectionFieldInfo where
    type AttrAllowedOps StaticPadTemplateDirectionFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint StaticPadTemplateDirectionFieldInfo = (~) Gst.Enums.PadDirection
    type AttrBaseTypeConstraint StaticPadTemplateDirectionFieldInfo = (~) StaticPadTemplate
    type AttrGetType StaticPadTemplateDirectionFieldInfo = Gst.Enums.PadDirection
    type AttrLabel StaticPadTemplateDirectionFieldInfo = "direction"
    type AttrOrigin StaticPadTemplateDirectionFieldInfo = StaticPadTemplate
    attrGet _ = getStaticPadTemplateDirection
    attrSet _ = setStaticPadTemplateDirection
    attrConstruct = undefined
    attrClear _ = undefined

staticPadTemplate_direction :: AttrLabelProxy "direction"
staticPadTemplate_direction = AttrLabelProxy


getStaticPadTemplatePresence :: MonadIO m => StaticPadTemplate -> m Gst.Enums.PadPresence
getStaticPadTemplatePresence s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 12) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

setStaticPadTemplatePresence :: MonadIO m => StaticPadTemplate -> Gst.Enums.PadPresence -> m ()
setStaticPadTemplatePresence s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 12) (val' :: CUInt)

data StaticPadTemplatePresenceFieldInfo
instance AttrInfo StaticPadTemplatePresenceFieldInfo where
    type AttrAllowedOps StaticPadTemplatePresenceFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint StaticPadTemplatePresenceFieldInfo = (~) Gst.Enums.PadPresence
    type AttrBaseTypeConstraint StaticPadTemplatePresenceFieldInfo = (~) StaticPadTemplate
    type AttrGetType StaticPadTemplatePresenceFieldInfo = Gst.Enums.PadPresence
    type AttrLabel StaticPadTemplatePresenceFieldInfo = "presence"
    type AttrOrigin StaticPadTemplatePresenceFieldInfo = StaticPadTemplate
    attrGet _ = getStaticPadTemplatePresence
    attrSet _ = setStaticPadTemplatePresence
    attrConstruct = undefined
    attrClear _ = undefined

staticPadTemplate_presence :: AttrLabelProxy "presence"
staticPadTemplate_presence = AttrLabelProxy


getStaticPadTemplateStaticCaps :: MonadIO m => StaticPadTemplate -> m Gst.StaticCaps.StaticCaps
getStaticPadTemplateStaticCaps s = liftIO $ withManagedPtr s $ \ptr -> do
    let val = ptr `plusPtr` 16 :: (Ptr Gst.StaticCaps.StaticCaps)
    val' <- (newPtr Gst.StaticCaps.StaticCaps) val
    return val'

data StaticPadTemplateStaticCapsFieldInfo
instance AttrInfo StaticPadTemplateStaticCapsFieldInfo where
    type AttrAllowedOps StaticPadTemplateStaticCapsFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint StaticPadTemplateStaticCapsFieldInfo = (~) (Ptr Gst.StaticCaps.StaticCaps)
    type AttrBaseTypeConstraint StaticPadTemplateStaticCapsFieldInfo = (~) StaticPadTemplate
    type AttrGetType StaticPadTemplateStaticCapsFieldInfo = Gst.StaticCaps.StaticCaps
    type AttrLabel StaticPadTemplateStaticCapsFieldInfo = "static_caps"
    type AttrOrigin StaticPadTemplateStaticCapsFieldInfo = StaticPadTemplate
    attrGet _ = getStaticPadTemplateStaticCaps
    attrSet _ = undefined
    attrConstruct = undefined
    attrClear _ = undefined

staticPadTemplate_staticCaps :: AttrLabelProxy "staticCaps"
staticPadTemplate_staticCaps = AttrLabelProxy



instance O.HasAttributeList StaticPadTemplate
type instance O.AttributeList StaticPadTemplate = StaticPadTemplateAttributeList
type StaticPadTemplateAttributeList = ('[ '("nameTemplate", StaticPadTemplateNameTemplateFieldInfo), '("direction", StaticPadTemplateDirectionFieldInfo), '("presence", StaticPadTemplatePresenceFieldInfo), '("staticCaps", StaticPadTemplateStaticCapsFieldInfo)] :: [(Symbol, *)])

-- 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 'GI.Gst.Structs.StaticPadTemplate.StaticPadTemplate' into a 'GI.Gst.Objects.PadTemplate.PadTemplate'.
-}
staticPadTemplateGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StaticPadTemplate
    {- ^ /@padTemplate@/: the static pad template -}
    -> m Gst.PadTemplate.PadTemplate
    {- ^ __Returns:__ a new 'GI.Gst.Objects.PadTemplate.PadTemplate'. -}
staticPadTemplateGet padTemplate = liftIO $ do
    padTemplate' <- unsafeManagedPtrGetPtr padTemplate
    result <- gst_static_pad_template_get padTemplate'
    checkUnexpectedReturnNULL "staticPadTemplateGet" result
    result' <- (wrapObject Gst.PadTemplate.PadTemplate) result
    touchManagedPtr padTemplate
    return result'

data StaticPadTemplateGetMethodInfo
instance (signature ~ (m Gst.PadTemplate.PadTemplate), MonadIO m) => O.MethodInfo StaticPadTemplateGetMethodInfo StaticPadTemplate signature where
    overloadedMethod _ = staticPadTemplateGet

-- 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 'GI.Gst.Structs.StaticPadTemplate.StaticPadTemplate' to get capabilities of. -}
    -> m Gst.Caps.Caps
    {- ^ __Returns:__ the '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 templ = liftIO $ do
    templ' <- unsafeManagedPtrGetPtr templ
    result <- gst_static_pad_template_get_caps templ'
    checkUnexpectedReturnNULL "staticPadTemplateGetCaps" result
    result' <- (wrapBoxed Gst.Caps.Caps) result
    touchManagedPtr templ
    return result'

data StaticPadTemplateGetCapsMethodInfo
instance (signature ~ (m Gst.Caps.Caps), MonadIO m) => O.MethodInfo StaticPadTemplateGetCapsMethodInfo StaticPadTemplate signature where
    overloadedMethod _ = staticPadTemplateGetCaps

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) => O.IsLabelProxy t (StaticPadTemplate -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveStaticPadTemplateMethod t StaticPadTemplate, O.MethodInfo info StaticPadTemplate p) => O.IsLabel t (StaticPadTemplate -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif