{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Useful for testing purposes.
-- 
-- == Asset
-- 
-- The default asset ID is GESTestClip, but the framerate and video
-- size can be overridden using an ID of the form:
-- 
-- >framerate=60/1, width=1920, height=1080, max-duration=5.0
-- 
-- Note: @max-duration@ can be provided in seconds as float, or as GstClockTime
-- as guint64 or gint.

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

module GI.GES.Objects.TestClip
    ( 

-- * Exported types
    TestClip(..)                            ,
    IsTestClip                              ,
    toTestClip                              ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [add]("GI.GES.Objects.Container#g:method:add"), [addAsset]("GI.GES.Objects.Clip#g:method:addAsset"), [addChildProperty]("GI.GES.Objects.TimelineElement#g:method:addChildProperty"), [addChildToTrack]("GI.GES.Objects.Clip#g:method:addChildToTrack"), [addMetasFromString]("GI.GES.Interfaces.MetaContainer#g:method:addMetasFromString"), [addTopEffect]("GI.GES.Objects.Clip#g:method:addTopEffect"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [checkMetaRegistered]("GI.GES.Interfaces.MetaContainer#g:method:checkMetaRegistered"), [copy]("GI.GES.Objects.TimelineElement#g:method:copy"), [edit]("GI.GES.Objects.Container#g:method:edit"), [editFull]("GI.GES.Objects.TimelineElement#g:method:editFull"), [findTrackElement]("GI.GES.Objects.Clip#g:method:findTrackElement"), [findTrackElements]("GI.GES.Objects.Clip#g:method:findTrackElements"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.GES.Interfaces.MetaContainer#g:method:foreach"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isMuted]("GI.GES.Objects.TestClip#g:method:isMuted"), [listChildrenProperties]("GI.GES.Objects.TimelineElement#g:method:listChildrenProperties"), [lookupChild]("GI.GES.Objects.TimelineElement#g:method:lookupChild"), [metasToString]("GI.GES.Interfaces.MetaContainer#g:method:metasToString"), [moveToLayer]("GI.GES.Objects.Clip#g:method:moveToLayer"), [moveToLayerFull]("GI.GES.Objects.Clip#g:method:moveToLayerFull"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [paste]("GI.GES.Objects.TimelineElement#g:method:paste"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [registerMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerMeta"), [registerMetaBoolean]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaBoolean"), [registerMetaDate]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDate"), [registerMetaDateTime]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDateTime"), [registerMetaDouble]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDouble"), [registerMetaFloat]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaFloat"), [registerMetaInt]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt"), [registerMetaInt64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt64"), [registerMetaString]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaString"), [registerMetaUint]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint"), [registerMetaUint64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint64"), [registerStaticMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerStaticMeta"), [remove]("GI.GES.Objects.Container#g:method:remove"), [removeChildProperty]("GI.GES.Objects.TimelineElement#g:method:removeChildProperty"), [removeTopEffect]("GI.GES.Objects.Clip#g:method:removeTopEffect"), [ripple]("GI.GES.Objects.TimelineElement#g:method:ripple"), [rippleEnd]("GI.GES.Objects.TimelineElement#g:method:rippleEnd"), [rollEnd]("GI.GES.Objects.TimelineElement#g:method:rollEnd"), [rollStart]("GI.GES.Objects.TimelineElement#g:method:rollStart"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [split]("GI.GES.Objects.Clip#g:method:split"), [splitFull]("GI.GES.Objects.Clip#g:method:splitFull"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [trim]("GI.GES.Objects.TimelineElement#g:method:trim"), [ungroup]("GI.GES.Objects.Container#g:method:ungroup"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAsset]("GI.GES.Interfaces.Extractable#g:method:getAsset"), [getBoolean]("GI.GES.Interfaces.MetaContainer#g:method:getBoolean"), [getChildProperty]("GI.GES.Objects.TimelineElement#g:method:getChildProperty"), [getChildPropertyByPspec]("GI.GES.Objects.TimelineElement#g:method:getChildPropertyByPspec"), [getChildren]("GI.GES.Objects.Container#g:method:getChildren"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDate]("GI.GES.Interfaces.MetaContainer#g:method:getDate"), [getDateTime]("GI.GES.Interfaces.MetaContainer#g:method:getDateTime"), [getDouble]("GI.GES.Interfaces.MetaContainer#g:method:getDouble"), [getDuration]("GI.GES.Objects.TimelineElement#g:method:getDuration"), [getDurationLimit]("GI.GES.Objects.Clip#g:method:getDurationLimit"), [getFloat]("GI.GES.Interfaces.MetaContainer#g:method:getFloat"), [getFrequency]("GI.GES.Objects.TestClip#g:method:getFrequency"), [getId]("GI.GES.Interfaces.Extractable#g:method:getId"), [getInpoint]("GI.GES.Objects.TimelineElement#g:method:getInpoint"), [getInt]("GI.GES.Interfaces.MetaContainer#g:method:getInt"), [getInt64]("GI.GES.Interfaces.MetaContainer#g:method:getInt64"), [getInternalTimeFromTimelineTime]("GI.GES.Objects.Clip#g:method:getInternalTimeFromTimelineTime"), [getLayer]("GI.GES.Objects.Clip#g:method:getLayer"), [getLayerPriority]("GI.GES.Objects.TimelineElement#g:method:getLayerPriority"), [getMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:getMarkerList"), [getMaxDuration]("GI.GES.Objects.TimelineElement#g:method:getMaxDuration"), [getMeta]("GI.GES.Interfaces.MetaContainer#g:method:getMeta"), [getName]("GI.GES.Objects.TimelineElement#g:method:getName"), [getNaturalFramerate]("GI.GES.Objects.TimelineElement#g:method:getNaturalFramerate"), [getParent]("GI.GES.Objects.TimelineElement#g:method:getParent"), [getPriority]("GI.GES.Objects.TimelineElement#g:method:getPriority"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getStart]("GI.GES.Objects.TimelineElement#g:method:getStart"), [getString]("GI.GES.Interfaces.MetaContainer#g:method:getString"), [getSupportedFormats]("GI.GES.Objects.Clip#g:method:getSupportedFormats"), [getTimeline]("GI.GES.Objects.TimelineElement#g:method:getTimeline"), [getTimelineTimeFromInternalTime]("GI.GES.Objects.Clip#g:method:getTimelineTimeFromInternalTime"), [getTimelineTimeFromSourceFrame]("GI.GES.Objects.Clip#g:method:getTimelineTimeFromSourceFrame"), [getTopEffectIndex]("GI.GES.Objects.Clip#g:method:getTopEffectIndex"), [getTopEffectPosition]("GI.GES.Objects.Clip#g:method:getTopEffectPosition"), [getTopEffects]("GI.GES.Objects.Clip#g:method:getTopEffects"), [getToplevelParent]("GI.GES.Objects.TimelineElement#g:method:getToplevelParent"), [getTrackTypes]("GI.GES.Objects.TimelineElement#g:method:getTrackTypes"), [getUint]("GI.GES.Interfaces.MetaContainer#g:method:getUint"), [getUint64]("GI.GES.Interfaces.MetaContainer#g:method:getUint64"), [getVolume]("GI.GES.Objects.TestClip#g:method:getVolume"), [getVpattern]("GI.GES.Objects.TestClip#g:method:getVpattern").
-- 
-- ==== Setters
-- [setAsset]("GI.GES.Interfaces.Extractable#g:method:setAsset"), [setBoolean]("GI.GES.Interfaces.MetaContainer#g:method:setBoolean"), [setChildProperty]("GI.GES.Objects.TimelineElement#g:method:setChildProperty"), [setChildPropertyByPspec]("GI.GES.Objects.TimelineElement#g:method:setChildPropertyByPspec"), [setChildPropertyFull]("GI.GES.Objects.TimelineElement#g:method:setChildPropertyFull"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDate]("GI.GES.Interfaces.MetaContainer#g:method:setDate"), [setDateTime]("GI.GES.Interfaces.MetaContainer#g:method:setDateTime"), [setDouble]("GI.GES.Interfaces.MetaContainer#g:method:setDouble"), [setDuration]("GI.GES.Objects.TimelineElement#g:method:setDuration"), [setFloat]("GI.GES.Interfaces.MetaContainer#g:method:setFloat"), [setFrequency]("GI.GES.Objects.TestClip#g:method:setFrequency"), [setInpoint]("GI.GES.Objects.TimelineElement#g:method:setInpoint"), [setInt]("GI.GES.Interfaces.MetaContainer#g:method:setInt"), [setInt64]("GI.GES.Interfaces.MetaContainer#g:method:setInt64"), [setMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:setMarkerList"), [setMaxDuration]("GI.GES.Objects.TimelineElement#g:method:setMaxDuration"), [setMeta]("GI.GES.Interfaces.MetaContainer#g:method:setMeta"), [setMute]("GI.GES.Objects.TestClip#g:method:setMute"), [setName]("GI.GES.Objects.TimelineElement#g:method:setName"), [setParent]("GI.GES.Objects.TimelineElement#g:method:setParent"), [setPriority]("GI.GES.Objects.TimelineElement#g:method:setPriority"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setStart]("GI.GES.Objects.TimelineElement#g:method:setStart"), [setString]("GI.GES.Interfaces.MetaContainer#g:method:setString"), [setSupportedFormats]("GI.GES.Objects.Clip#g:method:setSupportedFormats"), [setTimeline]("GI.GES.Objects.TimelineElement#g:method:setTimeline"), [setTopEffectIndex]("GI.GES.Objects.Clip#g:method:setTopEffectIndex"), [setTopEffectIndexFull]("GI.GES.Objects.Clip#g:method:setTopEffectIndexFull"), [setTopEffectPriority]("GI.GES.Objects.Clip#g:method:setTopEffectPriority"), [setUint]("GI.GES.Interfaces.MetaContainer#g:method:setUint"), [setUint64]("GI.GES.Interfaces.MetaContainer#g:method:setUint64"), [setVolume]("GI.GES.Objects.TestClip#g:method:setVolume"), [setVpattern]("GI.GES.Objects.TestClip#g:method:setVpattern").

#if defined(ENABLE_OVERLOADING)
    ResolveTestClipMethod                   ,
#endif

-- ** getFrequency #method:getFrequency#

#if defined(ENABLE_OVERLOADING)
    TestClipGetFrequencyMethodInfo          ,
#endif
    testClipGetFrequency                    ,


-- ** getVolume #method:getVolume#

#if defined(ENABLE_OVERLOADING)
    TestClipGetVolumeMethodInfo             ,
#endif
    testClipGetVolume                       ,


-- ** getVpattern #method:getVpattern#

#if defined(ENABLE_OVERLOADING)
    TestClipGetVpatternMethodInfo           ,
#endif
    testClipGetVpattern                     ,


-- ** isMuted #method:isMuted#

#if defined(ENABLE_OVERLOADING)
    TestClipIsMutedMethodInfo               ,
#endif
    testClipIsMuted                         ,


-- ** new #method:new#

    testClipNew                             ,


-- ** newForNick #method:newForNick#

    testClipNewForNick                      ,


-- ** setFrequency #method:setFrequency#

#if defined(ENABLE_OVERLOADING)
    TestClipSetFrequencyMethodInfo          ,
#endif
    testClipSetFrequency                    ,


-- ** setMute #method:setMute#

#if defined(ENABLE_OVERLOADING)
    TestClipSetMuteMethodInfo               ,
#endif
    testClipSetMute                         ,


-- ** setVolume #method:setVolume#

#if defined(ENABLE_OVERLOADING)
    TestClipSetVolumeMethodInfo             ,
#endif
    testClipSetVolume                       ,


-- ** setVpattern #method:setVpattern#

#if defined(ENABLE_OVERLOADING)
    TestClipSetVpatternMethodInfo           ,
#endif
    testClipSetVpattern                     ,




 -- * Properties


-- ** freq #attr:freq#
-- | The frequency to generate for audio track elements.

#if defined(ENABLE_OVERLOADING)
    TestClipFreqPropertyInfo                ,
#endif
    constructTestClipFreq                   ,
    getTestClipFreq                         ,
    setTestClipFreq                         ,
#if defined(ENABLE_OVERLOADING)
    testClipFreq                            ,
#endif


-- ** mute #attr:mute#
-- | Whether the sound will be played or not.

#if defined(ENABLE_OVERLOADING)
    TestClipMutePropertyInfo                ,
#endif
    constructTestClipMute                   ,
    getTestClipMute                         ,
    setTestClipMute                         ,
#if defined(ENABLE_OVERLOADING)
    testClipMute                            ,
#endif


-- ** volume #attr:volume#
-- | The volume for the audio track elements.

#if defined(ENABLE_OVERLOADING)
    TestClipVolumePropertyInfo              ,
#endif
    constructTestClipVolume                 ,
    getTestClipVolume                       ,
    setTestClipVolume                       ,
#if defined(ENABLE_OVERLOADING)
    testClipVolume                          ,
#endif


-- ** vpattern #attr:vpattern#
-- | Video pattern to display in video track elements.

#if defined(ENABLE_OVERLOADING)
    TestClipVpatternPropertyInfo            ,
#endif
    constructTestClipVpattern               ,
    getTestClipVpattern                     ,
    setTestClipVpattern                     ,
#if defined(ENABLE_OVERLOADING)
    testClipVpattern                        ,
#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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R

import {-# SOURCE #-} qualified GI.GES.Enums as GES.Enums
import {-# SOURCE #-} qualified GI.GES.Interfaces.Extractable as GES.Extractable
import {-# SOURCE #-} qualified GI.GES.Interfaces.MetaContainer as GES.MetaContainer
import {-# SOURCE #-} qualified GI.GES.Objects.Clip as GES.Clip
import {-# SOURCE #-} qualified GI.GES.Objects.Container as GES.Container
import {-# SOURCE #-} qualified GI.GES.Objects.SourceClip as GES.SourceClip
import {-# SOURCE #-} qualified GI.GES.Objects.TimelineElement as GES.TimelineElement
import qualified GI.GObject.Objects.Object as GObject.Object

-- | Memory-managed wrapper type.
newtype TestClip = TestClip (SP.ManagedPtr TestClip)
    deriving (TestClip -> TestClip -> Bool
(TestClip -> TestClip -> Bool)
-> (TestClip -> TestClip -> Bool) -> Eq TestClip
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TestClip -> TestClip -> Bool
== :: TestClip -> TestClip -> Bool
$c/= :: TestClip -> TestClip -> Bool
/= :: TestClip -> TestClip -> Bool
Eq)

instance SP.ManagedPtrNewtype TestClip where
    toManagedPtr :: TestClip -> ManagedPtr TestClip
toManagedPtr (TestClip ManagedPtr TestClip
p) = ManagedPtr TestClip
p

foreign import ccall "ges_test_clip_get_type"
    c_ges_test_clip_get_type :: IO B.Types.GType

instance B.Types.TypedObject TestClip where
    glibType :: IO GType
glibType = IO GType
c_ges_test_clip_get_type

instance B.Types.GObject TestClip

-- | Type class for types which can be safely cast to `TestClip`, for instance with `toTestClip`.
class (SP.GObject o, O.IsDescendantOf TestClip o) => IsTestClip o
instance (SP.GObject o, O.IsDescendantOf TestClip o) => IsTestClip o

instance O.HasParentTypes TestClip
type instance O.ParentTypes TestClip = '[GES.SourceClip.SourceClip, GES.Clip.Clip, GES.Container.Container, GES.TimelineElement.TimelineElement, GObject.Object.Object, GES.Extractable.Extractable, GES.MetaContainer.MetaContainer]

-- | Cast to `TestClip`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTestClip :: (MIO.MonadIO m, IsTestClip o) => o -> m TestClip
toTestClip :: forall (m :: * -> *) o.
(MonadIO m, IsTestClip o) =>
o -> m TestClip
toTestClip = IO TestClip -> m TestClip
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO TestClip -> m TestClip)
-> (o -> IO TestClip) -> o -> m TestClip
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr TestClip -> TestClip) -> o -> IO TestClip
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr TestClip -> TestClip
TestClip

-- | Convert 'TestClip' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe TestClip) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ges_test_clip_get_type
    gvalueSet_ :: Ptr GValue -> Maybe TestClip -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TestClip
P.Nothing = Ptr GValue -> Ptr TestClip -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr TestClip
forall a. Ptr a
FP.nullPtr :: FP.Ptr TestClip)
    gvalueSet_ Ptr GValue
gv (P.Just TestClip
obj) = TestClip -> (Ptr TestClip -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TestClip
obj (Ptr GValue -> Ptr TestClip -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe TestClip)
gvalueGet_ Ptr GValue
gv = do
        Ptr TestClip
ptr <- Ptr GValue -> IO (Ptr TestClip)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TestClip)
        if Ptr TestClip
ptr Ptr TestClip -> Ptr TestClip -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TestClip
forall a. Ptr a
FP.nullPtr
        then TestClip -> Maybe TestClip
forall a. a -> Maybe a
P.Just (TestClip -> Maybe TestClip) -> IO TestClip -> IO (Maybe TestClip)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr TestClip -> TestClip) -> Ptr TestClip -> IO TestClip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TestClip -> TestClip
TestClip Ptr TestClip
ptr
        else Maybe TestClip -> IO (Maybe TestClip)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TestClip
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveTestClipMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveTestClipMethod "add" o = GES.Container.ContainerAddMethodInfo
    ResolveTestClipMethod "addAsset" o = GES.Clip.ClipAddAssetMethodInfo
    ResolveTestClipMethod "addChildProperty" o = GES.TimelineElement.TimelineElementAddChildPropertyMethodInfo
    ResolveTestClipMethod "addChildToTrack" o = GES.Clip.ClipAddChildToTrackMethodInfo
    ResolveTestClipMethod "addMetasFromString" o = GES.MetaContainer.MetaContainerAddMetasFromStringMethodInfo
    ResolveTestClipMethod "addTopEffect" o = GES.Clip.ClipAddTopEffectMethodInfo
    ResolveTestClipMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTestClipMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTestClipMethod "checkMetaRegistered" o = GES.MetaContainer.MetaContainerCheckMetaRegisteredMethodInfo
    ResolveTestClipMethod "copy" o = GES.TimelineElement.TimelineElementCopyMethodInfo
    ResolveTestClipMethod "edit" o = GES.Container.ContainerEditMethodInfo
    ResolveTestClipMethod "editFull" o = GES.TimelineElement.TimelineElementEditFullMethodInfo
    ResolveTestClipMethod "findTrackElement" o = GES.Clip.ClipFindTrackElementMethodInfo
    ResolveTestClipMethod "findTrackElements" o = GES.Clip.ClipFindTrackElementsMethodInfo
    ResolveTestClipMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTestClipMethod "foreach" o = GES.MetaContainer.MetaContainerForeachMethodInfo
    ResolveTestClipMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTestClipMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTestClipMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTestClipMethod "isMuted" o = TestClipIsMutedMethodInfo
    ResolveTestClipMethod "listChildrenProperties" o = GES.TimelineElement.TimelineElementListChildrenPropertiesMethodInfo
    ResolveTestClipMethod "lookupChild" o = GES.TimelineElement.TimelineElementLookupChildMethodInfo
    ResolveTestClipMethod "metasToString" o = GES.MetaContainer.MetaContainerMetasToStringMethodInfo
    ResolveTestClipMethod "moveToLayer" o = GES.Clip.ClipMoveToLayerMethodInfo
    ResolveTestClipMethod "moveToLayerFull" o = GES.Clip.ClipMoveToLayerFullMethodInfo
    ResolveTestClipMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTestClipMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTestClipMethod "paste" o = GES.TimelineElement.TimelineElementPasteMethodInfo
    ResolveTestClipMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTestClipMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTestClipMethod "registerMeta" o = GES.MetaContainer.MetaContainerRegisterMetaMethodInfo
    ResolveTestClipMethod "registerMetaBoolean" o = GES.MetaContainer.MetaContainerRegisterMetaBooleanMethodInfo
    ResolveTestClipMethod "registerMetaDate" o = GES.MetaContainer.MetaContainerRegisterMetaDateMethodInfo
    ResolveTestClipMethod "registerMetaDateTime" o = GES.MetaContainer.MetaContainerRegisterMetaDateTimeMethodInfo
    ResolveTestClipMethod "registerMetaDouble" o = GES.MetaContainer.MetaContainerRegisterMetaDoubleMethodInfo
    ResolveTestClipMethod "registerMetaFloat" o = GES.MetaContainer.MetaContainerRegisterMetaFloatMethodInfo
    ResolveTestClipMethod "registerMetaInt" o = GES.MetaContainer.MetaContainerRegisterMetaIntMethodInfo
    ResolveTestClipMethod "registerMetaInt64" o = GES.MetaContainer.MetaContainerRegisterMetaInt64MethodInfo
    ResolveTestClipMethod "registerMetaString" o = GES.MetaContainer.MetaContainerRegisterMetaStringMethodInfo
    ResolveTestClipMethod "registerMetaUint" o = GES.MetaContainer.MetaContainerRegisterMetaUintMethodInfo
    ResolveTestClipMethod "registerMetaUint64" o = GES.MetaContainer.MetaContainerRegisterMetaUint64MethodInfo
    ResolveTestClipMethod "registerStaticMeta" o = GES.MetaContainer.MetaContainerRegisterStaticMetaMethodInfo
    ResolveTestClipMethod "remove" o = GES.Container.ContainerRemoveMethodInfo
    ResolveTestClipMethod "removeChildProperty" o = GES.TimelineElement.TimelineElementRemoveChildPropertyMethodInfo
    ResolveTestClipMethod "removeTopEffect" o = GES.Clip.ClipRemoveTopEffectMethodInfo
    ResolveTestClipMethod "ripple" o = GES.TimelineElement.TimelineElementRippleMethodInfo
    ResolveTestClipMethod "rippleEnd" o = GES.TimelineElement.TimelineElementRippleEndMethodInfo
    ResolveTestClipMethod "rollEnd" o = GES.TimelineElement.TimelineElementRollEndMethodInfo
    ResolveTestClipMethod "rollStart" o = GES.TimelineElement.TimelineElementRollStartMethodInfo
    ResolveTestClipMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTestClipMethod "split" o = GES.Clip.ClipSplitMethodInfo
    ResolveTestClipMethod "splitFull" o = GES.Clip.ClipSplitFullMethodInfo
    ResolveTestClipMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTestClipMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTestClipMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTestClipMethod "trim" o = GES.TimelineElement.TimelineElementTrimMethodInfo
    ResolveTestClipMethod "ungroup" o = GES.Container.ContainerUngroupMethodInfo
    ResolveTestClipMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTestClipMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTestClipMethod "getAsset" o = GES.Extractable.ExtractableGetAssetMethodInfo
    ResolveTestClipMethod "getBoolean" o = GES.MetaContainer.MetaContainerGetBooleanMethodInfo
    ResolveTestClipMethod "getChildProperty" o = GES.TimelineElement.TimelineElementGetChildPropertyMethodInfo
    ResolveTestClipMethod "getChildPropertyByPspec" o = GES.TimelineElement.TimelineElementGetChildPropertyByPspecMethodInfo
    ResolveTestClipMethod "getChildren" o = GES.Container.ContainerGetChildrenMethodInfo
    ResolveTestClipMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTestClipMethod "getDate" o = GES.MetaContainer.MetaContainerGetDateMethodInfo
    ResolveTestClipMethod "getDateTime" o = GES.MetaContainer.MetaContainerGetDateTimeMethodInfo
    ResolveTestClipMethod "getDouble" o = GES.MetaContainer.MetaContainerGetDoubleMethodInfo
    ResolveTestClipMethod "getDuration" o = GES.TimelineElement.TimelineElementGetDurationMethodInfo
    ResolveTestClipMethod "getDurationLimit" o = GES.Clip.ClipGetDurationLimitMethodInfo
    ResolveTestClipMethod "getFloat" o = GES.MetaContainer.MetaContainerGetFloatMethodInfo
    ResolveTestClipMethod "getFrequency" o = TestClipGetFrequencyMethodInfo
    ResolveTestClipMethod "getId" o = GES.Extractable.ExtractableGetIdMethodInfo
    ResolveTestClipMethod "getInpoint" o = GES.TimelineElement.TimelineElementGetInpointMethodInfo
    ResolveTestClipMethod "getInt" o = GES.MetaContainer.MetaContainerGetIntMethodInfo
    ResolveTestClipMethod "getInt64" o = GES.MetaContainer.MetaContainerGetInt64MethodInfo
    ResolveTestClipMethod "getInternalTimeFromTimelineTime" o = GES.Clip.ClipGetInternalTimeFromTimelineTimeMethodInfo
    ResolveTestClipMethod "getLayer" o = GES.Clip.ClipGetLayerMethodInfo
    ResolveTestClipMethod "getLayerPriority" o = GES.TimelineElement.TimelineElementGetLayerPriorityMethodInfo
    ResolveTestClipMethod "getMarkerList" o = GES.MetaContainer.MetaContainerGetMarkerListMethodInfo
    ResolveTestClipMethod "getMaxDuration" o = GES.TimelineElement.TimelineElementGetMaxDurationMethodInfo
    ResolveTestClipMethod "getMeta" o = GES.MetaContainer.MetaContainerGetMetaMethodInfo
    ResolveTestClipMethod "getName" o = GES.TimelineElement.TimelineElementGetNameMethodInfo
    ResolveTestClipMethod "getNaturalFramerate" o = GES.TimelineElement.TimelineElementGetNaturalFramerateMethodInfo
    ResolveTestClipMethod "getParent" o = GES.TimelineElement.TimelineElementGetParentMethodInfo
    ResolveTestClipMethod "getPriority" o = GES.TimelineElement.TimelineElementGetPriorityMethodInfo
    ResolveTestClipMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTestClipMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTestClipMethod "getStart" o = GES.TimelineElement.TimelineElementGetStartMethodInfo
    ResolveTestClipMethod "getString" o = GES.MetaContainer.MetaContainerGetStringMethodInfo
    ResolveTestClipMethod "getSupportedFormats" o = GES.Clip.ClipGetSupportedFormatsMethodInfo
    ResolveTestClipMethod "getTimeline" o = GES.TimelineElement.TimelineElementGetTimelineMethodInfo
    ResolveTestClipMethod "getTimelineTimeFromInternalTime" o = GES.Clip.ClipGetTimelineTimeFromInternalTimeMethodInfo
    ResolveTestClipMethod "getTimelineTimeFromSourceFrame" o = GES.Clip.ClipGetTimelineTimeFromSourceFrameMethodInfo
    ResolveTestClipMethod "getTopEffectIndex" o = GES.Clip.ClipGetTopEffectIndexMethodInfo
    ResolveTestClipMethod "getTopEffectPosition" o = GES.Clip.ClipGetTopEffectPositionMethodInfo
    ResolveTestClipMethod "getTopEffects" o = GES.Clip.ClipGetTopEffectsMethodInfo
    ResolveTestClipMethod "getToplevelParent" o = GES.TimelineElement.TimelineElementGetToplevelParentMethodInfo
    ResolveTestClipMethod "getTrackTypes" o = GES.TimelineElement.TimelineElementGetTrackTypesMethodInfo
    ResolveTestClipMethod "getUint" o = GES.MetaContainer.MetaContainerGetUintMethodInfo
    ResolveTestClipMethod "getUint64" o = GES.MetaContainer.MetaContainerGetUint64MethodInfo
    ResolveTestClipMethod "getVolume" o = TestClipGetVolumeMethodInfo
    ResolveTestClipMethod "getVpattern" o = TestClipGetVpatternMethodInfo
    ResolveTestClipMethod "setAsset" o = GES.Extractable.ExtractableSetAssetMethodInfo
    ResolveTestClipMethod "setBoolean" o = GES.MetaContainer.MetaContainerSetBooleanMethodInfo
    ResolveTestClipMethod "setChildProperty" o = GES.TimelineElement.TimelineElementSetChildPropertyMethodInfo
    ResolveTestClipMethod "setChildPropertyByPspec" o = GES.TimelineElement.TimelineElementSetChildPropertyByPspecMethodInfo
    ResolveTestClipMethod "setChildPropertyFull" o = GES.TimelineElement.TimelineElementSetChildPropertyFullMethodInfo
    ResolveTestClipMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTestClipMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTestClipMethod "setDate" o = GES.MetaContainer.MetaContainerSetDateMethodInfo
    ResolveTestClipMethod "setDateTime" o = GES.MetaContainer.MetaContainerSetDateTimeMethodInfo
    ResolveTestClipMethod "setDouble" o = GES.MetaContainer.MetaContainerSetDoubleMethodInfo
    ResolveTestClipMethod "setDuration" o = GES.TimelineElement.TimelineElementSetDurationMethodInfo
    ResolveTestClipMethod "setFloat" o = GES.MetaContainer.MetaContainerSetFloatMethodInfo
    ResolveTestClipMethod "setFrequency" o = TestClipSetFrequencyMethodInfo
    ResolveTestClipMethod "setInpoint" o = GES.TimelineElement.TimelineElementSetInpointMethodInfo
    ResolveTestClipMethod "setInt" o = GES.MetaContainer.MetaContainerSetIntMethodInfo
    ResolveTestClipMethod "setInt64" o = GES.MetaContainer.MetaContainerSetInt64MethodInfo
    ResolveTestClipMethod "setMarkerList" o = GES.MetaContainer.MetaContainerSetMarkerListMethodInfo
    ResolveTestClipMethod "setMaxDuration" o = GES.TimelineElement.TimelineElementSetMaxDurationMethodInfo
    ResolveTestClipMethod "setMeta" o = GES.MetaContainer.MetaContainerSetMetaMethodInfo
    ResolveTestClipMethod "setMute" o = TestClipSetMuteMethodInfo
    ResolveTestClipMethod "setName" o = GES.TimelineElement.TimelineElementSetNameMethodInfo
    ResolveTestClipMethod "setParent" o = GES.TimelineElement.TimelineElementSetParentMethodInfo
    ResolveTestClipMethod "setPriority" o = GES.TimelineElement.TimelineElementSetPriorityMethodInfo
    ResolveTestClipMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTestClipMethod "setStart" o = GES.TimelineElement.TimelineElementSetStartMethodInfo
    ResolveTestClipMethod "setString" o = GES.MetaContainer.MetaContainerSetStringMethodInfo
    ResolveTestClipMethod "setSupportedFormats" o = GES.Clip.ClipSetSupportedFormatsMethodInfo
    ResolveTestClipMethod "setTimeline" o = GES.TimelineElement.TimelineElementSetTimelineMethodInfo
    ResolveTestClipMethod "setTopEffectIndex" o = GES.Clip.ClipSetTopEffectIndexMethodInfo
    ResolveTestClipMethod "setTopEffectIndexFull" o = GES.Clip.ClipSetTopEffectIndexFullMethodInfo
    ResolveTestClipMethod "setTopEffectPriority" o = GES.Clip.ClipSetTopEffectPriorityMethodInfo
    ResolveTestClipMethod "setUint" o = GES.MetaContainer.MetaContainerSetUintMethodInfo
    ResolveTestClipMethod "setUint64" o = GES.MetaContainer.MetaContainerSetUint64MethodInfo
    ResolveTestClipMethod "setVolume" o = TestClipSetVolumeMethodInfo
    ResolveTestClipMethod "setVpattern" o = TestClipSetVpatternMethodInfo
    ResolveTestClipMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveTestClipMethod t TestClip, O.OverloadedMethod info TestClip p) => OL.IsLabel t (TestClip -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTestClipMethod t TestClip, O.OverloadedMethod info TestClip p, R.HasField t TestClip p) => R.HasField t TestClip p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveTestClipMethod t TestClip, O.OverloadedMethodInfo info TestClip) => OL.IsLabel t (O.MethodProxy info TestClip) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- VVV Prop "freq"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@freq@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' testClip #freq
-- @
getTestClipFreq :: (MonadIO m, IsTestClip o) => o -> m Double
getTestClipFreq :: forall (m :: * -> *) o. (MonadIO m, IsTestClip o) => o -> m Double
getTestClipFreq o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"freq"

-- | Set the value of the “@freq@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' testClip [ #freq 'Data.GI.Base.Attributes.:=' value ]
-- @
setTestClipFreq :: (MonadIO m, IsTestClip o) => o -> Double -> m ()
setTestClipFreq :: forall (m :: * -> *) o.
(MonadIO m, IsTestClip o) =>
o -> Double -> m ()
setTestClipFreq o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"freq" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@freq@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTestClipFreq :: (IsTestClip o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructTestClipFreq :: forall o (m :: * -> *).
(IsTestClip o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructTestClipFreq Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"freq" Double
val

#if defined(ENABLE_OVERLOADING)
data TestClipFreqPropertyInfo
instance AttrInfo TestClipFreqPropertyInfo where
    type AttrAllowedOps TestClipFreqPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TestClipFreqPropertyInfo = IsTestClip
    type AttrSetTypeConstraint TestClipFreqPropertyInfo = (~) Double
    type AttrTransferTypeConstraint TestClipFreqPropertyInfo = (~) Double
    type AttrTransferType TestClipFreqPropertyInfo = Double
    type AttrGetType TestClipFreqPropertyInfo = Double
    type AttrLabel TestClipFreqPropertyInfo = "freq"
    type AttrOrigin TestClipFreqPropertyInfo = TestClip
    attrGet = getTestClipFreq
    attrSet = setTestClipFreq
    attrTransfer _ v = do
        return v
    attrConstruct = constructTestClipFreq
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.freq"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#g:attr:freq"
        })
#endif

-- VVV Prop "mute"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Just False)

-- | Get the value of the “@mute@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' testClip #mute
-- @
getTestClipMute :: (MonadIO m, IsTestClip o) => o -> m Bool
getTestClipMute :: forall (m :: * -> *) o. (MonadIO m, IsTestClip o) => o -> m Bool
getTestClipMute o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"mute"

-- | Set the value of the “@mute@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' testClip [ #mute 'Data.GI.Base.Attributes.:=' value ]
-- @
setTestClipMute :: (MonadIO m, IsTestClip o) => o -> Bool -> m ()
setTestClipMute :: forall (m :: * -> *) o.
(MonadIO m, IsTestClip o) =>
o -> Bool -> m ()
setTestClipMute o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"mute" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@mute@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTestClipMute :: (IsTestClip o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTestClipMute :: forall o (m :: * -> *).
(IsTestClip o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTestClipMute Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"mute" Bool
val

#if defined(ENABLE_OVERLOADING)
data TestClipMutePropertyInfo
instance AttrInfo TestClipMutePropertyInfo where
    type AttrAllowedOps TestClipMutePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TestClipMutePropertyInfo = IsTestClip
    type AttrSetTypeConstraint TestClipMutePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TestClipMutePropertyInfo = (~) Bool
    type AttrTransferType TestClipMutePropertyInfo = Bool
    type AttrGetType TestClipMutePropertyInfo = Bool
    type AttrLabel TestClipMutePropertyInfo = "mute"
    type AttrOrigin TestClipMutePropertyInfo = TestClip
    attrGet = getTestClipMute
    attrSet = setTestClipMute
    attrTransfer _ v = do
        return v
    attrConstruct = constructTestClipMute
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.mute"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#g:attr:mute"
        })
#endif

-- VVV Prop "volume"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@volume@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' testClip #volume
-- @
getTestClipVolume :: (MonadIO m, IsTestClip o) => o -> m Double
getTestClipVolume :: forall (m :: * -> *) o. (MonadIO m, IsTestClip o) => o -> m Double
getTestClipVolume o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"volume"

-- | Set the value of the “@volume@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' testClip [ #volume 'Data.GI.Base.Attributes.:=' value ]
-- @
setTestClipVolume :: (MonadIO m, IsTestClip o) => o -> Double -> m ()
setTestClipVolume :: forall (m :: * -> *) o.
(MonadIO m, IsTestClip o) =>
o -> Double -> m ()
setTestClipVolume o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"volume" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@volume@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTestClipVolume :: (IsTestClip o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructTestClipVolume :: forall o (m :: * -> *).
(IsTestClip o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructTestClipVolume Double
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"volume" Double
val

#if defined(ENABLE_OVERLOADING)
data TestClipVolumePropertyInfo
instance AttrInfo TestClipVolumePropertyInfo where
    type AttrAllowedOps TestClipVolumePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TestClipVolumePropertyInfo = IsTestClip
    type AttrSetTypeConstraint TestClipVolumePropertyInfo = (~) Double
    type AttrTransferTypeConstraint TestClipVolumePropertyInfo = (~) Double
    type AttrTransferType TestClipVolumePropertyInfo = Double
    type AttrGetType TestClipVolumePropertyInfo = Double
    type AttrLabel TestClipVolumePropertyInfo = "volume"
    type AttrOrigin TestClipVolumePropertyInfo = TestClip
    attrGet = getTestClipVolume
    attrSet = setTestClipVolume
    attrTransfer _ v = do
        return v
    attrConstruct = constructTestClipVolume
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.volume"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#g:attr:volume"
        })
#endif

-- VVV Prop "vpattern"
   -- Type: TInterface (Name {namespace = "GES", name = "VideoTestPattern"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@vpattern@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' testClip #vpattern
-- @
getTestClipVpattern :: (MonadIO m, IsTestClip o) => o -> m GES.Enums.VideoTestPattern
getTestClipVpattern :: forall (m :: * -> *) o.
(MonadIO m, IsTestClip o) =>
o -> m VideoTestPattern
getTestClipVpattern o
obj = IO VideoTestPattern -> m VideoTestPattern
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO VideoTestPattern -> m VideoTestPattern)
-> IO VideoTestPattern -> m VideoTestPattern
forall a b. (a -> b) -> a -> b
$ o -> String -> IO VideoTestPattern
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"vpattern"

-- | Set the value of the “@vpattern@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' testClip [ #vpattern 'Data.GI.Base.Attributes.:=' value ]
-- @
setTestClipVpattern :: (MonadIO m, IsTestClip o) => o -> GES.Enums.VideoTestPattern -> m ()
setTestClipVpattern :: forall (m :: * -> *) o.
(MonadIO m, IsTestClip o) =>
o -> VideoTestPattern -> m ()
setTestClipVpattern o
obj VideoTestPattern
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> VideoTestPattern -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"vpattern" VideoTestPattern
val

-- | Construct a `GValueConstruct` with valid value for the “@vpattern@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTestClipVpattern :: (IsTestClip o, MIO.MonadIO m) => GES.Enums.VideoTestPattern -> m (GValueConstruct o)
constructTestClipVpattern :: forall o (m :: * -> *).
(IsTestClip o, MonadIO m) =>
VideoTestPattern -> m (GValueConstruct o)
constructTestClipVpattern VideoTestPattern
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> VideoTestPattern -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"vpattern" VideoTestPattern
val

#if defined(ENABLE_OVERLOADING)
data TestClipVpatternPropertyInfo
instance AttrInfo TestClipVpatternPropertyInfo where
    type AttrAllowedOps TestClipVpatternPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TestClipVpatternPropertyInfo = IsTestClip
    type AttrSetTypeConstraint TestClipVpatternPropertyInfo = (~) GES.Enums.VideoTestPattern
    type AttrTransferTypeConstraint TestClipVpatternPropertyInfo = (~) GES.Enums.VideoTestPattern
    type AttrTransferType TestClipVpatternPropertyInfo = GES.Enums.VideoTestPattern
    type AttrGetType TestClipVpatternPropertyInfo = GES.Enums.VideoTestPattern
    type AttrLabel TestClipVpatternPropertyInfo = "vpattern"
    type AttrOrigin TestClipVpatternPropertyInfo = TestClip
    attrGet = getTestClipVpattern
    attrSet = setTestClipVpattern
    attrTransfer _ v = do
        return v
    attrConstruct = constructTestClipVpattern
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.vpattern"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#g:attr:vpattern"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TestClip
type instance O.AttributeList TestClip = TestClipAttributeList
type TestClipAttributeList = ('[ '("duration", GES.TimelineElement.TimelineElementDurationPropertyInfo), '("durationLimit", GES.Clip.ClipDurationLimitPropertyInfo), '("freq", TestClipFreqPropertyInfo), '("height", GES.Container.ContainerHeightPropertyInfo), '("inPoint", GES.TimelineElement.TimelineElementInPointPropertyInfo), '("layer", GES.Clip.ClipLayerPropertyInfo), '("maxDuration", GES.TimelineElement.TimelineElementMaxDurationPropertyInfo), '("mute", TestClipMutePropertyInfo), '("name", GES.TimelineElement.TimelineElementNamePropertyInfo), '("parent", GES.TimelineElement.TimelineElementParentPropertyInfo), '("priority", GES.TimelineElement.TimelineElementPriorityPropertyInfo), '("serialize", GES.TimelineElement.TimelineElementSerializePropertyInfo), '("start", GES.TimelineElement.TimelineElementStartPropertyInfo), '("supportedFormats", GES.Clip.ClipSupportedFormatsPropertyInfo), '("timeline", GES.TimelineElement.TimelineElementTimelinePropertyInfo), '("volume", TestClipVolumePropertyInfo), '("vpattern", TestClipVpatternPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
testClipFreq :: AttrLabelProxy "freq"
testClipFreq = AttrLabelProxy

testClipMute :: AttrLabelProxy "mute"
testClipMute = AttrLabelProxy

testClipVolume :: AttrLabelProxy "volume"
testClipVolume = AttrLabelProxy

testClipVpattern :: AttrLabelProxy "vpattern"
testClipVpattern = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TestClip = TestClipSignalList
type TestClipSignalList = ('[ '("childAdded", GES.Container.ContainerChildAddedSignalInfo), '("childPropertyAdded", GES.TimelineElement.TimelineElementChildPropertyAddedSignalInfo), '("childPropertyRemoved", GES.TimelineElement.TimelineElementChildPropertyRemovedSignalInfo), '("childRemoved", GES.Container.ContainerChildRemovedSignalInfo), '("deepNotify", GES.TimelineElement.TimelineElementDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("notifyMeta", GES.MetaContainer.MetaContainerNotifyMetaSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method TestClip::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GES" , name = "TestClip" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_test_clip_new" ges_test_clip_new :: 
    IO (Ptr TestClip)

-- | Creates a new t'GI.GES.Objects.TestClip.TestClip'.
testClipNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (Maybe TestClip)
    -- ^ __Returns:__ The newly created t'GI.GES.Objects.TestClip.TestClip',
    -- or 'P.Nothing' if there was an error.
testClipNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m (Maybe TestClip)
testClipNew  = IO (Maybe TestClip) -> m (Maybe TestClip)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TestClip) -> m (Maybe TestClip))
-> IO (Maybe TestClip) -> m (Maybe TestClip)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TestClip
result <- IO (Ptr TestClip)
ges_test_clip_new
    Maybe TestClip
maybeResult <- Ptr TestClip
-> (Ptr TestClip -> IO TestClip) -> IO (Maybe TestClip)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TestClip
result ((Ptr TestClip -> IO TestClip) -> IO (Maybe TestClip))
-> (Ptr TestClip -> IO TestClip) -> IO (Maybe TestClip)
forall a b. (a -> b) -> a -> b
$ \Ptr TestClip
result' -> do
        TestClip
result'' <- ((ManagedPtr TestClip -> TestClip) -> Ptr TestClip -> IO TestClip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TestClip -> TestClip
TestClip) Ptr TestClip
result'
        TestClip -> IO TestClip
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TestClip
result''
    Maybe TestClip -> IO (Maybe TestClip)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TestClip
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method TestClip::new_for_nick
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "nick"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the nickname for which to create the #GESTestClip"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GES" , name = "TestClip" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_test_clip_new_for_nick" ges_test_clip_new_for_nick :: 
    CString ->                              -- nick : TBasicType TUTF8
    IO (Ptr TestClip)

-- | Creates a new t'GI.GES.Objects.TestClip.TestClip' for the provided /@nick@/.
testClipNewForNick ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@nick@/: the nickname for which to create the t'GI.GES.Objects.TestClip.TestClip'
    -> m (Maybe TestClip)
    -- ^ __Returns:__ The newly created t'GI.GES.Objects.TestClip.TestClip',
    -- or 'P.Nothing' if there was an error.
testClipNewForNick :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe TestClip)
testClipNewForNick Text
nick = IO (Maybe TestClip) -> m (Maybe TestClip)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TestClip) -> m (Maybe TestClip))
-> IO (Maybe TestClip) -> m (Maybe TestClip)
forall a b. (a -> b) -> a -> b
$ do
    CString
nick' <- Text -> IO CString
textToCString Text
nick
    Ptr TestClip
result <- CString -> IO (Ptr TestClip)
ges_test_clip_new_for_nick CString
nick'
    Maybe TestClip
maybeResult <- Ptr TestClip
-> (Ptr TestClip -> IO TestClip) -> IO (Maybe TestClip)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TestClip
result ((Ptr TestClip -> IO TestClip) -> IO (Maybe TestClip))
-> (Ptr TestClip -> IO TestClip) -> IO (Maybe TestClip)
forall a b. (a -> b) -> a -> b
$ \Ptr TestClip
result' -> do
        TestClip
result'' <- ((ManagedPtr TestClip -> TestClip) -> Ptr TestClip -> IO TestClip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TestClip -> TestClip
TestClip) Ptr TestClip
result'
        TestClip -> IO TestClip
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TestClip
result''
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
nick'
    Maybe TestClip -> IO (Maybe TestClip)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TestClip
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method TestClip::get_frequency
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TestClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESTestClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "ges_test_clip_get_frequency" ges_test_clip_get_frequency :: 
    Ptr TestClip ->                         -- self : TInterface (Name {namespace = "GES", name = "TestClip"})
    IO CDouble

-- | Get the frequency /@self@/ generates.
testClipGetFrequency ::
    (B.CallStack.HasCallStack, MonadIO m, IsTestClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TestClip.TestClip'
    -> m Double
    -- ^ __Returns:__ The frequency /@self@/ generates. See audiotestsrc element.
testClipGetFrequency :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTestClip a) =>
a -> m Double
testClipGetFrequency a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr TestClip
self' <- a -> IO (Ptr TestClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr TestClip -> IO CDouble
ges_test_clip_get_frequency Ptr TestClip
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data TestClipGetFrequencyMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTestClip a) => O.OverloadedMethod TestClipGetFrequencyMethodInfo a signature where
    overloadedMethod = testClipGetFrequency

instance O.OverloadedMethodInfo TestClipGetFrequencyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.testClipGetFrequency",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#v:testClipGetFrequency"
        })


#endif

-- method TestClip::get_volume
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TestClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESTestClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "ges_test_clip_get_volume" ges_test_clip_get_volume :: 
    Ptr TestClip ->                         -- self : TInterface (Name {namespace = "GES", name = "TestClip"})
    IO CDouble

-- | Get the volume of the test audio signal applied on /@self@/.
testClipGetVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsTestClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TestClip.TestClip'
    -> m Double
    -- ^ __Returns:__ The volume of the test audio signal applied on /@self@/.
testClipGetVolume :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTestClip a) =>
a -> m Double
testClipGetVolume a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr TestClip
self' <- a -> IO (Ptr TestClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr TestClip -> IO CDouble
ges_test_clip_get_volume Ptr TestClip
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data TestClipGetVolumeMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTestClip a) => O.OverloadedMethod TestClipGetVolumeMethodInfo a signature where
    overloadedMethod = testClipGetVolume

