{- |
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 used by the collect_pads.
-}

module GI.GstBase.Structs.CollectData
    ( 

-- * Exported types
    CollectData(..)                         ,
    newZeroCollectData                      ,
    noCollectData                           ,


 -- * Properties
-- ** buffer #attr:buffer#
    clearCollectDataBuffer                  ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    collectData_buffer                      ,
#endif
    getCollectDataBuffer                    ,
    setCollectDataBuffer                    ,


-- ** collect #attr:collect#
    clearCollectDataCollect                 ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    collectData_collect                     ,
#endif
    getCollectDataCollect                   ,
    setCollectDataCollect                   ,


-- ** pad #attr:pad#
    clearCollectDataPad                     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    collectData_pad                         ,
#endif
    getCollectDataPad                       ,
    setCollectDataPad                       ,


-- ** pos #attr:pos#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    collectData_pos                         ,
#endif
    getCollectDataPos                       ,
    setCollectDataPos                       ,


-- ** segment #attr:segment#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    collectData_segment                     ,
#endif
    getCollectDataSegment                   ,




    ) 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 qualified GI.Gst.Objects.Pad as Gst.Pad
import qualified GI.Gst.Structs.Buffer as Gst.Buffer
import qualified GI.Gst.Structs.Segment as Gst.Segment
import {-# SOURCE #-} qualified GI.GstBase.Objects.CollectPads as GstBase.CollectPads

newtype CollectData = CollectData (ManagedPtr CollectData)
instance WrappedPtr CollectData where
    wrappedPtrCalloc = callocBytes 168
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 168 >=> wrapPtr CollectData)
    wrappedPtrFree = Just ptr_to_g_free

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

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


noCollectData :: Maybe CollectData
noCollectData = Nothing

getCollectDataCollect :: MonadIO m => CollectData -> m (Maybe GstBase.CollectPads.CollectPads)
getCollectDataCollect s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr GstBase.CollectPads.CollectPads)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newObject GstBase.CollectPads.CollectPads) val'
        return val''
    return result

setCollectDataCollect :: MonadIO m => CollectData -> Ptr GstBase.CollectPads.CollectPads -> m ()
setCollectDataCollect s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Ptr GstBase.CollectPads.CollectPads)

clearCollectDataCollect :: MonadIO m => CollectData -> m ()
clearCollectDataCollect s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr GstBase.CollectPads.CollectPads)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CollectDataCollectFieldInfo
instance AttrInfo CollectDataCollectFieldInfo where
    type AttrAllowedOps CollectDataCollectFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CollectDataCollectFieldInfo = (~) (Ptr GstBase.CollectPads.CollectPads)
    type AttrBaseTypeConstraint CollectDataCollectFieldInfo = (~) CollectData
    type AttrGetType CollectDataCollectFieldInfo = Maybe GstBase.CollectPads.CollectPads
    type AttrLabel CollectDataCollectFieldInfo = "collect"
    type AttrOrigin CollectDataCollectFieldInfo = CollectData
    attrGet _ = getCollectDataCollect
    attrSet _ = setCollectDataCollect
    attrConstruct = undefined
    attrClear _ = clearCollectDataCollect

collectData_collect :: AttrLabelProxy "collect"
collectData_collect = AttrLabelProxy

#endif


getCollectDataPad :: MonadIO m => CollectData -> m (Maybe Gst.Pad.Pad)
getCollectDataPad s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gst.Pad.Pad)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newObject Gst.Pad.Pad) val'
        return val''
    return result

setCollectDataPad :: MonadIO m => CollectData -> Ptr Gst.Pad.Pad -> m ()
setCollectDataPad s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Ptr Gst.Pad.Pad)

clearCollectDataPad :: MonadIO m => CollectData -> m ()
clearCollectDataPad s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gst.Pad.Pad)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CollectDataPadFieldInfo
instance AttrInfo CollectDataPadFieldInfo where
    type AttrAllowedOps CollectDataPadFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CollectDataPadFieldInfo = (~) (Ptr Gst.Pad.Pad)
    type AttrBaseTypeConstraint CollectDataPadFieldInfo = (~) CollectData
    type AttrGetType CollectDataPadFieldInfo = Maybe Gst.Pad.Pad
    type AttrLabel CollectDataPadFieldInfo = "pad"
    type AttrOrigin CollectDataPadFieldInfo = CollectData
    attrGet _ = getCollectDataPad
    attrSet _ = setCollectDataPad
    attrConstruct = undefined
    attrClear _ = clearCollectDataPad

