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

Supported frame rates: 30000\/1001, 60000\/1001 (both with and without drop
frame), and integer frame rates e.g. 25\/1, 30\/1, 50\/1, 60\/1.

The configuration of the time code.
-}

module GI.GstVideo.Structs.VideoTimeCodeConfig
    ( 

-- * Exported types
    VideoTimeCodeConfig(..)                 ,
    newZeroVideoTimeCodeConfig              ,
    noVideoTimeCodeConfig                   ,


 -- * Properties
-- ** flags #attr:flags#
    getVideoTimeCodeConfigFlags             ,
    setVideoTimeCodeConfigFlags             ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoTimeCodeConfig_flags               ,
#endif


-- ** fpsD #attr:fpsD#
    getVideoTimeCodeConfigFpsD              ,
    setVideoTimeCodeConfigFpsD              ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoTimeCodeConfig_fpsD                ,
#endif


-- ** fpsN #attr:fpsN#
    getVideoTimeCodeConfigFpsN              ,
    setVideoTimeCodeConfigFpsN              ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoTimeCodeConfig_fpsN                ,
#endif


-- ** latestDailyJam #attr:latestDailyJam#
    clearVideoTimeCodeConfigLatestDailyJam  ,
    getVideoTimeCodeConfigLatestDailyJam    ,
    setVideoTimeCodeConfigLatestDailyJam    ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoTimeCodeConfig_latestDailyJam      ,
#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.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.GLib.Structs.DateTime as GLib.DateTime
import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags

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

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

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


noVideoTimeCodeConfig :: Maybe VideoTimeCodeConfig
noVideoTimeCodeConfig = Nothing

getVideoTimeCodeConfigFpsN :: MonadIO m => VideoTimeCodeConfig -> m Word32
getVideoTimeCodeConfigFpsN s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

setVideoTimeCodeConfigFpsN :: MonadIO m => VideoTimeCodeConfig -> Word32 -> m ()
setVideoTimeCodeConfigFpsN s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeConfigFpsNFieldInfo
instance AttrInfo VideoTimeCodeConfigFpsNFieldInfo where
    type AttrAllowedOps VideoTimeCodeConfigFpsNFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeConfigFpsNFieldInfo = (~) Word32
    type AttrBaseTypeConstraint VideoTimeCodeConfigFpsNFieldInfo = (~) VideoTimeCodeConfig
    type AttrGetType VideoTimeCodeConfigFpsNFieldInfo = Word32
    type AttrLabel VideoTimeCodeConfigFpsNFieldInfo = "fps_n"
    type AttrOrigin VideoTimeCodeConfigFpsNFieldInfo = VideoTimeCodeConfig
    attrGet _ = getVideoTimeCodeConfigFpsN
    attrSet _ = setVideoTimeCodeConfigFpsN
    attrConstruct = undefined
    attrClear _ = undefined

videoTimeCodeConfig_fpsN :: AttrLabelProxy "fpsN"
videoTimeCodeConfig_fpsN = AttrLabelProxy

#endif


getVideoTimeCodeConfigFpsD :: MonadIO m => VideoTimeCodeConfig -> m Word32
getVideoTimeCodeConfigFpsD s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 4) :: IO Word32
    return val

setVideoTimeCodeConfigFpsD :: MonadIO m => VideoTimeCodeConfig -> Word32 -> m ()
setVideoTimeCodeConfigFpsD s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 4) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeConfigFpsDFieldInfo
instance AttrInfo VideoTimeCodeConfigFpsDFieldInfo where
    type AttrAllowedOps VideoTimeCodeConfigFpsDFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeConfigFpsDFieldInfo = (~) Word32
    type AttrBaseTypeConstraint VideoTimeCodeConfigFpsDFieldInfo = (~) VideoTimeCodeConfig
    type AttrGetType VideoTimeCodeConfigFpsDFieldInfo = Word32
    type AttrLabel VideoTimeCodeConfigFpsDFieldInfo = "fps_d"
    type AttrOrigin VideoTimeCodeConfigFpsDFieldInfo = VideoTimeCodeConfig
    attrGet _ = getVideoTimeCodeConfigFpsD
    attrSet _ = setVideoTimeCodeConfigFpsD
    attrConstruct = undefined
    attrClear _ = undefined

videoTimeCodeConfig_fpsD :: AttrLabelProxy "fpsD"
videoTimeCodeConfig_fpsD = AttrLabelProxy