instance O.OverloadedMethodInfo TestClipGetVolumeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.testClipGetVolume",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#v:testClipGetVolume"
        })


#endif

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

foreign import ccall "ges_test_clip_get_vpattern" ges_test_clip_get_vpattern :: 
    Ptr TestClip ->                         -- self : TInterface (Name {namespace = "GES", name = "TestClip"})
    IO CUInt

-- | Get the t'GI.GES.Enums.VideoTestPattern' which is applied on /@self@/.
testClipGetVpattern ::
    (B.CallStack.HasCallStack, MonadIO m, IsTestClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TestClip.TestClip'
    -> m GES.Enums.VideoTestPattern
    -- ^ __Returns:__ The t'GI.GES.Enums.VideoTestPattern' which is applied on /@self@/.
testClipGetVpattern :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTestClip a) =>
a -> m VideoTestPattern
testClipGetVpattern a
self = IO VideoTestPattern -> m VideoTestPattern
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoTestPattern -> m VideoTestPattern)
-> IO VideoTestPattern -> m VideoTestPattern
forall a b. (a -> b) -> a -> b
$ do
    Ptr TestClip
self' <- a -> IO (Ptr TestClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr TestClip -> IO CUInt
ges_test_clip_get_vpattern Ptr TestClip
self'
    let result' :: VideoTestPattern
