{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.GES.Objects.TrackElement.TrackElement' is a t'GI.GES.Objects.TimelineElement.TimelineElement' that specifically belongs
-- to a single t'GI.GES.Objects.Track.Track' of its [TimelineElement:timeline]("GI.GES.Objects.TimelineElement#g:attr:timeline"). Its
-- [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") and [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") specify its
-- temporal extent in the track. Specifically, a track element wraps some
-- nleobject, such as an @/nlesource/@ or @/nleoperation/@, which can be
-- retrieved with 'GI.GES.Objects.TrackElement.trackElementGetNleobject', and its
-- [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start"), [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration"),
-- [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint"), [TimelineElement:priority]("GI.GES.Objects.TimelineElement#g:attr:priority") and
-- [TrackElement:active]("GI.GES.Objects.TrackElement#g:attr:active") properties expose the corresponding nleobject
-- properties. When a track element is added to a track, its nleobject is
-- added to the corresponding @/nlecomposition/@ that the track wraps.
-- 
-- Most users will not have to work directly with track elements since a
-- t'GI.GES.Objects.Clip.Clip' will automatically create track elements for its timeline\'s
-- tracks and take responsibility for updating them. The only track
-- elements that are not automatically created by clips, but a user is
-- likely to want to create, are t'GI.GES.Objects.Effect.Effect'-s.
-- 
-- == Control Bindings for Children Properties
-- 
-- You can set up control bindings for a track element child property
-- using 'GI.GES.Objects.TrackElement.trackElementSetControlSource'. A
-- @/GstTimedValueControlSource/@ should specify the timed values using the
-- internal source coordinates (see t'GI.GES.Objects.TimelineElement.TimelineElement'). By default,
-- these will be updated to lie between the [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint")
-- and out-point of the element. This can be switched off by setting
-- [TrackElement:autoClampControlSources]("GI.GES.Objects.TrackElement#g:attr:autoClampControlSources") to 'P.False'.

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

module GI.GES.Objects.TrackElement
    ( 
#if defined(ENABLE_OVERLOADING)
    TrackElementGetAllControlBindingsMethodInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    TrackElementListChildrenPropertiesMethodInfo,
#endif

-- * Exported types
    TrackElement(..)                        ,
    IsTrackElement                          ,
    toTrackElement                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addChildProperty]("GI.GES.Objects.TimelineElement#g:method:addChildProperty"), [addChildrenProps]("GI.GES.Objects.TrackElement#g:method:addChildrenProps"), [addMetasFromString]("GI.GES.Interfaces.MetaContainer#g:method:addMetasFromString"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [checkMetaRegistered]("GI.GES.Interfaces.MetaContainer#g:method:checkMetaRegistered"), [clampControlSource]("GI.GES.Objects.TrackElement#g:method:clampControlSource"), [copy]("GI.GES.Objects.TimelineElement#g:method:copy"), [edit]("GI.GES.Objects.TrackElement#g:method:edit"), [editFull]("GI.GES.Objects.TimelineElement#g:method:editFull"), [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"), [hasInternalSource]("GI.GES.Objects.TrackElement#g:method:hasInternalSource"), [isActive]("GI.GES.Objects.TrackElement#g:method:isActive"), [isCore]("GI.GES.Objects.TrackElement#g:method:isCore"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [listChildrenProperties]("GI.GES.Objects.TrackElement#g:method:listChildrenProperties"), [lookupChild]("GI.GES.Objects.TrackElement#g:method:lookupChild"), [metasToString]("GI.GES.Interfaces.MetaContainer#g:method:metasToString"), [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"), [removeChildProperty]("GI.GES.Objects.TimelineElement#g:method:removeChildProperty"), [removeControlBinding]("GI.GES.Objects.TrackElement#g:method:removeControlBinding"), [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"), [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"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAllControlBindings]("GI.GES.Objects.TrackElement#g:method:getAllControlBindings"), [getAsset]("GI.GES.Interfaces.Extractable#g:method:getAsset"), [getAutoClampControlSources]("GI.GES.Objects.TrackElement#g:method:getAutoClampControlSources"), [getBoolean]("GI.GES.Interfaces.MetaContainer#g:method:getBoolean"), [getChildProperty]("GI.GES.Objects.TimelineElement#g:method:getChildProperty"), [getChildPropertyByPspec]("GI.GES.Objects.TimelineElement#g:method:getChildPropertyByPspec"), [getControlBinding]("GI.GES.Objects.TrackElement#g:method:getControlBinding"), [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"), [getElement]("GI.GES.Objects.TrackElement#g:method:getElement"), [getFloat]("GI.GES.Interfaces.MetaContainer#g:method:getFloat"), [getGnlobject]("GI.GES.Objects.TrackElement#g:method:getGnlobject"), [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"), [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"), [getNleobject]("GI.GES.Objects.TrackElement#g:method:getNleobject"), [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"), [getTimeline]("GI.GES.Objects.TimelineElement#g:method:getTimeline"), [getToplevelParent]("GI.GES.Objects.TimelineElement#g:method:getToplevelParent"), [getTrack]("GI.GES.Objects.TrackElement#g:method:getTrack"), [getTrackType]("GI.GES.Objects.TrackElement#g:method:getTrackType"), [getTrackTypes]("GI.GES.Objects.TimelineElement#g:method:getTrackTypes"), [getUint]("GI.GES.Interfaces.MetaContainer#g:method:getUint"), [getUint64]("GI.GES.Interfaces.MetaContainer#g:method:getUint64").
-- 
-- ==== Setters
-- [setActive]("GI.GES.Objects.TrackElement#g:method:setActive"), [setAsset]("GI.GES.Interfaces.Extractable#g:method:setAsset"), [setAutoClampControlSources]("GI.GES.Objects.TrackElement#g:method:setAutoClampControlSources"), [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"), [setControlSource]("GI.GES.Objects.TrackElement#g:method:setControlSource"), [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"), [setHasInternalSource]("GI.GES.Objects.TrackElement#g:method:setHasInternalSource"), [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"), [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"), [setTimeline]("GI.GES.Objects.TimelineElement#g:method:setTimeline"), [setTrackType]("GI.GES.Objects.TrackElement#g:method:setTrackType"), [setUint]("GI.GES.Interfaces.MetaContainer#g:method:setUint"), [setUint64]("GI.GES.Interfaces.MetaContainer#g:method:setUint64").

#if defined(ENABLE_OVERLOADING)
    ResolveTrackElementMethod               ,
#endif

-- ** addChildrenProps #method:addChildrenProps#

#if defined(ENABLE_OVERLOADING)
    TrackElementAddChildrenPropsMethodInfo  ,
#endif
    trackElementAddChildrenProps            ,


-- ** clampControlSource #method:clampControlSource#

#if defined(ENABLE_OVERLOADING)
    TrackElementClampControlSourceMethodInfo,
#endif
    trackElementClampControlSource          ,


-- ** edit #method:edit#

#if defined(ENABLE_OVERLOADING)
    TrackElementEditMethodInfo              ,
#endif
    trackElementEdit                        ,


-- ** getAutoClampControlSources #method:getAutoClampControlSources#

#if defined(ENABLE_OVERLOADING)
    TrackElementGetAutoClampControlSourcesMethodInfo,
#endif
    trackElementGetAutoClampControlSources  ,


-- ** getControlBinding #method:getControlBinding#

#if defined(ENABLE_OVERLOADING)
    TrackElementGetControlBindingMethodInfo ,
#endif
    trackElementGetControlBinding           ,


-- ** getElement #method:getElement#

#if defined(ENABLE_OVERLOADING)
    TrackElementGetElementMethodInfo        ,
#endif
    trackElementGetElement                  ,


-- ** getGnlobject #method:getGnlobject#

#if defined(ENABLE_OVERLOADING)
    TrackElementGetGnlobjectMethodInfo      ,
#endif
    trackElementGetGnlobject                ,


-- ** getNleobject #method:getNleobject#

#if defined(ENABLE_OVERLOADING)
    TrackElementGetNleobjectMethodInfo      ,
#endif
    trackElementGetNleobject                ,


-- ** getTrack #method:getTrack#

#if defined(ENABLE_OVERLOADING)
    TrackElementGetTrackMethodInfo          ,
#endif
    trackElementGetTrack                    ,


-- ** getTrackType #method:getTrackType#

#if defined(ENABLE_OVERLOADING)
    TrackElementGetTrackTypeMethodInfo      ,
#endif
    trackElementGetTrackType                ,


-- ** hasInternalSource #method:hasInternalSource#

#if defined(ENABLE_OVERLOADING)
    TrackElementHasInternalSourceMethodInfo ,
#endif
    trackElementHasInternalSource           ,


-- ** isActive #method:isActive#

#if defined(ENABLE_OVERLOADING)
    TrackElementIsActiveMethodInfo          ,
#endif
    trackElementIsActive                    ,


-- ** isCore #method:isCore#

#if defined(ENABLE_OVERLOADING)
    TrackElementIsCoreMethodInfo            ,
#endif
    trackElementIsCore                      ,


-- ** lookupChild #method:lookupChild#

#if defined(ENABLE_OVERLOADING)
    TrackElementLookupChildMethodInfo       ,
#endif
    trackElementLookupChild                 ,


-- ** removeControlBinding #method:removeControlBinding#

#if defined(ENABLE_OVERLOADING)
    TrackElementRemoveControlBindingMethodInfo,
#endif
    trackElementRemoveControlBinding        ,


-- ** setActive #method:setActive#

#if defined(ENABLE_OVERLOADING)
    TrackElementSetActiveMethodInfo         ,
#endif
    trackElementSetActive                   ,


-- ** setAutoClampControlSources #method:setAutoClampControlSources#

#if defined(ENABLE_OVERLOADING)
    TrackElementSetAutoClampControlSourcesMethodInfo,
#endif
    trackElementSetAutoClampControlSources  ,


-- ** setControlSource #method:setControlSource#

#if defined(ENABLE_OVERLOADING)
    TrackElementSetControlSourceMethodInfo  ,
#endif
    trackElementSetControlSource            ,


-- ** setHasInternalSource #method:setHasInternalSource#

#if defined(ENABLE_OVERLOADING)
    TrackElementSetHasInternalSourceMethodInfo,
#endif
    trackElementSetHasInternalSource        ,


-- ** setTrackType #method:setTrackType#

#if defined(ENABLE_OVERLOADING)
    TrackElementSetTrackTypeMethodInfo      ,
#endif
    trackElementSetTrackType                ,




 -- * Properties


-- ** active #attr:active#
-- | Whether the effect of the element should be applied in its
-- [TrackElement:track]("GI.GES.Objects.TrackElement#g:attr:track"). If set to 'P.False', it will not be used in
-- the output of the track.

#if defined(ENABLE_OVERLOADING)
    TrackElementActivePropertyInfo          ,
#endif
    constructTrackElementActive             ,
    getTrackElementActive                   ,
    setTrackElementActive                   ,
#if defined(ENABLE_OVERLOADING)
    trackElementActive                      ,
#endif


-- ** autoClampControlSources #attr:autoClampControlSources#
-- | Whether the control sources on the element (see
-- 'GI.GES.Objects.TrackElement.trackElementSetControlSource') will be automatically
-- updated whenever the [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") or out-point of the
-- element change in value.
-- 
-- See 'GI.GES.Objects.TrackElement.trackElementClampControlSource' for how this is done
-- per control source.
-- 
-- Default value: 'P.True'
-- 
-- /Since: 1.18/

#if defined(ENABLE_OVERLOADING)
    TrackElementAutoClampControlSourcesPropertyInfo,
#endif
    constructTrackElementAutoClampControlSources,
    getTrackElementAutoClampControlSources  ,
    setTrackElementAutoClampControlSources  ,
#if defined(ENABLE_OVERLOADING)
    trackElementAutoClampControlSources     ,
#endif


-- ** hasInternalSource #attr:hasInternalSource#
-- | This property is used to determine whether the \'internal time\'
-- properties of the element have any meaning. In particular, unless
-- this is set to 'P.True', the [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") and
-- [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") can not be set to any value other
-- than the default 0 and 'GI.Gst.Constants.CLOCK_TIME_NONE', respectively.
-- 
-- If an element has some *internal* *timed* source t'GI.Gst.Objects.Element.Element' that it
-- reads stream data from as part of its function in a t'GI.GES.Objects.Track.Track', then
-- you\'ll likely want to set this to 'P.True' to allow the
-- [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") and [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") to
-- be set.
-- 
-- The default value is determined by the t'GI.GES.Structs.TrackElementClass.TrackElementClass'
-- /@defaultHasInternalSource@/ class property. For most
-- t'GI.GES.Structs.SourceClass.SourceClass'-es, this will be 'P.True', with the exception of those
-- that have a potentially *static* source, such as t'GI.GES.Structs.ImageSourceClass.ImageSourceClass'
-- and t'GI.GES.Structs.TitleSourceClass.TitleSourceClass'. Otherwise, this will usually be 'P.False'.
-- 
-- For most t'GI.GES.Objects.Operation.Operation'-s you will likely want to leave this set to
-- 'P.False'. The exception may be for an operation that reads some stream
-- data from some private internal source as part of manipulating the
-- input data from the usual linked upstream t'GI.GES.Objects.TrackElement.TrackElement'.
-- 
-- For example, you may want to set this to 'P.True' for a
-- @/GES_TRACK_TYPE_VIDEO/@ operation that wraps a @/textoverlay/@ that reads
-- from a subtitle file and places its text on top of the received video
-- data. The [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") of the element would be used
-- to shift the initial seek time on the @/textoverlay/@ away from 0, and
-- the [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") could be set to reflect the
-- time at which the subtitle file runs out of data.
-- 
-- Note that GES can not support track elements that have both internal
-- content and manipulate the timing of their data streams (time
-- effects).
-- 
-- /Since: 1.18/

#if defined(ENABLE_OVERLOADING)
    TrackElementHasInternalSourcePropertyInfo,
#endif
    constructTrackElementHasInternalSource  ,
    getTrackElementHasInternalSource        ,
    setTrackElementHasInternalSource        ,


-- ** track #attr:track#
-- | The track that this element belongs to, or 'P.Nothing' if it does not
-- belong to a track.

#if defined(ENABLE_OVERLOADING)
    TrackElementTrackPropertyInfo           ,
#endif
    getTrackElementTrack                    ,
#if defined(ENABLE_OVERLOADING)
    trackElementTrack                       ,
#endif


-- ** trackType #attr:trackType#
-- | The track type of the element, which determines the type of track the
-- element can be added to (see [Track:trackType]("GI.GES.Objects.Track#g:attr:trackType")). This should
-- correspond to the type of data that the element can produce or
-- process.

#if defined(ENABLE_OVERLOADING)
    TrackElementTrackTypePropertyInfo       ,
#endif
    constructTrackElementTrackType          ,
    getTrackElementTrackType                ,
    setTrackElementTrackType                ,
#if defined(ENABLE_OVERLOADING)
    trackElementTrackType                   ,
#endif




 -- * Signals


-- ** controlBindingAdded #signal:controlBindingAdded#

    TrackElementControlBindingAddedCallback ,
#if defined(ENABLE_OVERLOADING)
    TrackElementControlBindingAddedSignalInfo,
#endif
    afterTrackElementControlBindingAdded    ,
    onTrackElementControlBindingAdded       ,


-- ** controlBindingRemoved #signal:controlBindingRemoved#

    TrackElementControlBindingRemovedCallback,
#if defined(ENABLE_OVERLOADING)
    TrackElementControlBindingRemovedSignalInfo,
#endif
    afterTrackElementControlBindingRemoved  ,
    onTrackElementControlBindingRemoved     ,




    ) 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.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.Flags as GES.Flags
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.Layer as GES.Layer
import {-# SOURCE #-} qualified GI.GES.Objects.TimelineElement as GES.TimelineElement
import {-# SOURCE #-} qualified GI.GES.Objects.Track as GES.Track
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Objects.ControlBinding as Gst.ControlBinding
import qualified GI.Gst.Objects.ControlSource as Gst.ControlSource
import qualified GI.Gst.Objects.Element as Gst.Element

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

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

foreign import ccall "ges_track_element_get_type"
    c_ges_track_element_get_type :: IO B.Types.GType

instance B.Types.TypedObject TrackElement where
    glibType :: IO GType
glibType = IO GType
c_ges_track_element_get_type

instance B.Types.GObject TrackElement

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

instance O.HasParentTypes TrackElement
type instance O.ParentTypes TrackElement = '[GES.TimelineElement.TimelineElement, GObject.Object.Object, GES.Extractable.Extractable, GES.MetaContainer.MetaContainer]

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

-- | Convert 'TrackElement' 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 TrackElement) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ges_track_element_get_type
    gvalueSet_ :: Ptr GValue -> Maybe TrackElement -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TrackElement
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr TrackElement)
    gvalueSet_ Ptr GValue
gv (P.Just TrackElement
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TrackElement
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe TrackElement)
gvalueGet_ Ptr GValue
gv = do
        Ptr TrackElement
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TrackElement)
        if Ptr TrackElement
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
        then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TrackElement -> TrackElement
TrackElement Ptr TrackElement
ptr
        else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveTrackElementMethod (t :: Symbol) (o :: *) :: * where
    ResolveTrackElementMethod "addChildProperty" o = GES.TimelineElement.TimelineElementAddChildPropertyMethodInfo
    ResolveTrackElementMethod "addChildrenProps" o = TrackElementAddChildrenPropsMethodInfo
    ResolveTrackElementMethod "addMetasFromString" o = GES.MetaContainer.MetaContainerAddMetasFromStringMethodInfo
    ResolveTrackElementMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTrackElementMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTrackElementMethod "checkMetaRegistered" o = GES.MetaContainer.MetaContainerCheckMetaRegisteredMethodInfo
    ResolveTrackElementMethod "clampControlSource" o = TrackElementClampControlSourceMethodInfo
    ResolveTrackElementMethod "copy" o = GES.TimelineElement.TimelineElementCopyMethodInfo
    ResolveTrackElementMethod "edit" o = TrackElementEditMethodInfo
    ResolveTrackElementMethod "editFull" o = GES.TimelineElement.TimelineElementEditFullMethodInfo
    ResolveTrackElementMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTrackElementMethod "foreach" o = GES.MetaContainer.MetaContainerForeachMethodInfo
    ResolveTrackElementMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTrackElementMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTrackElementMethod "hasInternalSource" o = TrackElementHasInternalSourceMethodInfo
    ResolveTrackElementMethod "isActive" o = TrackElementIsActiveMethodInfo
    ResolveTrackElementMethod "isCore" o = TrackElementIsCoreMethodInfo
    ResolveTrackElementMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTrackElementMethod "listChildrenProperties" o = TrackElementListChildrenPropertiesMethodInfo
    ResolveTrackElementMethod "lookupChild" o = TrackElementLookupChildMethodInfo
    ResolveTrackElementMethod "metasToString" o = GES.MetaContainer.MetaContainerMetasToStringMethodInfo
    ResolveTrackElementMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTrackElementMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTrackElementMethod "paste" o = GES.TimelineElement.TimelineElementPasteMethodInfo
    ResolveTrackElementMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTrackElementMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTrackElementMethod "registerMeta" o = GES.MetaContainer.MetaContainerRegisterMetaMethodInfo
    ResolveTrackElementMethod "registerMetaBoolean" o = GES.MetaContainer.MetaContainerRegisterMetaBooleanMethodInfo
    ResolveTrackElementMethod "registerMetaDate" o = GES.MetaContainer.MetaContainerRegisterMetaDateMethodInfo
    ResolveTrackElementMethod "registerMetaDateTime" o = GES.MetaContainer.MetaContainerRegisterMetaDateTimeMethodInfo
    ResolveTrackElementMethod "registerMetaDouble" o = GES.MetaContainer.MetaContainerRegisterMetaDoubleMethodInfo
    ResolveTrackElementMethod "registerMetaFloat" o = GES.MetaContainer.MetaContainerRegisterMetaFloatMethodInfo
    ResolveTrackElementMethod "registerMetaInt" o = GES.MetaContainer.MetaContainerRegisterMetaIntMethodInfo
    ResolveTrackElementMethod "registerMetaInt64" o = GES.MetaContainer.MetaContainerRegisterMetaInt64MethodInfo
    ResolveTrackElementMethod "registerMetaString" o = GES.MetaContainer.MetaContainerRegisterMetaStringMethodInfo
    ResolveTrackElementMethod "registerMetaUint" o = GES.MetaContainer.MetaContainerRegisterMetaUintMethodInfo
    ResolveTrackElementMethod "registerMetaUint64" o = GES.MetaContainer.MetaContainerRegisterMetaUint64MethodInfo
    ResolveTrackElementMethod "registerStaticMeta" o = GES.MetaContainer.MetaContainerRegisterStaticMetaMethodInfo
    ResolveTrackElementMethod "removeChildProperty" o = GES.TimelineElement.TimelineElementRemoveChildPropertyMethodInfo
    ResolveTrackElementMethod "removeControlBinding" o = TrackElementRemoveControlBindingMethodInfo
    ResolveTrackElementMethod "ripple" o = GES.TimelineElement.TimelineElementRippleMethodInfo
    ResolveTrackElementMethod "rippleEnd" o = GES.TimelineElement.TimelineElementRippleEndMethodInfo
    ResolveTrackElementMethod "rollEnd" o = GES.TimelineElement.TimelineElementRollEndMethodInfo
    ResolveTrackElementMethod "rollStart" o = GES.TimelineElement.TimelineElementRollStartMethodInfo
    ResolveTrackElementMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTrackElementMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTrackElementMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTrackElementMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTrackElementMethod "trim" o = GES.TimelineElement.TimelineElementTrimMethodInfo
    ResolveTrackElementMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTrackElementMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTrackElementMethod "getAllControlBindings" o = TrackElementGetAllControlBindingsMethodInfo
    ResolveTrackElementMethod "getAsset" o = GES.Extractable.ExtractableGetAssetMethodInfo
    ResolveTrackElementMethod "getAutoClampControlSources" o = TrackElementGetAutoClampControlSourcesMethodInfo
    ResolveTrackElementMethod "getBoolean" o = GES.MetaContainer.MetaContainerGetBooleanMethodInfo
    ResolveTrackElementMethod "getChildProperty" o = GES.TimelineElement.TimelineElementGetChildPropertyMethodInfo
    ResolveTrackElementMethod "getChildPropertyByPspec" o = GES.TimelineElement.TimelineElementGetChildPropertyByPspecMethodInfo
    ResolveTrackElementMethod "getControlBinding" o = TrackElementGetControlBindingMethodInfo
    ResolveTrackElementMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTrackElementMethod "getDate" o = GES.MetaContainer.MetaContainerGetDateMethodInfo
    ResolveTrackElementMethod "getDateTime" o = GES.MetaContainer.MetaContainerGetDateTimeMethodInfo
    ResolveTrackElementMethod "getDouble" o = GES.MetaContainer.MetaContainerGetDoubleMethodInfo
    ResolveTrackElementMethod "getDuration" o = GES.TimelineElement.TimelineElementGetDurationMethodInfo
    ResolveTrackElementMethod "getElement" o = TrackElementGetElementMethodInfo
    ResolveTrackElementMethod "getFloat" o = GES.MetaContainer.MetaContainerGetFloatMethodInfo
    ResolveTrackElementMethod "getGnlobject" o = TrackElementGetGnlobjectMethodInfo
    ResolveTrackElementMethod "getId" o = GES.Extractable.ExtractableGetIdMethodInfo
    ResolveTrackElementMethod "getInpoint" o = GES.TimelineElement.TimelineElementGetInpointMethodInfo
    ResolveTrackElementMethod "getInt" o = GES.MetaContainer.MetaContainerGetIntMethodInfo
    ResolveTrackElementMethod "getInt64" o = GES.MetaContainer.MetaContainerGetInt64MethodInfo
    ResolveTrackElementMethod "getLayerPriority" o = GES.TimelineElement.TimelineElementGetLayerPriorityMethodInfo
    ResolveTrackElementMethod "getMarkerList" o = GES.MetaContainer.MetaContainerGetMarkerListMethodInfo
    ResolveTrackElementMethod "getMaxDuration" o = GES.TimelineElement.TimelineElementGetMaxDurationMethodInfo
    ResolveTrackElementMethod "getMeta" o = GES.MetaContainer.MetaContainerGetMetaMethodInfo
    ResolveTrackElementMethod "getName" o = GES.TimelineElement.TimelineElementGetNameMethodInfo
    ResolveTrackElementMethod "getNaturalFramerate" o = GES.TimelineElement.TimelineElementGetNaturalFramerateMethodInfo
    ResolveTrackElementMethod "getNleobject" o = TrackElementGetNleobjectMethodInfo
    ResolveTrackElementMethod "getParent" o = GES.TimelineElement.TimelineElementGetParentMethodInfo
    ResolveTrackElementMethod "getPriority" o = GES.TimelineElement.TimelineElementGetPriorityMethodInfo
    ResolveTrackElementMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTrackElementMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTrackElementMethod "getStart" o = GES.TimelineElement.TimelineElementGetStartMethodInfo
    ResolveTrackElementMethod "getString" o = GES.MetaContainer.MetaContainerGetStringMethodInfo
    ResolveTrackElementMethod "getTimeline" o = GES.TimelineElement.TimelineElementGetTimelineMethodInfo
    ResolveTrackElementMethod "getToplevelParent" o = GES.TimelineElement.TimelineElementGetToplevelParentMethodInfo
    ResolveTrackElementMethod "getTrack" o = TrackElementGetTrackMethodInfo
    ResolveTrackElementMethod "getTrackType" o = TrackElementGetTrackTypeMethodInfo
    ResolveTrackElementMethod "getTrackTypes" o = GES.TimelineElement.TimelineElementGetTrackTypesMethodInfo
    ResolveTrackElementMethod "getUint" o = GES.MetaContainer.MetaContainerGetUintMethodInfo
    ResolveTrackElementMethod "getUint64" o = GES.MetaContainer.MetaContainerGetUint64MethodInfo
    ResolveTrackElementMethod "setActive" o = TrackElementSetActiveMethodInfo
    ResolveTrackElementMethod "setAsset" o = GES.Extractable.ExtractableSetAssetMethodInfo
    ResolveTrackElementMethod "setAutoClampControlSources" o = TrackElementSetAutoClampControlSourcesMethodInfo
    ResolveTrackElementMethod "setBoolean" o = GES.MetaContainer.MetaContainerSetBooleanMethodInfo
    ResolveTrackElementMethod "setChildProperty" o = GES.TimelineElement.TimelineElementSetChildPropertyMethodInfo
    ResolveTrackElementMethod "setChildPropertyByPspec" o = GES.TimelineElement.TimelineElementSetChildPropertyByPspecMethodInfo
    ResolveTrackElementMethod "setChildPropertyFull" o = GES.TimelineElement.TimelineElementSetChildPropertyFullMethodInfo
    ResolveTrackElementMethod "setControlSource" o = TrackElementSetControlSourceMethodInfo
    ResolveTrackElementMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTrackElementMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTrackElementMethod "setDate" o = GES.MetaContainer.MetaContainerSetDateMethodInfo
    ResolveTrackElementMethod "setDateTime" o = GES.MetaContainer.MetaContainerSetDateTimeMethodInfo
    ResolveTrackElementMethod "setDouble" o = GES.MetaContainer.MetaContainerSetDoubleMethodInfo
    ResolveTrackElementMethod "setDuration" o = GES.TimelineElement.TimelineElementSetDurationMethodInfo
    ResolveTrackElementMethod "setFloat" o = GES.MetaContainer.MetaContainerSetFloatMethodInfo
    ResolveTrackElementMethod "setHasInternalSource" o = TrackElementSetHasInternalSourceMethodInfo
    ResolveTrackElementMethod "setInpoint" o = GES.TimelineElement.TimelineElementSetInpointMethodInfo
    ResolveTrackElementMethod "setInt" o = GES.MetaContainer.MetaContainerSetIntMethodInfo
    ResolveTrackElementMethod "setInt64" o = GES.MetaContainer.MetaContainerSetInt64MethodInfo
    ResolveTrackElementMethod "setMarkerList" o = GES.MetaContainer.MetaContainerSetMarkerListMethodInfo
    ResolveTrackElementMethod "setMaxDuration" o = GES.TimelineElement.TimelineElementSetMaxDurationMethodInfo
    ResolveTrackElementMethod "setMeta" o = GES.MetaContainer.MetaContainerSetMetaMethodInfo
    ResolveTrackElementMethod "setName" o = GES.TimelineElement.TimelineElementSetNameMethodInfo
    ResolveTrackElementMethod "setParent" o = GES.TimelineElement.TimelineElementSetParentMethodInfo
    ResolveTrackElementMethod "setPriority" o = GES.TimelineElement.TimelineElementSetPriorityMethodInfo
    ResolveTrackElementMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTrackElementMethod "setStart" o = GES.TimelineElement.TimelineElementSetStartMethodInfo
    ResolveTrackElementMethod "setString" o = GES.MetaContainer.MetaContainerSetStringMethodInfo
    ResolveTrackElementMethod "setTimeline" o = GES.TimelineElement.TimelineElementSetTimelineMethodInfo
    ResolveTrackElementMethod "setTrackType" o = TrackElementSetTrackTypeMethodInfo
    ResolveTrackElementMethod "setUint" o = GES.MetaContainer.MetaContainerSetUintMethodInfo
    ResolveTrackElementMethod "setUint64" o = GES.MetaContainer.MetaContainerSetUint64MethodInfo
    ResolveTrackElementMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveTrackElementMethod t TrackElement, O.OverloadedMethod info TrackElement p) => OL.IsLabel t (TrackElement -> 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 ~ ResolveTrackElementMethod t TrackElement, O.OverloadedMethod info TrackElement p, R.HasField t TrackElement p) => R.HasField t TrackElement p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- signal TrackElement::control-binding-added
-- | This is emitted when a control binding is added to a child property
-- of the track element.
type TrackElementControlBindingAddedCallback =
    Gst.ControlBinding.ControlBinding
    -- ^ /@controlBinding@/: The control binding that has been added
    -> IO ()

type C_TrackElementControlBindingAddedCallback =
    Ptr TrackElement ->                     -- object
    Ptr Gst.ControlBinding.ControlBinding ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TrackElementControlBindingAddedCallback`.
foreign import ccall "wrapper"
    mk_TrackElementControlBindingAddedCallback :: C_TrackElementControlBindingAddedCallback -> IO (FunPtr C_TrackElementControlBindingAddedCallback)

wrap_TrackElementControlBindingAddedCallback :: 
    GObject a => (a -> TrackElementControlBindingAddedCallback) ->
    C_TrackElementControlBindingAddedCallback
wrap_TrackElementControlBindingAddedCallback :: forall a.
GObject a =>
(a -> TrackElementControlBindingAddedCallback)
-> C_TrackElementControlBindingAddedCallback
wrap_TrackElementControlBindingAddedCallback a -> TrackElementControlBindingAddedCallback
gi'cb Ptr TrackElement
gi'selfPtr Ptr ControlBinding
controlBinding Ptr ()
_ = do
    ControlBinding
controlBinding' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ControlBinding -> ControlBinding
Gst.ControlBinding.ControlBinding) Ptr ControlBinding
controlBinding
    forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TrackElement
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \TrackElement
gi'self -> a -> TrackElementControlBindingAddedCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce TrackElement
gi'self)  ControlBinding
controlBinding'


-- | Connect a signal handler for the [controlBindingAdded](#signal:controlBindingAdded) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' trackElement #controlBindingAdded callback
-- @
-- 
-- 
onTrackElementControlBindingAdded :: (IsTrackElement a, MonadIO m) => a -> ((?self :: a) => TrackElementControlBindingAddedCallback) -> m SignalHandlerId
onTrackElementControlBindingAdded :: forall a (m :: * -> *).
(IsTrackElement a, MonadIO m) =>
a
-> ((?self::a) => TrackElementControlBindingAddedCallback)
-> m SignalHandlerId
onTrackElementControlBindingAdded a
obj (?self::a) => TrackElementControlBindingAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TrackElementControlBindingAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TrackElementControlBindingAddedCallback
cb
    let wrapped' :: C_TrackElementControlBindingAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TrackElementControlBindingAddedCallback)
-> C_TrackElementControlBindingAddedCallback
wrap_TrackElementControlBindingAddedCallback a -> TrackElementControlBindingAddedCallback
wrapped
    FunPtr C_TrackElementControlBindingAddedCallback
wrapped'' <- C_TrackElementControlBindingAddedCallback
-> IO (FunPtr C_TrackElementControlBindingAddedCallback)
mk_TrackElementControlBindingAddedCallback C_TrackElementControlBindingAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"control-binding-added" FunPtr C_TrackElementControlBindingAddedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing

-- | Connect a signal handler for the [controlBindingAdded](#signal:controlBindingAdded) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' trackElement #controlBindingAdded callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTrackElementControlBindingAdded :: (IsTrackElement a, MonadIO m) => a -> ((?self :: a) => TrackElementControlBindingAddedCallback) -> m SignalHandlerId
afterTrackElementControlBindingAdded :: forall a (m :: * -> *).
(IsTrackElement a, MonadIO m) =>
a
-> ((?self::a) => TrackElementControlBindingAddedCallback)
-> m SignalHandlerId
afterTrackElementControlBindingAdded a
obj (?self::a) => TrackElementControlBindingAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TrackElementControlBindingAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TrackElementControlBindingAddedCallback
cb
    let wrapped' :: C_TrackElementControlBindingAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TrackElementControlBindingAddedCallback)
-> C_TrackElementControlBindingAddedCallback
wrap_TrackElementControlBindingAddedCallback a -> TrackElementControlBindingAddedCallback
wrapped
    FunPtr C_TrackElementControlBindingAddedCallback
wrapped'' <- C_TrackElementControlBindingAddedCallback
-> IO (FunPtr C_TrackElementControlBindingAddedCallback)
mk_TrackElementControlBindingAddedCallback C_TrackElementControlBindingAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"control-binding-added" FunPtr C_TrackElementControlBindingAddedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TrackElementControlBindingAddedSignalInfo
instance SignalInfo TrackElementControlBindingAddedSignalInfo where
    type HaskellCallbackType TrackElementControlBindingAddedSignalInfo = TrackElementControlBindingAddedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TrackElementControlBindingAddedCallback cb
        cb'' <- mk_TrackElementControlBindingAddedCallback cb'
        connectSignalFunPtr obj "control-binding-added" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TrackElement::control-binding-added"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TrackElement.html#g:signal:controlBindingAdded"})

#endif

-- signal TrackElement::control-binding-removed
-- | This is emitted when a control binding is removed from a child
-- property of the track element.
type TrackElementControlBindingRemovedCallback =
    Gst.ControlBinding.ControlBinding
    -- ^ /@controlBinding@/: The control binding that has been removed
    -> IO ()

type C_TrackElementControlBindingRemovedCallback =
    Ptr TrackElement ->                     -- object
    Ptr Gst.ControlBinding.ControlBinding ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TrackElementControlBindingRemovedCallback`.
foreign import ccall "wrapper"
    mk_TrackElementControlBindingRemovedCallback :: C_TrackElementControlBindingRemovedCallback -> IO (FunPtr C_TrackElementControlBindingRemovedCallback)

wrap_TrackElementControlBindingRemovedCallback :: 
    GObject a => (a -> TrackElementControlBindingRemovedCallback) ->
    C_TrackElementControlBindingRemovedCallback
wrap_TrackElementControlBindingRemovedCallback :: forall a.
GObject a =>
(a -> TrackElementControlBindingAddedCallback)
-> C_TrackElementControlBindingAddedCallback
wrap_TrackElementControlBindingRemovedCallback a -> TrackElementControlBindingAddedCallback
gi'cb Ptr TrackElement
gi'selfPtr Ptr ControlBinding
controlBinding Ptr ()
_ = do
    ControlBinding
controlBinding' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ControlBinding -> ControlBinding
Gst.ControlBinding.ControlBinding) Ptr ControlBinding
controlBinding
    forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TrackElement
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \TrackElement
gi'self -> a -> TrackElementControlBindingAddedCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce TrackElement
gi'self)  ControlBinding
controlBinding'


-- | Connect a signal handler for the [controlBindingRemoved](#signal:controlBindingRemoved) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' trackElement #controlBindingRemoved callback
-- @
-- 
-- 
onTrackElementControlBindingRemoved :: (IsTrackElement a, MonadIO m) => a -> ((?self :: a) => TrackElementControlBindingRemovedCallback) -> m SignalHandlerId
onTrackElementControlBindingRemoved :: forall a (m :: * -> *).
(IsTrackElement a, MonadIO m) =>
a
-> ((?self::a) => TrackElementControlBindingAddedCallback)
-> m SignalHandlerId
onTrackElementControlBindingRemoved a
obj (?self::a) => TrackElementControlBindingAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TrackElementControlBindingAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TrackElementControlBindingAddedCallback
cb
    let wrapped' :: C_TrackElementControlBindingAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TrackElementControlBindingAddedCallback)
-> C_TrackElementControlBindingAddedCallback
wrap_TrackElementControlBindingRemovedCallback a -> TrackElementControlBindingAddedCallback
wrapped
    FunPtr C_TrackElementControlBindingAddedCallback
wrapped'' <- C_TrackElementControlBindingAddedCallback
-> IO (FunPtr C_TrackElementControlBindingAddedCallback)
mk_TrackElementControlBindingRemovedCallback C_TrackElementControlBindingAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"control-binding-removed" FunPtr C_TrackElementControlBindingAddedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing

-- | Connect a signal handler for the [controlBindingRemoved](#signal:controlBindingRemoved) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' trackElement #controlBindingRemoved callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterTrackElementControlBindingRemoved :: (IsTrackElement a, MonadIO m) => a -> ((?self :: a) => TrackElementControlBindingRemovedCallback) -> m SignalHandlerId
afterTrackElementControlBindingRemoved :: forall a (m :: * -> *).
(IsTrackElement a, MonadIO m) =>
a
-> ((?self::a) => TrackElementControlBindingAddedCallback)
-> m SignalHandlerId
afterTrackElementControlBindingRemoved a
obj (?self::a) => TrackElementControlBindingAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TrackElementControlBindingAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TrackElementControlBindingAddedCallback
cb
    let wrapped' :: C_TrackElementControlBindingAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TrackElementControlBindingAddedCallback)
-> C_TrackElementControlBindingAddedCallback
wrap_TrackElementControlBindingRemovedCallback a -> TrackElementControlBindingAddedCallback
wrapped
    FunPtr C_TrackElementControlBindingAddedCallback
wrapped'' <- C_TrackElementControlBindingAddedCallback
-> IO (FunPtr C_TrackElementControlBindingAddedCallback)
mk_TrackElementControlBindingRemovedCallback C_TrackElementControlBindingAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"control-binding-removed" FunPtr C_TrackElementControlBindingAddedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TrackElementControlBindingRemovedSignalInfo
instance SignalInfo TrackElementControlBindingRemovedSignalInfo where
    type HaskellCallbackType TrackElementControlBindingRemovedSignalInfo = TrackElementControlBindingRemovedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TrackElementControlBindingRemovedCallback cb
        cb'' <- mk_TrackElementControlBindingRemovedCallback cb'
        connectSignalFunPtr obj "control-binding-removed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TrackElement::control-binding-removed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TrackElement.html#g:signal:controlBindingRemoved"})

#endif

-- VVV Prop "active"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

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

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

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

-- VVV Prop "auto-clamp-control-sources"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data TrackElementAutoClampControlSourcesPropertyInfo
instance AttrInfo TrackElementAutoClampControlSourcesPropertyInfo where
    type AttrAllowedOps TrackElementAutoClampControlSourcesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TrackElementAutoClampControlSourcesPropertyInfo = IsTrackElement
    type AttrSetTypeConstraint TrackElementAutoClampControlSourcesPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TrackElementAutoClampControlSourcesPropertyInfo = (~) Bool
    type AttrTransferType TrackElementAutoClampControlSourcesPropertyInfo = Bool
    type AttrGetType TrackElementAutoClampControlSourcesPropertyInfo = Bool
    type AttrLabel TrackElementAutoClampControlSourcesPropertyInfo = "auto-clamp-control-sources"
    type AttrOrigin TrackElementAutoClampControlSourcesPropertyInfo = TrackElement
    attrGet = getTrackElementAutoClampControlSources
    attrSet = setTrackElementAutoClampControlSources
    attrTransfer _ v = do
        return v
    attrConstruct = constructTrackElementAutoClampControlSources
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TrackElement.autoClampControlSources"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TrackElement.html#g:attr:autoClampControlSources"
        })
#endif

-- VVV Prop "has-internal-source"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

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

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

#if defined(ENABLE_OVERLOADING)
data TrackElementHasInternalSourcePropertyInfo
instance AttrInfo TrackElementHasInternalSourcePropertyInfo where
    type AttrAllowedOps TrackElementHasInternalSourcePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TrackElementHasInternalSourcePropertyInfo = IsTrackElement
    type AttrSetTypeConstraint TrackElementHasInternalSourcePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TrackElementHasInternalSourcePropertyInfo = (~) Bool
    type AttrTransferType TrackElementHasInternalSourcePropertyInfo = Bool
    type AttrGetType TrackElementHasInternalSourcePropertyInfo = Bool
    type AttrLabel TrackElementHasInternalSourcePropertyInfo = "has-internal-source"
    type AttrOrigin TrackElementHasInternalSourcePropertyInfo = TrackElement
    attrGet = getTrackElementHasInternalSource
    attrSet = setTrackElementHasInternalSource
    attrTransfer _ v = do
        return v
    attrConstruct = constructTrackElementHasInternalSource
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TrackElement.hasInternalSource"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TrackElement.html#g:attr:hasInternalSource"
        })
#endif

-- VVV Prop "track"
   -- Type: TInterface (Name {namespace = "GES", name = "Track"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@track@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' trackElement #track
-- @
getTrackElementTrack :: (MonadIO m, IsTrackElement o) => o -> m (Maybe GES.Track.Track)
getTrackElementTrack :: forall (m :: * -> *) o.
(MonadIO m, IsTrackElement o) =>
o -> m (Maybe Track)
getTrackElementTrack o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"track" ManagedPtr Track -> Track
GES.Track.Track

#if defined(ENABLE_OVERLOADING)
data TrackElementTrackPropertyInfo
instance AttrInfo TrackElementTrackPropertyInfo where
    type AttrAllowedOps TrackElementTrackPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TrackElementTrackPropertyInfo = IsTrackElement
    type AttrSetTypeConstraint TrackElementTrackPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TrackElementTrackPropertyInfo = (~) ()
    type AttrTransferType TrackElementTrackPropertyInfo = ()
    type AttrGetType TrackElementTrackPropertyInfo = (Maybe GES.Track.Track)
    type AttrLabel TrackElementTrackPropertyInfo = "track"
    type AttrOrigin TrackElementTrackPropertyInfo = TrackElement
    attrGet = getTrackElementTrack
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TrackElement.track"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TrackElement.html#g:attr:track"
        })
#endif

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

-- | Get the value of the “@track-type@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' trackElement #trackType
-- @
getTrackElementTrackType :: (MonadIO m, IsTrackElement o) => o -> m [GES.Flags.TrackType]
getTrackElementTrackType :: forall (m :: * -> *) o.
(MonadIO m, IsTrackElement o) =>
o -> m [TrackType]
getTrackElementTrackType o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"track-type"

-- | Set the value of the “@track-type@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' trackElement [ #trackType 'Data.GI.Base.Attributes.:=' value ]
-- @
setTrackElementTrackType :: (MonadIO m, IsTrackElement o) => o -> [GES.Flags.TrackType] -> m ()
setTrackElementTrackType :: forall (m :: * -> *) o.
(MonadIO m, IsTrackElement o) =>
o -> [TrackType] -> m ()
setTrackElementTrackType o
obj [TrackType]
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"track-type" [TrackType]
val

-- | Construct a `GValueConstruct` with valid value for the “@track-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTrackElementTrackType :: (IsTrackElement o, MIO.MonadIO m) => [GES.Flags.TrackType] -> m (GValueConstruct o)
constructTrackElementTrackType :: forall o (m :: * -> *).
(IsTrackElement o, MonadIO m) =>
[TrackType] -> m (GValueConstruct o)
constructTrackElementTrackType [TrackType]
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"track-type" [TrackType]
val

#if defined(ENABLE_OVERLOADING)
data TrackElementTrackTypePropertyInfo
instance AttrInfo TrackElementTrackTypePropertyInfo where
    type AttrAllowedOps TrackElementTrackTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TrackElementTrackTypePropertyInfo = IsTrackElement
    type AttrSetTypeConstraint TrackElementTrackTypePropertyInfo = (~) [GES.Flags.TrackType]
    type AttrTransferTypeConstraint TrackElementTrackTypePropertyInfo = (~) [GES.Flags.TrackType]
    type AttrTransferType TrackElementTrackTypePropertyInfo = [GES.Flags.TrackType]
    type AttrGetType TrackElementTrackTypePropertyInfo = [GES.Flags.TrackType]
    type AttrLabel TrackElementTrackTypePropertyInfo = "track-type"
    type AttrOrigin TrackElementTrackTypePropertyInfo = TrackElement
    attrGet = getTrackElementTrackType
    attrSet = setTrackElementTrackType
    attrTransfer _ v = do
        return v
    attrConstruct = constructTrackElementTrackType
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TrackElement.trackType"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TrackElement.html#g:attr:trackType"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TrackElement
type instance O.AttributeList TrackElement = TrackElementAttributeList
type TrackElementAttributeList = ('[ '("active", TrackElementActivePropertyInfo), '("autoClampControlSources", TrackElementAutoClampControlSourcesPropertyInfo), '("duration", GES.TimelineElement.TimelineElementDurationPropertyInfo), '("hasInternalSource", TrackElementHasInternalSourcePropertyInfo), '("inPoint", GES.TimelineElement.TimelineElementInPointPropertyInfo), '("maxDuration", GES.TimelineElement.TimelineElementMaxDurationPropertyInfo), '("name", GES.TimelineElement.TimelineElementNamePropertyInfo), '("parent", GES.TimelineElement.TimelineElementParentPropertyInfo), '("priority", GES.TimelineElement.TimelineElementPriorityPropertyInfo), '("serialize", GES.TimelineElement.TimelineElementSerializePropertyInfo), '("start", GES.TimelineElement.TimelineElementStartPropertyInfo), '("timeline", GES.TimelineElement.TimelineElementTimelinePropertyInfo), '("track", TrackElementTrackPropertyInfo), '("trackType", TrackElementTrackTypePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
trackElementActive :: AttrLabelProxy "active"
trackElementActive = AttrLabelProxy

trackElementAutoClampControlSources :: AttrLabelProxy "autoClampControlSources"
trackElementAutoClampControlSources = AttrLabelProxy

trackElementTrack :: AttrLabelProxy "track"
trackElementTrack = AttrLabelProxy

trackElementTrackType :: AttrLabelProxy "trackType"
trackElementTrackType = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TrackElement = TrackElementSignalList
type TrackElementSignalList = ('[ '("childPropertyAdded", GES.TimelineElement.TimelineElementChildPropertyAddedSignalInfo), '("childPropertyRemoved", GES.TimelineElement.TimelineElementChildPropertyRemovedSignalInfo), '("controlBindingAdded", TrackElementControlBindingAddedSignalInfo), '("controlBindingRemoved", TrackElementControlBindingRemovedSignalInfo), '("deepNotify", GES.TimelineElement.TimelineElementDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("notifyMeta", GES.MetaContainer.MetaContainerNotifyMetaSignalInfo)] :: [(Symbol, *)])

#endif

-- method TrackElement::add_children_props
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "element"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "Element" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The child object to retrieve properties from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "wanted_categories"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "\nAn array of element factory \"klass\" categories to whitelist, or %NULL\nto accept all categories"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "blacklist"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A\nblacklist of element factory names, or %NULL to not blacklist any\nelement factory"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "whitelist"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A\nwhitelist of element property names, or %NULL to whitelist all\nwriteable properties"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_element_add_children_props" ges_track_element_add_children_props :: 
    Ptr TrackElement ->                     -- self : TInterface (Name {namespace = "GES", name = "TrackElement"})
    Ptr Gst.Element.Element ->              -- element : TInterface (Name {namespace = "Gst", name = "Element"})
    Ptr CString ->                          -- wanted_categories : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr CString ->                          -- blacklist : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr CString ->                          -- whitelist : TCArray True (-1) (-1) (TBasicType TUTF8)
    IO ()

-- | Adds all the properties of a t'GI.Gst.Objects.Element.Element' that match the criteria as
-- children properties of the track element. If the name of /@element@/\'s
-- t'GI.Gst.Objects.ElementFactory.ElementFactory' is not in /@blacklist@/, and the factory\'s
-- 'GI.Gst.Constants.ELEMENT_METADATA_KLASS' contains at least one member of
-- /@wantedCategories@/ (e.g. 'GI.Gst.Constants.ELEMENT_FACTORY_KLASS_DECODER'), then
-- all the properties of /@element@/ that are also in /@whitelist@/ are added as
-- child properties of /@self@/ using
-- 'GI.GES.Objects.TimelineElement.timelineElementAddChildProperty'.
-- 
-- This is intended to be used by subclasses when constructing.
trackElementAddChildrenProps ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a, Gst.Element.IsElement b) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> b
    -- ^ /@element@/: The child object to retrieve properties from
    -> Maybe ([T.Text])
    -- ^ /@wantedCategories@/: 
    -- An array of element factory \"klass\" categories to whitelist, or 'P.Nothing'
    -- to accept all categories
    -> Maybe ([T.Text])
    -- ^ /@blacklist@/: A
    -- blacklist of element factory names, or 'P.Nothing' to not blacklist any
    -- element factory
    -> Maybe ([T.Text])
    -- ^ /@whitelist@/: A
    -- whitelist of element property names, or 'P.Nothing' to whitelist all
    -- writeable properties
    -> m ()
trackElementAddChildrenProps :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTrackElement a, IsElement b) =>
a -> b -> Maybe [Text] -> Maybe [Text] -> Maybe [Text] -> m ()
trackElementAddChildrenProps a
self b
element Maybe [Text]
wantedCategories Maybe [Text]
blacklist Maybe [Text]
whitelist = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Element
element' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
element
    Ptr CString
maybeWantedCategories <- case Maybe [Text]
wantedCategories of
        Maybe [Text]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just [Text]
jWantedCategories -> do
            Ptr CString
jWantedCategories' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jWantedCategories
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jWantedCategories'
    Ptr CString
maybeBlacklist <- case Maybe [Text]
blacklist of
        Maybe [Text]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just [Text]
jBlacklist -> do
            Ptr CString
jBlacklist' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jBlacklist
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jBlacklist'
    Ptr CString
maybeWhitelist <- case Maybe [Text]
whitelist of
        Maybe [Text]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just [Text]
jWhitelist -> do
            Ptr CString
jWhitelist' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jWhitelist
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jWhitelist'
    Ptr TrackElement
-> Ptr Element
-> Ptr CString
-> Ptr CString
-> Ptr CString
-> IO ()
ges_track_element_add_children_props Ptr TrackElement
self' Ptr Element
element' Ptr CString
maybeWantedCategories Ptr CString
maybeBlacklist Ptr CString
maybeWhitelist
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
element
    forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeWantedCategories
    forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeWantedCategories
    forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeBlacklist
    forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeBlacklist
    forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeWhitelist
    forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeWhitelist
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TrackElementAddChildrenPropsMethodInfo
instance (signature ~ (b -> Maybe ([T.Text]) -> Maybe ([T.Text]) -> Maybe ([T.Text]) -> m ()), MonadIO m, IsTrackElement a, Gst.Element.IsElement b) => O.OverloadedMethod TrackElementAddChildrenPropsMethodInfo a signature where
    overloadedMethod = trackElementAddChildrenProps

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


#endif

-- method TrackElement::clamp_control_source
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The name of the child property to clamp the control\nsource of"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_element_clamp_control_source" ges_track_element_clamp_control_source :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    CString ->                              -- property_name : TBasicType TUTF8
    IO ()

-- | Clamp the @/GstTimedValueControlSource/@ for the specified child property
-- to lie between the [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") and out-point of the
-- element. The out-point is the @/GES_TIMELINE_ELEMENT_END/@ of the element
-- translated from the timeline coordinates to the internal source
-- coordinates of the element.
-- 
-- If the property does not have a @/GstTimedValueControlSource/@ set by
-- 'GI.GES.Objects.TrackElement.trackElementSetControlSource', nothing happens. Otherwise, if
-- a timed value for the control source lies before the in-point of the
-- element, or after its out-point, then it will be removed. At the
-- in-point and out-point times, a new interpolated value will be placed.
-- 
-- /Since: 1.18/
trackElementClampControlSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> T.Text
    -- ^ /@propertyName@/: The name of the child property to clamp the control
    -- source of
    -> m ()
trackElementClampControlSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> Text -> m ()
trackElementClampControlSource a
object Text
propertyName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr TrackElement -> CString -> IO ()
ges_track_element_clamp_control_source Ptr TrackElement
object' CString
propertyName'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TrackElementClampControlSourceMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementClampControlSourceMethodInfo a signature where
    overloadedMethod = trackElementClampControlSource

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


#endif

-- method TrackElement::edit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTrackElement to edit"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "layers"
--           , argType =
--               TGList (TInterface Name { namespace = "GES" , name = "Layer" })
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A whitelist of layers\nwhere the edit can be performed, %NULL allows all layers in the\ntimeline"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "EditMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The edit mode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "edge"
--           , argType = TInterface Name { namespace = "GES" , name = "Edge" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The edge of @object where the edit should occur"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The edit position: a new location for the edge of @object\n(in nanoseconds)"
--                 , 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_track_element_edit" ges_track_element_edit :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    Ptr (GList (Ptr GES.Layer.Layer)) ->    -- layers : TGList (TInterface (Name {namespace = "GES", name = "Layer"}))
    CUInt ->                                -- mode : TInterface (Name {namespace = "GES", name = "EditMode"})
    CUInt ->                                -- edge : TInterface (Name {namespace = "GES", name = "Edge"})
    Word64 ->                               -- position : TBasicType TUInt64
    IO CInt

{-# DEPRECATED trackElementEdit ["(Since version 1.18)","use @/ges_timeline_element_edit/@ instead."] #-}
-- | Edits the element within its track.
trackElementEdit ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a, GES.Layer.IsLayer b) =>
    a
    -- ^ /@object@/: The t'GI.GES.Objects.TrackElement.TrackElement' to edit
    -> [b]
    -- ^ /@layers@/: A whitelist of layers
    -- where the edit can be performed, 'P.Nothing' allows all layers in the
    -- timeline
    -> GES.Enums.EditMode
    -- ^ /@mode@/: The edit mode
    -> GES.Enums.Edge
    -- ^ /@edge@/: The edge of /@object@/ where the edit should occur
    -> Word64
    -- ^ /@position@/: The edit position: a new location for the edge of /@object@/
    -- (in nanoseconds)
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the edit of /@object@/ completed, 'P.False' on failure.
trackElementEdit :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTrackElement a, IsLayer b) =>
a -> [b] -> EditMode -> Edge -> Word64 -> m Bool
trackElementEdit a
object [b]
layers EditMode
mode Edge
edge Word64
position = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    [Ptr Layer]
layers' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [b]
layers
    Ptr (GList (Ptr Layer))
layers'' <- forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGList [Ptr Layer]
layers'
    let mode' :: CUInt
mode' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) EditMode
mode
    let edge' :: CUInt
edge' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Edge
edge
    CInt
result <- Ptr TrackElement
-> Ptr (GList (Ptr Layer)) -> CUInt -> CUInt -> Word64 -> IO CInt
ges_track_element_edit Ptr TrackElement
object' Ptr (GList (Ptr Layer))
layers'' CUInt
mode' CUInt
edge' Word64
position
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [b]
layers
    forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Layer))
layers''
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementEditMethodInfo
instance (signature ~ ([b] -> GES.Enums.EditMode -> GES.Enums.Edge -> Word64 -> m Bool), MonadIO m, IsTrackElement a, GES.Layer.IsLayer b) => O.OverloadedMethod TrackElementEditMethodInfo a signature where
    overloadedMethod = trackElementEdit

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


#endif

-- XXX Could not generate method TrackElement::get_all_control_bindings
-- Not implemented: GHashTable element of type TInterface (Name {namespace = "Gst", name = "ControlBinding"}) unsupported.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data TrackElementGetAllControlBindingsMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "getAllControlBindings" TrackElement) => O.OverloadedMethod TrackElementGetAllControlBindingsMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "getAllControlBindings" TrackElement) => O.OverloadedMethodInfo TrackElementGetAllControlBindingsMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method TrackElement::get_auto_clamp_control_sources
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , 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_track_element_get_auto_clamp_control_sources" ges_track_element_get_auto_clamp_control_sources :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    IO CInt