#endif


getVideoTimeCodeConfigFlags :: MonadIO m => VideoTimeCodeConfig -> m [GstVideo.Flags.VideoTimeCodeFlags]
getVideoTimeCodeConfigFlags s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO CUInt
    let val' = wordToGFlags val
    return val'

setVideoTimeCodeConfigFlags :: MonadIO m => VideoTimeCodeConfig -> [GstVideo.Flags.VideoTimeCodeFlags] -> m ()
setVideoTimeCodeConfigFlags s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = gflagsToWord val
    poke (ptr `plusPtr` 8) (val' :: CUInt)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeConfigFlagsFieldInfo
instance AttrInfo VideoTimeCodeConfigFlagsFieldInfo where
    type AttrAllowedOps VideoTimeCodeConfigFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeConfigFlagsFieldInfo = (~) [GstVideo.Flags.VideoTimeCodeFlags]
    type AttrBaseTypeConstraint VideoTimeCodeConfigFlagsFieldInfo = (~) VideoTimeCodeConfig
    type AttrGetType VideoTimeCodeConfigFlagsFieldInfo = [GstVideo.Flags.VideoTimeCodeFlags]
    type AttrLabel VideoTimeCodeConfigFlagsFieldInfo = "flags"
    type AttrOrigin VideoTimeCodeConfigFlagsFieldInfo = VideoTimeCodeConfig
    attrGet _ = getVideoTimeCodeConfigFlags
    attrSet _ = setVideoTimeCodeConfigFlags
    attrConstruct = undefined
    attrClear _ = undefined

videoTimeCodeConfig_flags :: AttrLabelProxy "flags"
videoTimeCodeConfig_flags = AttrLabelProxy

#endif


getVideoTimeCodeConfigLatestDailyJam :: MonadIO m => VideoTimeCodeConfig -> m (Maybe GLib.DateTime.DateTime)
getVideoTimeCodeConfigLatestDailyJam s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO (Ptr GLib.DateTime.DateTime)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newBoxed GLib.DateTime.DateTime) val'
        return val''
    return result

setVideoTimeCodeConfigLatestDailyJam :: MonadIO m => VideoTimeCodeConfig -> Ptr GLib.DateTime.DateTime -> m ()
setVideoTimeCodeConfigLatestDailyJam s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Ptr GLib.DateTime.DateTime)

clearVideoTimeCodeConfigLatestDailyJam :: MonadIO m => VideoTimeCodeConfig -> m ()
clearVideoTimeCodeConfigLatestDailyJam s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr GLib.DateTime.DateTime)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeConfigLatestDailyJamFieldInfo
instance AttrInfo VideoTimeCodeConfigLatestDailyJamFieldInfo where
    type AttrAllowedOps VideoTimeCodeConfigLatestDailyJamFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint VideoTimeCodeConfigLatestDailyJamFieldInfo = (~) (Ptr GLib.DateTime.DateTime)
    type AttrBaseTypeConstraint VideoTimeCodeConfigLatestDailyJamFieldInfo = (~) VideoTimeCodeConfig
    type AttrGetType VideoTimeCodeConfigLatestDailyJamFieldInfo = Maybe GLib.DateTime.DateTime
    type AttrLabel VideoTimeCodeConfigLatestDailyJamFieldInfo = "latest_daily_jam"
    type AttrOrigin VideoTimeCodeConfigLatestDailyJamFieldInfo = VideoTimeCodeConfig
    attrGet _ = getVideoTimeCodeConfigLatestDailyJam
    attrSet _ = setVideoTimeCodeConfigLatestDailyJam
    attrConstruct = undefined
    attrClear _ = clearVideoTimeCodeConfigLatestDailyJam

videoTimeCodeConfig_latestDailyJam :: AttrLabelProxy "latestDailyJam"
videoTimeCodeConfig_latestDailyJam = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList VideoTimeCodeConfig
type instance O.AttributeList VideoTimeCodeConfig = VideoTimeCodeConfigAttributeList
type VideoTimeCodeConfigAttributeList = ('[ '("fpsN", VideoTimeCodeConfigFpsNFieldInfo), '("fpsD", VideoTimeCodeConfigFpsDFieldInfo), '("flags", VideoTimeCodeConfigFlagsFieldInfo), '("latestDailyJam", VideoTimeCodeConfigLatestDailyJamFieldInfo)] :: [(Symbol, *)])
#endif

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

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

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