result' = (Int -> VideoTestPattern
forall a. Enum a => Int -> a
toEnum (Int -> VideoTestPattern)
-> (CUInt -> Int) -> CUInt -> VideoTestPattern
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    VideoTestPattern -> IO VideoTestPattern
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoTestPattern
result'

#if defined(ENABLE_OVERLOADING)
data TestClipGetVpatternMethodInfo
instance (signature ~ (m GES.Enums.VideoTestPattern), MonadIO m, IsTestClip a) => O.OverloadedMethod TestClipGetVpatternMethodInfo a signature where
    overloadedMethod = testClipGetVpattern

instance O.OverloadedMethodInfo TestClipGetVpatternMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.testClipGetVpattern",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#v:testClipGetVpattern"
        })


#endif

-- method TestClip::is_muted
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TestClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESTestClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_test_clip_is_muted" ges_test_clip_is_muted :: 
    Ptr TestClip ->                         -- self : TInterface (Name {namespace = "GES", name = "TestClip"})
    IO CInt

-- | Let you know if the audio track of /@self@/ is muted or not.
testClipIsMuted ::
    (B.CallStack.HasCallStack, MonadIO m, IsTestClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TestClip.TestClip'
    -> m Bool
    -- ^ __Returns:__ Whether the audio track of /@self@/ is muted or not.
testClipIsMuted :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTestClip a) =>
a -> m Bool
testClipIsMuted a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TestClip
self' <- a -> IO (Ptr TestClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TestClip -> IO CInt
ges_test_clip_is_muted Ptr TestClip
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TestClipIsMutedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTestClip a) => O.OverloadedMethod TestClipIsMutedMethodInfo a signature where
    overloadedMethod = testClipIsMuted