-- | Gets [TrackElement:autoClampControlSources]("GI.GES.Objects.TrackElement#g:attr:autoClampControlSources").
-- 
-- /Since: 1.18/
trackElementGetAutoClampControlSources ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> m Bool
    -- ^ __Returns:__ Whether the control sources for the child properties of
    -- /@object@/ are automatically clamped.
trackElementGetAutoClampControlSources :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> m Bool
trackElementGetAutoClampControlSources a
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CInt
result <- Ptr TrackElement -> IO CInt
ges_track_element_get_auto_clamp_control_sources Ptr TrackElement
object'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementGetAutoClampControlSourcesMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementGetAutoClampControlSourcesMethodInfo a signature where
    overloadedMethod = trackElementGetAutoClampControlSources

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


#endif

-- method TrackElement::get_control_binding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The name of the child property to return the control\nbinding of"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gst" , name = "ControlBinding" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_element_get_control_binding" ges_track_element_get_control_binding :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    CString ->                              -- property_name : TBasicType TUTF8
    IO (Ptr Gst.ControlBinding.ControlBinding)

-- | Gets the control binding that was created for the specified child
-- property of the track element using
-- 'GI.GES.Objects.TrackElement.trackElementSetControlSource'. The given /@propertyName@/ must
-- be the same name of the child property that was passed to
-- 'GI.GES.Objects.TrackElement.trackElementSetControlSource'.
trackElementGetControlBinding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> T.Text
    -- ^ /@propertyName@/: The name of the child property to return the control
    -- binding of
    -> m (Maybe Gst.ControlBinding.ControlBinding)
    -- ^ __Returns:__ The control binding that was
    -- created for the specified child property of /@object@/, or 'P.Nothing' if
    -- /@propertyName@/ does not correspond to any control binding.
