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

A representation of a difference between two 'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' instances.
Will not necessarily correspond to a real timecode (e.g. 00:00:10;00)
-}

module GI.GstVideo.Structs.VideoTimeCodeInterval
    ( 

-- * Exported types
    VideoTimeCodeInterval(..)               ,
    newZeroVideoTimeCodeInterval            ,
    noVideoTimeCodeInterval                 ,


 -- * Methods
-- ** clear #method:clear#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    VideoTimeCodeIntervalClearMethodInfo    ,
#endif
    videoTimeCodeIntervalClear              ,


-- ** copy #method:copy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    VideoTimeCodeIntervalCopyMethodInfo     ,
#endif
    videoTimeCodeIntervalCopy               ,


-- ** free #method:free#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    VideoTimeCodeIntervalFreeMethodInfo     ,
#endif
    videoTimeCodeIntervalFree               ,


-- ** init #method:init#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    VideoTimeCodeIntervalInitMethodInfo     ,
#endif
    videoTimeCodeIntervalInit               ,


-- ** new #method:new#
    videoTimeCodeIntervalNew                ,


-- ** newFromString #method:newFromString#
    videoTimeCodeIntervalNewFromString      ,




 -- * Properties
-- ** frames #attr:frames#
    getVideoTimeCodeIntervalFrames          ,
    setVideoTimeCodeIntervalFrames          ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoTimeCodeInterval_frames            ,
#endif


-- ** hours #attr:hours#
    getVideoTimeCodeIntervalHours           ,
    setVideoTimeCodeIntervalHours           ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoTimeCodeInterval_hours             ,
#endif


-- ** minutes #attr:minutes#
    getVideoTimeCodeIntervalMinutes         ,
    setVideoTimeCodeIntervalMinutes         ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoTimeCodeInterval_minutes           ,
#endif


-- ** seconds #attr:seconds#
    getVideoTimeCodeIntervalSeconds         ,
    setVideoTimeCodeIntervalSeconds         ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    videoTimeCodeInterval_seconds           ,
#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


newtype VideoTimeCodeInterval = VideoTimeCodeInterval (ManagedPtr VideoTimeCodeInterval)
foreign import ccall "gst_video_time_code_interval_get_type" c_gst_video_time_code_interval_get_type :: 
    IO GType

instance BoxedObject VideoTimeCodeInterval where
    boxedType _ = c_gst_video_time_code_interval_get_type

-- | Construct a `VideoTimeCodeInterval` struct initialized to zero.
newZeroVideoTimeCodeInterval :: MonadIO m => m VideoTimeCodeInterval
newZeroVideoTimeCodeInterval = liftIO $ callocBoxedBytes 16 >>= wrapBoxed VideoTimeCodeInterval

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


noVideoTimeCodeInterval :: Maybe VideoTimeCodeInterval
noVideoTimeCodeInterval = Nothing

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

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeIntervalHoursFieldInfo
instance AttrInfo VideoTimeCodeIntervalHoursFieldInfo where
    type AttrAllowedOps VideoTimeCodeIntervalHoursFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeIntervalHoursFieldInfo = (~) Word32
    type AttrBaseTypeConstraint VideoTimeCodeIntervalHoursFieldInfo = (~) VideoTimeCodeInterval
    type AttrGetType VideoTimeCodeIntervalHoursFieldInfo = Word32
    type AttrLabel VideoTimeCodeIntervalHoursFieldInfo = "hours"
    type AttrOrigin VideoTimeCodeIntervalHoursFieldInfo = VideoTimeCodeInterval
    attrGet _ = getVideoTimeCodeIntervalHours
    attrSet _ = setVideoTimeCodeIntervalHours
    attrConstruct = undefined
    attrClear _ = undefined

videoTimeCodeInterval_hours :: AttrLabelProxy "hours"
videoTimeCodeInterval_hours = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeIntervalMinutesFieldInfo
instance AttrInfo VideoTimeCodeIntervalMinutesFieldInfo where
    type AttrAllowedOps VideoTimeCodeIntervalMinutesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeIntervalMinutesFieldInfo = (~) Word32
    type AttrBaseTypeConstraint VideoTimeCodeIntervalMinutesFieldInfo = (~) VideoTimeCodeInterval
    type AttrGetType VideoTimeCodeIntervalMinutesFieldInfo = Word32
    type AttrLabel VideoTimeCodeIntervalMinutesFieldInfo = "minutes"
    type AttrOrigin VideoTimeCodeIntervalMinutesFieldInfo = VideoTimeCodeInterval
    attrGet _ = getVideoTimeCodeIntervalMinutes
    attrSet _ = setVideoTimeCodeIntervalMinutes
    attrConstruct = undefined
    attrClear _ = undefined

videoTimeCodeInterval_minutes :: AttrLabelProxy "minutes"
videoTimeCodeInterval_minutes = AttrLabelProxy

#endif


getVideoTimeCodeIntervalSeconds :: MonadIO m => VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalSeconds s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Word32
    return val

setVideoTimeCodeIntervalSeconds :: MonadIO m => VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalSeconds s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeIntervalSecondsFieldInfo
instance AttrInfo VideoTimeCodeIntervalSecondsFieldInfo where
    type AttrAllowedOps VideoTimeCodeIntervalSecondsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeIntervalSecondsFieldInfo = (~) Word32
    type AttrBaseTypeConstraint VideoTimeCodeIntervalSecondsFieldInfo = (~) VideoTimeCodeInterval
    type AttrGetType VideoTimeCodeIntervalSecondsFieldInfo = Word32
    type AttrLabel VideoTimeCodeIntervalSecondsFieldInfo = "seconds"
    type AttrOrigin VideoTimeCodeIntervalSecondsFieldInfo = VideoTimeCodeInterval
    attrGet _ = getVideoTimeCodeIntervalSeconds
    attrSet _ = setVideoTimeCodeIntervalSeconds
    attrConstruct = undefined
    attrClear _ = undefined

videoTimeCodeInterval_seconds :: AttrLabelProxy "seconds"
videoTimeCodeInterval_seconds = AttrLabelProxy

#endif


getVideoTimeCodeIntervalFrames :: MonadIO m => VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalFrames s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 12) :: IO Word32
    return val