instance O.OverloadedMethodInfo TestClipIsMutedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.testClipIsMuted",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#v:testClipIsMuted"
        })


#endif

-- method TestClip::set_frequency
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TestClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTestClip to set the frequency on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "freq"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the frequency you want to use on @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_test_clip_set_frequency" ges_test_clip_set_frequency :: 
    Ptr TestClip ->                         -- self : TInterface (Name {namespace = "GES", name = "TestClip"})
    CDouble ->                              -- freq : TBasicType TDouble
    IO ()

-- | Sets the frequency to generate. See audiotestsrc element.
testClipSetFrequency ::
    (B.CallStack.HasCallStack, MonadIO m, IsTestClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TestClip.TestClip' to set the frequency on
    -> Double
    -- ^ /@freq@/: the frequency you want to use on /@self@/
    -> m ()
testClipSetFrequency :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTestClip a) =>
a -> Double -> m ()
testClipSetFrequency a
self Double
freq = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TestClip
self' <- a -> IO (Ptr TestClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let freq' :: CDouble
freq' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
freq
    Ptr TestClip -> CDouble -> IO ()
ges_test_clip_set_frequency Ptr TestClip
self' CDouble
freq'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TestClipSetFrequencyMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTestClip a) => O.OverloadedMethod TestClipSetFrequencyMethodInfo a signature where
    overloadedMethod = testClipSetFrequency