trackElementGetControlBinding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> Text -> m (Maybe ControlBinding)
trackElementGetControlBinding a
object Text
propertyName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr ControlBinding
result <- Ptr TrackElement -> CString -> IO (Ptr ControlBinding)
ges_track_element_get_control_binding Ptr TrackElement
object' CString
propertyName'
    Maybe ControlBinding
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ControlBinding
result forall a b. (a -> b) -> a -> b
$ \Ptr ControlBinding
result' -> do
        ControlBinding
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ControlBinding -> ControlBinding
Gst.ControlBinding.ControlBinding) Ptr ControlBinding
result'
        forall (m :: * -> *) a. Monad m => a -> m a
return ControlBinding
result''
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ControlBinding
maybeResult

#if defined(ENABLE_OVERLOADING)
data TrackElementGetControlBindingMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gst.ControlBinding.ControlBinding)), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementGetControlBindingMethodInfo a signature where
    overloadedMethod = trackElementGetControlBinding

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


#endif

-- method TrackElement::get_element
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Element" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_element_get_element" ges_track_element_get_element :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    IO (Ptr Gst.Element.Element)

-- | Get the t'GI.Gst.Objects.Element.Element' that the track element\'s underlying nleobject
-- controls.
trackElementGetElement ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> m Gst.Element.Element
    -- ^ __Returns:__ The t'GI.Gst.Objects.Element.Element' being controlled by the
    -- nleobject that /@object@/ wraps.