setVideoTimeCodeIntervalFrames :: MonadIO m => VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalFrames s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 12) (val :: Word32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeIntervalFramesFieldInfo
instance AttrInfo VideoTimeCodeIntervalFramesFieldInfo where
    type AttrAllowedOps VideoTimeCodeIntervalFramesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeIntervalFramesFieldInfo = (~) Word32
    type AttrBaseTypeConstraint VideoTimeCodeIntervalFramesFieldInfo = (~) VideoTimeCodeInterval
    type AttrGetType VideoTimeCodeIntervalFramesFieldInfo = Word32
    type AttrLabel VideoTimeCodeIntervalFramesFieldInfo = "frames"
    type AttrOrigin VideoTimeCodeIntervalFramesFieldInfo = VideoTimeCodeInterval
    attrGet _ = getVideoTimeCodeIntervalFrames
    attrSet _ = setVideoTimeCodeIntervalFrames
    attrConstruct = undefined
    attrClear _ = undefined

videoTimeCodeInterval_frames :: AttrLabelProxy "frames"
videoTimeCodeInterval_frames = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList VideoTimeCodeInterval
type instance O.AttributeList VideoTimeCodeInterval = VideoTimeCodeIntervalAttributeList
type VideoTimeCodeIntervalAttributeList = ('[ '("hours", VideoTimeCodeIntervalHoursFieldInfo), '("minutes", VideoTimeCodeIntervalMinutesFieldInfo), '("seconds", VideoTimeCodeIntervalSecondsFieldInfo), '("frames", VideoTimeCodeIntervalFramesFieldInfo)] :: [(Symbol, *)])
#endif

-- method VideoTimeCodeInterval::new
-- method type : Constructor
-- Args : [Arg {argCName = "hours", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hours field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minutes", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minutes field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the seconds field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frames", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the frames field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_interval_new" gst_video_time_code_interval_new :: 
    Word32 ->                               -- hours : TBasicType TUInt
    Word32 ->                               -- minutes : TBasicType TUInt
    Word32 ->                               -- seconds : TBasicType TUInt
    Word32 ->                               -- frames : TBasicType TUInt
    IO (Ptr VideoTimeCodeInterval)

{- |
/No description available in the introspection data./

@since 1.12
-}
videoTimeCodeIntervalNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Word32
    {- ^ /@hours@/: the hours field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> Word32
    {- ^ /@minutes@/: the minutes field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> Word32
    {- ^ /@seconds@/: the seconds field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> Word32
    {- ^ /@frames@/: the frames field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> m VideoTimeCodeInterval
    {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' with the given values. -}
videoTimeCodeIntervalNew hours minutes seconds frames = liftIO $ do
    result <- gst_video_time_code_interval_new hours minutes seconds frames
    checkUnexpectedReturnNULL "videoTimeCodeIntervalNew" result
    result' <- (wrapBoxed VideoTimeCodeInterval) result
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

-- method VideoTimeCodeInterval::new_from_string
-- method type : Constructor
-- Args : [Arg {argCName = "tc_inter_str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The string that represents the #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_interval_new_from_string" gst_video_time_code_interval_new_from_string :: 
    CString ->                              -- tc_inter_str : TBasicType TUTF8
    IO (Ptr VideoTimeCodeInterval)

{- |
/@tcInterStr@/ must only have \":\" as separators.

@since 1.12
-}
videoTimeCodeIntervalNewFromString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@tcInterStr@/: The string that represents the 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> m VideoTimeCodeInterval
    {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' from the given string -}
videoTimeCodeIntervalNewFromString tcInterStr = liftIO $ do
    tcInterStr' <- textToCString tcInterStr
    result <- gst_video_time_code_interval_new_from_string tcInterStr'
    checkUnexpectedReturnNULL "videoTimeCodeIntervalNewFromString" result
    result' <- (wrapBoxed VideoTimeCodeInterval) result
    freeMem tcInterStr'
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

-- method VideoTimeCodeInterval::clear
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_interval_clear" gst_video_time_code_interval_clear :: 
    Ptr VideoTimeCodeInterval ->            -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"})
    IO ()

{- |
Initializes /@tc@/ with empty\/zero\/NULL values.

@since 1.12
-}
videoTimeCodeIntervalClear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoTimeCodeInterval
    {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> m ()
videoTimeCodeIntervalClear tc = liftIO $ do
    tc' <- unsafeManagedPtrGetPtr tc
    gst_video_time_code_interval_clear tc'
    touchManagedPtr tc
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeIntervalClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoTimeCodeIntervalClearMethodInfo VideoTimeCodeInterval signature where
    overloadedMethod _ = videoTimeCodeIntervalClear

#endif

-- method VideoTimeCodeInterval::copy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_interval_copy" gst_video_time_code_interval_copy :: 
    Ptr VideoTimeCodeInterval ->            -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"})
    IO (Ptr VideoTimeCodeInterval)

{- |
/No description available in the introspection data./

@since 1.12
-}
videoTimeCodeIntervalCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoTimeCodeInterval
    {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> m VideoTimeCodeInterval
    {- ^ __Returns:__ a new 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' with the same values as /@tc@/ . -}
videoTimeCodeIntervalCopy tc = liftIO $ do
    tc' <- unsafeManagedPtrGetPtr tc
    result <- gst_video_time_code_interval_copy tc'
    checkUnexpectedReturnNULL "videoTimeCodeIntervalCopy" result
    result' <- (wrapBoxed VideoTimeCodeInterval) result
    touchManagedPtr tc
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeIntervalCopyMethodInfo
instance (signature ~ (m VideoTimeCodeInterval), MonadIO m) => O.MethodInfo VideoTimeCodeIntervalCopyMethodInfo VideoTimeCodeInterval signature where
    overloadedMethod _ = videoTimeCodeIntervalCopy

#endif

-- method VideoTimeCodeInterval::free
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_interval_free" gst_video_time_code_interval_free :: 
    Ptr VideoTimeCodeInterval ->            -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"})
    IO ()

{- |
Frees /@tc@/ .

@since 1.12
-}
videoTimeCodeIntervalFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoTimeCodeInterval
    {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> m ()
videoTimeCodeIntervalFree tc = liftIO $ do
    tc' <- unsafeManagedPtrGetPtr tc
    gst_video_time_code_interval_free tc'
    touchManagedPtr tc
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeIntervalFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoTimeCodeIntervalFreeMethodInfo VideoTimeCodeInterval signature where
    overloadedMethod _ = videoTimeCodeIntervalFree

#endif

-- method VideoTimeCodeInterval::init
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "tc", argType = TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hours", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hours field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minutes", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minutes field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the seconds field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frames", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the frames field of #GstVideoTimeCodeInterval", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_interval_init" gst_video_time_code_interval_init :: 
    Ptr VideoTimeCodeInterval ->            -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"})
    Word32 ->                               -- hours : TBasicType TUInt
    Word32 ->                               -- minutes : TBasicType TUInt
    Word32 ->                               -- seconds : TBasicType TUInt
    Word32 ->                               -- frames : TBasicType TUInt
    IO ()

{- |
Initializes /@tc@/ with the given values.

@since 1.12
-}
videoTimeCodeIntervalInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoTimeCodeInterval
    {- ^ /@tc@/: a 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> Word32
    {- ^ /@hours@/: the hours field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> Word32
    {- ^ /@minutes@/: the minutes field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> Word32
    {- ^ /@seconds@/: the seconds field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> Word32
    {- ^ /@frames@/: the frames field of 'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' -}
    -> m ()
videoTimeCodeIntervalInit tc hours minutes seconds frames = liftIO $ do
    tc' <- unsafeManagedPtrGetPtr tc
    gst_video_time_code_interval_init tc' hours minutes seconds frames
    touchManagedPtr tc
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data VideoTimeCodeIntervalInitMethodInfo
instance (signature ~ (Word32 -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m) => O.MethodInfo VideoTimeCodeIntervalInitMethodInfo VideoTimeCodeInterval signature where
    overloadedMethod _ = videoTimeCodeIntervalInit

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveVideoTimeCodeIntervalMethod (t :: Symbol) (o :: *) :: * where
    ResolveVideoTimeCodeIntervalMethod "clear" o = VideoTimeCodeIntervalClearMethodInfo
    ResolveVideoTimeCodeIntervalMethod "copy" o = VideoTimeCodeIntervalCopyMethodInfo
    ResolveVideoTimeCodeIntervalMethod "free" o = VideoTimeCodeIntervalFreeMethodInfo
    ResolveVideoTimeCodeIntervalMethod "init" o = VideoTimeCodeIntervalInitMethodInfo
    ResolveVideoTimeCodeIntervalMethod l o = O.MethodResolutionFailed l o

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

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