instance O.OverloadedMethodInfo TestClipSetFrequencyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.testClipSetFrequency",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#v:testClipSetFrequency"
        })


#endif

-- method TestClip::set_mute
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TestClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GESTestClip on which to mute or unmute the audio track"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mute"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE to mute the audio track, %FALSE to unmute it"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_test_clip_set_mute" ges_test_clip_set_mute :: 
    Ptr TestClip ->                         -- self : TInterface (Name {namespace = "GES", name = "TestClip"})
    CInt ->                                 -- mute : TBasicType TBoolean
    IO ()

-- | Sets whether the audio track of this clip is muted or not.
testClipSetMute ::
    (B.CallStack.HasCallStack, MonadIO m, IsTestClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TestClip.TestClip' on which to mute or unmute the audio track
    -> Bool
    -- ^ /@mute@/: 'P.True' to mute the audio track, 'P.False' to unmute it
    -> m ()
testClipSetMute :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTestClip a) =>
a -> Bool -> m ()
testClipSetMute a
self Bool
mute = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TestClip
self' <- a -> IO (Ptr TestClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let mute' :: CInt
mute' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
mute
    Ptr TestClip -> CInt -> IO ()
ges_test_clip_set_mute Ptr TestClip
self' CInt
mute'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TestClipSetMuteMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTestClip a) => O.OverloadedMethod TestClipSetMuteMethodInfo a signature where
    overloadedMethod = testClipSetMute