trackElementGetElement :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> m Element
trackElementGetElement a
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr Element
result <- Ptr TrackElement -> IO (Ptr Element)
ges_track_element_get_element Ptr TrackElement
object'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"trackElementGetElement" Ptr Element
result
    Element
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Element -> Element
Gst.Element.Element) Ptr Element
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Element
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementGetElementMethodInfo
instance (signature ~ (m Gst.Element.Element), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementGetElementMethodInfo a signature where
    overloadedMethod = trackElementGetElement

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


#endif

-- method TrackElement::get_gnlobject
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Element" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_element_get_gnlobject" ges_track_element_get_gnlobject :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    IO (Ptr Gst.Element.Element)

{-# DEPRECATED trackElementGetGnlobject ["use @/ges_track_element_get_nleobject/@ instead."] #-}
-- | Get the GNonLin object this object is controlling.
trackElementGetGnlobject ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> m Gst.Element.Element
    -- ^ __Returns:__ The GNonLin object this object is controlling.
trackElementGetGnlobject :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> m Element
trackElementGetGnlobject a
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr Element
result <- Ptr TrackElement -> IO (Ptr Element)
ges_track_element_get_gnlobject Ptr TrackElement
object'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"trackElementGetGnlobject" Ptr Element
result
    Element
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Element -> Element
Gst.Element.Element) Ptr Element
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Element
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementGetGnlobjectMethodInfo
instance (signature ~ (m Gst.Element.Element), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementGetGnlobjectMethodInfo a signature where
    overloadedMethod = trackElementGetGnlobject

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


#endif

-- method TrackElement::get_nleobject
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Element" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_element_get_nleobject" ges_track_element_get_nleobject :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    IO (Ptr Gst.Element.Element)

-- | Get the nleobject that this element wraps.
-- 
-- /Since: 1.6/
trackElementGetNleobject ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> m Gst.Element.Element
    -- ^ __Returns:__ The nleobject that /@object@/ wraps.
trackElementGetNleobject :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> m Element
trackElementGetNleobject a
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr Element
result <- Ptr TrackElement -> IO (Ptr Element)
ges_track_element_get_nleobject Ptr TrackElement
object'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"trackElementGetNleobject" Ptr Element
result
    Element
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Element -> Element
Gst.Element.Element) Ptr Element
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Element
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementGetNleobjectMethodInfo
instance (signature ~ (m Gst.Element.Element), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementGetNleobjectMethodInfo a signature where
    overloadedMethod = trackElementGetNleobject

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


#endif

-- method TrackElement::get_track
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GES" , name = "Track" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_element_get_track" ges_track_element_get_track :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    IO (Ptr GES.Track.Track)

-- | Get the [TrackElement:track]("GI.GES.Objects.TrackElement#g:attr:track") for the element.
trackElementGetTrack ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> m (Maybe GES.Track.Track)
    -- ^ __Returns:__ The track that /@object@/ belongs to,
    -- or 'P.Nothing' if it does not belong to a track.
trackElementGetTrack :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> m (Maybe Track)
trackElementGetTrack a
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr Track
result <- Ptr TrackElement -> IO (Ptr Track)
ges_track_element_get_track Ptr TrackElement
object'
    Maybe Track
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Track
result forall a b. (a -> b) -> a -> b
$ \Ptr Track
result' -> do
        Track
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Track -> Track
GES.Track.Track) Ptr Track
result'
        forall (m :: * -> *) a. Monad m => a -> m a
return Track
result''
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Track
maybeResult

#if defined(ENABLE_OVERLOADING)
data TrackElementGetTrackMethodInfo
instance (signature ~ (m (Maybe GES.Track.Track)), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementGetTrackMethodInfo a signature where
    overloadedMethod = trackElementGetTrack

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


#endif

-- method TrackElement::get_track_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GES" , name = "TrackType" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_element_get_track_type" ges_track_element_get_track_type :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    IO CUInt

-- | Gets the [TrackElement:trackType]("GI.GES.Objects.TrackElement#g:attr:trackType") for the element.
trackElementGetTrackType ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> m [GES.Flags.TrackType]
    -- ^ __Returns:__ The track-type of /@object@/.
trackElementGetTrackType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> m [TrackType]
trackElementGetTrackType a
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CUInt
result <- Ptr TrackElement -> IO CUInt
ges_track_element_get_track_type Ptr TrackElement
object'
    let result' :: [TrackType]
result' = forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return [TrackType]
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementGetTrackTypeMethodInfo
instance (signature ~ (m [GES.Flags.TrackType]), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementGetTrackTypeMethodInfo a signature where
    overloadedMethod = trackElementGetTrackType

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


#endif

-- method TrackElement::has_internal_source
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , 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_track_element_has_internal_source" ges_track_element_has_internal_source :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    IO CInt

-- | Gets [TrackElement:hasInternalSource]("GI.GES.Objects.TrackElement#g:attr:hasInternalSource") for the element.
-- 
-- /Since: 1.18/
trackElementHasInternalSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@object@/ can have its \'internal time\' properties set.
trackElementHasInternalSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> m Bool
trackElementHasInternalSource a
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CInt
result <- Ptr TrackElement -> IO CInt
ges_track_element_has_internal_source Ptr TrackElement
object'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementHasInternalSourceMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementHasInternalSourceMethodInfo a signature where
    overloadedMethod = trackElementHasInternalSource

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


#endif

-- method TrackElement::is_active
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , 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_track_element_is_active" ges_track_element_is_active :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    IO CInt

-- | Gets [TrackElement:active]("GI.GES.Objects.TrackElement#g:attr:active") for the element.
trackElementIsActive ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@object@/ is active in its track.
trackElementIsActive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> m Bool
trackElementIsActive a
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CInt
result <- Ptr TrackElement -> IO CInt
ges_track_element_is_active Ptr TrackElement
object'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementIsActiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementIsActiveMethodInfo a signature where
    overloadedMethod = trackElementIsActive

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


#endif

-- method TrackElement::is_core
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , 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_track_element_is_core" ges_track_element_is_core :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    IO CInt

-- | Get whether the given track element is a core track element. That is,
-- it was created by the /@createTrackElements@/ t'GI.GES.Structs.ClipClass.ClipClass' method for
-- some t'GI.GES.Objects.Clip.Clip'.
-- 
-- Note that such a track element can only be added to a clip that shares
-- the same t'GI.GES.Objects.Asset.Asset' as the clip that created it. For example, you are
-- allowed to move core children between clips that resulted from
-- 'GI.GES.Objects.Container.containerUngroup', but you could not move the core child from a
-- t'GI.GES.Objects.UriClip.UriClip' to a t'GI.GES.Objects.TitleClip.TitleClip' or another t'GI.GES.Objects.UriClip.UriClip' with a different
-- [UriClip:uri]("GI.GES.Objects.UriClip#g:attr:uri").
-- 
-- Moreover, if a core track element is added to a clip, it will always be
-- added as a core child. Therefore, if this returns 'P.True', then /@element@/
-- will be a core child of its parent clip.
-- 
-- /Since: 1.18/
trackElementIsCore ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@element@/ is a core track element.
trackElementIsCore :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> m Bool
trackElementIsCore a
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CInt
result <- Ptr TrackElement -> IO CInt
ges_track_element_is_core Ptr TrackElement
object'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementIsCoreMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementIsCoreMethodInfo a signature where
    overloadedMethod = trackElementIsCore

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


#endif

-- XXX Could not generate method TrackElement::list_children_properties
-- Not implemented: unpackCArray : Don't know how to unpack C Array of type TParamSpec
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data TrackElementListChildrenPropertiesMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "listChildrenProperties" TrackElement) => O.OverloadedMethod TrackElementListChildrenPropertiesMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "listChildrenProperties" TrackElement) => O.OverloadedMethodInfo TrackElementListChildrenPropertiesMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method TrackElement::lookup_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object to lookup the property in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Name of the property to look up. You can specify the name of the\n    class as such: \"ClassName::property-name\", to guarantee that you get the\n    proper GParamSpec in case various GstElement-s contain the same property\n    name. If you don't do so, you will get the first element found, having\n    this property and the and the corresponding GParamSpec."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "element"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "Element" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "pointer to a #GstElement that\n    takes the real object to set property on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "pointer to take the specification\n    describing the property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_element_lookup_child" ges_track_element_lookup_child :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    CString ->                              -- prop_name : TBasicType TUTF8
    Ptr (Ptr Gst.Element.Element) ->        -- element : TInterface (Name {namespace = "Gst", name = "Element"})
    Ptr (Ptr GParamSpec) ->                 -- pspec : TParamSpec
    IO CInt

{-# DEPRECATED trackElementLookupChild ["Use @/ges_timeline_element_lookup_child/@"] #-}
-- | Looks up which /@element@/ and /@pspec@/ would be effected by the given /@name@/. If various
-- contained elements have this property name you will get the first one, unless you
-- specify the class name in /@name@/.
trackElementLookupChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: Object to lookup the property in
    -> T.Text
    -- ^ /@propName@/: Name of the property to look up. You can specify the name of the
    --     class as such: \"ClassName[propertyName](#g:signal:propertyName)\", to guarantee that you get the
    --     proper GParamSpec in case various GstElement-s contain the same property
    --     name. If you don\'t do so, you will get the first element found, having
    --     this property and the and the corresponding GParamSpec.
    -> m ((Bool, Gst.Element.Element, GParamSpec))
    -- ^ __Returns:__ TRUE if /@element@/ and /@pspec@/ could be found. FALSE otherwise. In that
    -- case the values for /@pspec@/ and /@element@/ are not modified. Unref /@element@/ after
    -- usage.
trackElementLookupChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> Text -> m (Bool, Element, GParamSpec)
trackElementLookupChild a
object Text
propName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CString
propName' <- Text -> IO CString
textToCString Text
propName
    Ptr (Ptr Element)
element <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Element.Element))
    Ptr (Ptr GParamSpec)
