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

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.

/Since: 1.10/
-}

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

module GI.GstVideo.Structs.VideoTimeCodeConfig
    (

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


 -- * Properties
-- ** flags #attr:flags#
{- | the corresponding 'GI.GstVideo.Flags.VideoTimeCodeFlags'
-}
    getVideoTimeCodeConfigFlags             ,
    setVideoTimeCodeConfigFlags             ,
#if ENABLE_OVERLOADING
    videoTimeCodeConfig_flags               ,
#endif


-- ** fpsD #attr:fpsD#
{- | Denominator of the frame rate
-}
    getVideoTimeCodeConfigFpsD              ,
    setVideoTimeCodeConfigFpsD              ,
#if ENABLE_OVERLOADING
    videoTimeCodeConfig_fpsD                ,
#endif


-- ** fpsN #attr:fpsN#
{- | Numerator of the frame rate
-}
    getVideoTimeCodeConfigFpsN              ,
    setVideoTimeCodeConfigFpsN              ,
#if ENABLE_OVERLOADING
    videoTimeCodeConfig_fpsN                ,
#endif


-- ** latestDailyJam #attr:latestDailyJam#
{- | The latest daily jam information, if present, or NULL
-}
    clearVideoTimeCodeConfigLatestDailyJam  ,
    getVideoTimeCodeConfigLatestDailyJam    ,
    setVideoTimeCodeConfigLatestDailyJam    ,
#if ENABLE_OVERLOADING
    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.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.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 qualified GI.GLib.Structs.DateTime as GLib.DateTime
import {-# SOURCE #-} qualified GI.GstVideo.Flags as GstVideo.Flags

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


-- | A convenience alias for `Nothing` :: `Maybe` `VideoTimeCodeConfig`.
noVideoTimeCodeConfig :: Maybe VideoTimeCodeConfig
noVideoTimeCodeConfig = Nothing

{- |
Get the value of the “@fps_n@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' videoTimeCodeConfig #fpsN
@
-}
getVideoTimeCodeConfigFpsN :: MonadIO m => VideoTimeCodeConfig -> m Word32
getVideoTimeCodeConfigFpsN s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

{- |
Set the value of the “@fps_n@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' videoTimeCodeConfig [ #fpsN 'Data.GI.Base.Attributes.:=' value ]
@
-}
setVideoTimeCodeConfigFpsN :: MonadIO m => VideoTimeCodeConfig -> Word32 -> m ()
setVideoTimeCodeConfigFpsN s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word32)

#if ENABLE_OVERLOADING
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


{- |
Get the value of the “@fps_d@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' videoTimeCodeConfig #fpsD
@
-}
getVideoTimeCodeConfigFpsD :: MonadIO m => VideoTimeCodeConfig -> m Word32
getVideoTimeCodeConfigFpsD s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 4) :: IO Word32
    return val

{- |
Set the value of the “@fps_d@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' videoTimeCodeConfig [ #fpsD 'Data.GI.Base.Attributes.:=' value ]
@
-}
setVideoTimeCodeConfigFpsD :: MonadIO m => VideoTimeCodeConfig -> Word32 -> m ()
setVideoTimeCodeConfigFpsD s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 4) (val :: Word32)

#if ENABLE_OVERLOADING
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


{- |
Get the value of the “@flags@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' videoTimeCodeConfig #flags
@
-}
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'

{- |
Set the value of the “@flags@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' videoTimeCodeConfig [ #flags 'Data.GI.Base.Attributes.:=' value ]
@
-}
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 ENABLE_OVERLOADING
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


{- |
Get the value of the “@latest_daily_jam@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' videoTimeCodeConfig #latestDailyJam
@
-}
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

{- |
Set the value of the “@latest_daily_jam@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' videoTimeCodeConfig [ #latestDailyJam 'Data.GI.Base.Attributes.:=' value ]
@
-}
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)

{- |
Set the value of the “@latest_daily_jam@” 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' #latestDailyJam
@
-}
clearVideoTimeCodeConfigLatestDailyJam :: MonadIO m => VideoTimeCodeConfig -> m ()
clearVideoTimeCodeConfigLatestDailyJam s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr GLib.DateTime.DateTime)

#if ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
instance O.HasAttributeList VideoTimeCodeConfig
type instance O.AttributeList VideoTimeCodeConfig = VideoTimeCodeConfigAttributeList
type VideoTimeCodeConfigAttributeList = ('[ '("fpsN", VideoTimeCodeConfigFpsNFieldInfo), '("fpsD", VideoTimeCodeConfigFpsDFieldInfo), '("flags", VideoTimeCodeConfigFlagsFieldInfo), '("latestDailyJam", VideoTimeCodeConfigLatestDailyJamFieldInfo)] :: [(Symbol, *)])
#endif

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

instance (info ~ ResolveVideoTimeCodeConfigMethod t VideoTimeCodeConfig, O.MethodInfo info VideoTimeCodeConfig p) => OL.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