instance O.OverloadedMethodInfo TestClipSetMuteMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.testClipSetMute",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#v:testClipSetMute"
        })


#endif

-- method TestClip::set_volume
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TestClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTestClip to set the volume on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "volume"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the volume of the audio signal you want to use on @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_test_clip_set_volume" ges_test_clip_set_volume :: 
    Ptr TestClip ->                         -- self : TInterface (Name {namespace = "GES", name = "TestClip"})
    CDouble ->                              -- volume : TBasicType TDouble
    IO ()

-- | Sets the volume of the test audio signal.
testClipSetVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsTestClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TestClip.TestClip' to set the volume on
    -> Double
    -- ^ /@volume@/: the volume of the audio signal you want to use on /@self@/
    -> m ()
testClipSetVolume :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTestClip a) =>
a -> Double -> m ()
testClipSetVolume a
self Double
volume = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TestClip
self' <- a -> IO (Ptr TestClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let volume' :: CDouble
volume' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
volume
    Ptr TestClip -> CDouble -> IO ()
ges_test_clip_set_volume Ptr TestClip
self' CDouble
volume'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TestClipSetVolumeMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTestClip a) => O.OverloadedMethod TestClipSetVolumeMethodInfo a signature where
    overloadedMethod = testClipSetVolume