pspec <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GParamSpec))
    CInt
result <- Ptr TrackElement
-> CString -> Ptr (Ptr Element) -> Ptr (Ptr GParamSpec) -> IO CInt
ges_track_element_lookup_child Ptr TrackElement
object' CString
propName' Ptr (Ptr Element)
element Ptr (Ptr GParamSpec)
pspec
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Ptr Element
element' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Element)
element
    Element
element'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Element -> Element
Gst.Element.Element) Ptr Element
element'
    Ptr GParamSpec
pspec' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GParamSpec)
pspec
    GParamSpec
pspec'' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.wrapGParamSpecPtr Ptr GParamSpec
pspec'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall a. Ptr a -> IO ()
freeMem CString
propName'
    forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Element)
element
    forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GParamSpec)
pspec
    forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Element
element'', GParamSpec
pspec'')

#if defined(ENABLE_OVERLOADING)
data TrackElementLookupChildMethodInfo
instance (signature ~ (T.Text -> m ((Bool, Gst.Element.Element, GParamSpec))), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementLookupChildMethodInfo a signature where
    overloadedMethod = trackElementLookupChild

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


#endif

-- method TrackElement::remove_control_binding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The name of the child property to remove the control\nbinding from"
--                 , 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_track_element_remove_control_binding" ges_track_element_remove_control_binding :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    CString ->                              -- property_name : TBasicType TUTF8
    IO CInt

-- | Removes the t'GI.Gst.Objects.ControlBinding.ControlBinding' that was created for the specified child
-- property of the track element using
-- 'GI.GES.Objects.TrackElement.trackElementSetControlSource'. The given /@propertyName@/ must
-- be the same name of the child property that was passed to
-- 'GI.GES.Objects.TrackElement.trackElementSetControlSource'.
trackElementRemoveControlBinding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> T.Text
    -- ^ /@propertyName@/: The name of the child property to remove the control
    -- binding from
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the control binding was removed from the specified
    -- child property of /@object@/, or 'P.False' if an error occurred.
trackElementRemoveControlBinding :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> Text -> m Bool
trackElementRemoveControlBinding a
object Text
propertyName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    CInt
result <- Ptr TrackElement -> CString -> IO CInt
ges_track_element_remove_control_binding Ptr TrackElement
object' CString
propertyName'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementRemoveControlBindingMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementRemoveControlBindingMethodInfo a signature where
    overloadedMethod = trackElementRemoveControlBinding

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


#endif

-- method TrackElement::set_active
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "active"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether @object should be active in its track"
--                 , 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_track_element_set_active" ges_track_element_set_active :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    CInt ->                                 -- active : TBasicType TBoolean
    IO CInt

-- | Sets [TrackElement:active]("GI.GES.Objects.TrackElement#g:attr:active") for the element.
trackElementSetActive ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> Bool
    -- ^ /@active@/: Whether /@object@/ should be active in its track
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the property was *toggled*.
trackElementSetActive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> Bool -> m Bool
trackElementSetActive a
object Bool
active = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    let active' :: CInt
active' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
active
    CInt
result <- Ptr TrackElement -> CInt -> IO CInt
ges_track_element_set_active Ptr TrackElement
object' CInt
active'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementSetActiveMethodInfo
instance (signature ~ (Bool -> m Bool), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementSetActiveMethodInfo a signature where
    overloadedMethod = trackElementSetActive

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


#endif

-- method TrackElement::set_auto_clamp_control_sources
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "auto_clamp"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Whether to automatically clamp the control sources for the\nchild properties of @object"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_element_set_auto_clamp_control_sources" ges_track_element_set_auto_clamp_control_sources :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    CInt ->                                 -- auto_clamp : TBasicType TBoolean
    IO ()

-- | Sets [TrackElement:autoClampControlSources]("GI.GES.Objects.TrackElement#g:attr:autoClampControlSources"). If set to 'P.True', this
-- will immediately clamp all the control sources.
-- 
-- /Since: 1.18/
trackElementSetAutoClampControlSources ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> Bool
    -- ^ /@autoClamp@/: Whether to automatically clamp the control sources for the
    -- child properties of /@object@/
    -> m ()
trackElementSetAutoClampControlSources :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> Bool -> m ()
trackElementSetAutoClampControlSources a
object Bool
autoClamp = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    let autoClamp' :: CInt
autoClamp' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
autoClamp
    Ptr TrackElement -> CInt -> IO ()
ges_track_element_set_auto_clamp_control_sources Ptr TrackElement
object' CInt
autoClamp'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TrackElementSetAutoClampControlSourcesMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementSetAutoClampControlSourcesMethodInfo a signature where
    overloadedMethod = trackElementSetAutoClampControlSources

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


#endif

-- method TrackElement::set_control_source
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "source"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "ControlSource" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The control source to bind the child property to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name of the child property to control"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "binding_type"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The type of binding to create (\"direct\" or\n\"direct-absolute\")"
--                 , 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_track_element_set_control_source" ges_track_element_set_control_source :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    Ptr Gst.ControlSource.ControlSource ->  -- source : TInterface (Name {namespace = "Gst", name = "ControlSource"})
    CString ->                              -- property_name : TBasicType TUTF8
    CString ->                              -- binding_type : TBasicType TUTF8
    IO CInt

-- | Creates a t'GI.Gst.Objects.ControlBinding.ControlBinding' for the specified child property of the
-- track element using the given control source. The given /@propertyName@/
-- should refer to an existing child property of the track element, as
-- used in 'GI.GES.Objects.TimelineElement.timelineElementLookupChild'.
-- 
-- If /@bindingType@/ is \"direct\", then the control binding is created with
-- @/gst_direct_control_binding_new()/@ using the given control source. If
-- /@bindingType@/ is \"direct-absolute\", it is created with
-- @/gst_direct_control_binding_new_absolute()/@ instead.
trackElementSetControlSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a, Gst.ControlSource.IsControlSource b) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> b
    -- ^ /@source@/: The control source to bind the child property to
    -> T.Text
    -- ^ /@propertyName@/: The name of the child property to control
    -> T.Text
    -- ^ /@bindingType@/: The type of binding to create (\"direct\" or
    -- \"direct-absolute\")
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the specified child property could be bound to
    -- /@source@/, or 'P.False' if an error occurred.
trackElementSetControlSource :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTrackElement a, IsControlSource b) =>
a -> b -> Text -> Text -> m Bool
trackElementSetControlSource a
object b
source Text
propertyName Text
bindingType = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    Ptr ControlSource
source' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
source
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    CString
bindingType' <- Text -> IO CString
textToCString Text
bindingType
    CInt
result <- Ptr TrackElement
-> Ptr ControlSource -> CString -> CString -> IO CInt
ges_track_element_set_control_source Ptr TrackElement
object' Ptr ControlSource
source' CString
propertyName' CString
bindingType'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
source
    forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    forall a. Ptr a -> IO ()
freeMem CString
bindingType'
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementSetControlSourceMethodInfo
instance (signature ~ (b -> T.Text -> T.Text -> m Bool), MonadIO m, IsTrackElement a, Gst.ControlSource.IsControlSource b) => O.OverloadedMethod TrackElementSetControlSourceMethodInfo a signature where
    overloadedMethod = trackElementSetControlSource

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


#endif

-- method TrackElement::set_has_internal_source
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "has_internal_source"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Whether the @object should be allowed to have its\n'internal time' properties set."
--                 , 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_track_element_set_has_internal_source" ges_track_element_set_has_internal_source :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    CInt ->                                 -- has_internal_source : TBasicType TBoolean
    IO CInt

-- | Sets [TrackElement:hasInternalSource]("GI.GES.Objects.TrackElement#g:attr:hasInternalSource") for the element. If this is
-- set to 'P.False', this method will also set the
-- [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") of the element to 0 and its
-- [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") to 'GI.Gst.Constants.CLOCK_TIME_NONE'.
-- 
-- /Since: 1.18/
trackElementSetHasInternalSource ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> Bool
    -- ^ /@hasInternalSource@/: Whether the /@object@/ should be allowed to have its
    -- \'internal time\' properties set.
    -> m Bool
    -- ^ __Returns:__ 'P.False' if /@hasInternalSource@/ is forbidden for /@object@/ and
    -- 'P.True' in any other case.
trackElementSetHasInternalSource :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> Bool -> m Bool
trackElementSetHasInternalSource a
object Bool
hasInternalSource = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    let hasInternalSource' :: CInt
hasInternalSource' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
hasInternalSource
    CInt
result <- Ptr TrackElement -> CInt -> IO CInt
ges_track_element_set_has_internal_source Ptr TrackElement
object' CInt
hasInternalSource'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackElementSetHasInternalSourceMethodInfo
instance (signature ~ (Bool -> m Bool), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementSetHasInternalSourceMethodInfo a signature where
    overloadedMethod = trackElementSetHasInternalSource

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


#endif

-- method TrackElement::set_track_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrackElement" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "type"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new track-type for @object"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_element_set_track_type" ges_track_element_set_track_type :: 
    Ptr TrackElement ->                     -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    CUInt ->                                -- type : TInterface (Name {namespace = "GES", name = "TrackType"})
    IO ()

-- | Sets the [TrackElement:trackType]("GI.GES.Objects.TrackElement#g:attr:trackType") for the element.
trackElementSetTrackType ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrackElement a) =>
    a
    -- ^ /@object@/: A t'GI.GES.Objects.TrackElement.TrackElement'
    -> [GES.Flags.TrackType]
    -- ^ /@type@/: The new track-type for /@object@/
    -> m ()
trackElementSetTrackType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrackElement a) =>
a -> [TrackType] -> m ()
trackElementSetTrackType a
object [TrackType]
type_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
    let type_' :: CUInt
type_' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TrackType]
type_
    Ptr TrackElement -> CUInt -> IO ()
ges_track_element_set_track_type Ptr TrackElement
object' CUInt
type_'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TrackElementSetTrackTypeMethodInfo
instance (signature ~ ([GES.Flags.TrackType] -> m ()), MonadIO m, IsTrackElement a) => O.OverloadedMethod TrackElementSetTrackTypeMethodInfo a signature where
    overloadedMethod = trackElementSetTrackType

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


#endif