collectData_pad :: AttrLabelProxy "pad"
collectData_pad = AttrLabelProxy

#endif


getCollectDataBuffer :: MonadIO m => CollectData -> m (Maybe Gst.Buffer.Buffer)
getCollectDataBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO (Ptr Gst.Buffer.Buffer)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newBoxed Gst.Buffer.Buffer) val'
        return val''
    return result

setCollectDataBuffer :: MonadIO m => CollectData -> Ptr Gst.Buffer.Buffer -> m ()
setCollectDataBuffer s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Ptr Gst.Buffer.Buffer)

clearCollectDataBuffer :: MonadIO m => CollectData -> m ()
clearCollectDataBuffer s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr Gst.Buffer.Buffer)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CollectDataBufferFieldInfo
instance AttrInfo CollectDataBufferFieldInfo where
    type AttrAllowedOps CollectDataBufferFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CollectDataBufferFieldInfo = (~) (Ptr Gst.Buffer.Buffer)
    type AttrBaseTypeConstraint CollectDataBufferFieldInfo = (~) CollectData
    type AttrGetType CollectDataBufferFieldInfo = Maybe Gst.Buffer.Buffer
    type AttrLabel CollectDataBufferFieldInfo = "buffer"
    type AttrOrigin CollectDataBufferFieldInfo = CollectData
    attrGet _ = getCollectDataBuffer
    attrSet _ = setCollectDataBuffer
    attrConstruct = undefined
    attrClear _ = clearCollectDataBuffer

collectData_buffer :: AttrLabelProxy "buffer"
collectData_buffer = AttrLabelProxy

#endif


getCollectDataPos :: MonadIO m => CollectData -> m Word32
getCollectDataPos s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word32
    return val

setCollectDataPos :: MonadIO m => CollectData -> Word32 -> m ()
setCollectDataPos s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CollectDataPosFieldInfo
instance AttrInfo CollectDataPosFieldInfo where
    type AttrAllowedOps CollectDataPosFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint CollectDataPosFieldInfo = (~) Word32
    type AttrBaseTypeConstraint CollectDataPosFieldInfo = (~) CollectData
    type AttrGetType CollectDataPosFieldInfo = Word32
    type AttrLabel CollectDataPosFieldInfo = "pos"
    type AttrOrigin CollectDataPosFieldInfo = CollectData
    attrGet _ = getCollectDataPos
    attrSet _ = setCollectDataPos
    attrConstruct = undefined
    attrClear _ = undefined

collectData_pos :: AttrLabelProxy "pos"
collectData_pos = AttrLabelProxy

#endif


getCollectDataSegment :: MonadIO m => CollectData -> m Gst.Segment.Segment
getCollectDataSegment s = liftIO $ withManagedPtr s $ \ptr -> do
    let val = ptr `plusPtr` 32 :: (Ptr Gst.Segment.Segment)
    val' <- (newBoxed Gst.Segment.Segment) val
    return val'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data CollectDataSegmentFieldInfo
instance AttrInfo CollectDataSegmentFieldInfo where
    type AttrAllowedOps CollectDataSegmentFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint CollectDataSegmentFieldInfo = (~) (Ptr Gst.Segment.Segment)
    type AttrBaseTypeConstraint CollectDataSegmentFieldInfo = (~) CollectData
    type AttrGetType CollectDataSegmentFieldInfo = Gst.Segment.Segment
    type AttrLabel CollectDataSegmentFieldInfo = "segment"
    type AttrOrigin CollectDataSegmentFieldInfo = CollectData
    attrGet _ = getCollectDataSegment
    attrSet _ = undefined
    attrConstruct = undefined
    attrClear _ = undefined

collectData_segment :: AttrLabelProxy "segment"
collectData_segment = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList CollectData
type instance O.AttributeList CollectData = CollectDataAttributeList
type CollectDataAttributeList = ('[ '("collect", CollectDataCollectFieldInfo), '("pad", CollectDataPadFieldInfo), '("buffer", CollectDataBufferFieldInfo), '("pos", CollectDataPosFieldInfo), '("segment", CollectDataSegmentFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveCollectDataMethod (t :: Symbol) (o :: *) :: * where
    ResolveCollectDataMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCollectDataMethod t CollectData, O.MethodInfo info CollectData p) => O.IsLabelProxy t (CollectData -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveCollectDataMethod t CollectData, O.MethodInfo info CollectData p) => O.IsLabel t (CollectData -> 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