instance O.OverloadedMethodInfo TestClipSetVolumeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.testClipSetVolume",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#v:testClipSetVolume"
        })


#endif

-- method TestClip::set_vpattern
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TestClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTestClip to set the pattern on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "vpattern"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "VideoTestPattern" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESVideoTestPattern to use on @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_test_clip_set_vpattern" ges_test_clip_set_vpattern :: 
    Ptr TestClip ->                         -- self : TInterface (Name {namespace = "GES", name = "TestClip"})
    CUInt ->                                -- vpattern : TInterface (Name {namespace = "GES", name = "VideoTestPattern"})
    IO ()

-- | Sets which video pattern to display on /@self@/.
testClipSetVpattern ::
    (B.CallStack.HasCallStack, MonadIO m, IsTestClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TestClip.TestClip' to set the pattern on
    -> GES.Enums.VideoTestPattern
    -- ^ /@vpattern@/: the t'GI.GES.Enums.VideoTestPattern' to use on /@self@/
    -> m ()
testClipSetVpattern :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTestClip a) =>
a -> VideoTestPattern -> m ()
testClipSetVpattern a
self VideoTestPattern
vpattern = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TestClip
self' <- a -> IO (Ptr TestClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let vpattern' :: CUInt
vpattern' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (VideoTestPattern -> Int) -> VideoTestPattern -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VideoTestPattern -> Int
forall a. Enum a => a -> Int
fromEnum) VideoTestPattern
vpattern
    Ptr TestClip -> CUInt -> IO ()
ges_test_clip_set_vpattern Ptr TestClip
self' CUInt
vpattern'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TestClipSetVpatternMethodInfo
instance (signature ~ (GES.Enums.VideoTestPattern -> m ()), MonadIO m, IsTestClip a) => O.OverloadedMethod TestClipSetVpatternMethodInfo a signature where
    overloadedMethod = testClipSetVpattern

instance O.OverloadedMethodInfo TestClipSetVpatternMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TestClip.testClipSetVpattern",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TestClip.html#v:testClipSetVpattern"
        })


#endif