{-# 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.Track.Track' acts an output source for a t'GI.GES.Objects.Timeline.Timeline'. Each one
-- essentially provides an additional t'GI.Gst.Objects.Pad.Pad' for the timeline, with
-- [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps") capabilities. Internally, a track
-- wraps an @/nlecomposition/@ filtered by a @/capsfilter/@.
-- 
-- A track will contain a number of t'GI.GES.Objects.TrackElement.TrackElement'-s, and its role is
-- to select and activate these elements according to their timings when
-- the timeline in played. For example, a track would activate a
-- t'GI.GES.Objects.Source.Source' when its [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") is reached by outputting
-- its data for its [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration"). Similarly, a
-- t'GI.GES.Objects.Operation.Operation' would be activated by applying its effect to the source
-- data, starting from its [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") time and lasting for
-- its [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration").
-- 
-- For most users, it will usually be sufficient to add newly created
-- tracks to a timeline, but never directly add an element to a track.
-- Whenever a t'GI.GES.Objects.Clip.Clip' is added to a timeline, the clip adds its
-- elements to the timeline\'s tracks and assumes responsibility for
-- updating them.

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

module GI.GES.Objects.Track
    ( 

-- * Exported types
    Track(..)                               ,
    IsTrack                                 ,
    toTrack                                 ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [abortState]("GI.Gst.Objects.Element#g:method:abortState"), [add]("GI.Gst.Objects.Bin#g:method:add"), [addControlBinding]("GI.Gst.Objects.Object#g:method:addControlBinding"), [addElement]("GI.GES.Objects.Track#g:method:addElement"), [addElementFull]("GI.GES.Objects.Track#g:method:addElementFull"), [addMetasFromString]("GI.GES.Interfaces.MetaContainer#g:method:addMetasFromString"), [addPad]("GI.Gst.Objects.Element#g:method:addPad"), [addPropertyDeepNotifyWatch]("GI.Gst.Objects.Element#g:method:addPropertyDeepNotifyWatch"), [addPropertyNotifyWatch]("GI.Gst.Objects.Element#g:method:addPropertyNotifyWatch"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [callAsync]("GI.Gst.Objects.Element#g:method:callAsync"), [changeState]("GI.Gst.Objects.Element#g:method:changeState"), [checkMetaRegistered]("GI.GES.Interfaces.MetaContainer#g:method:checkMetaRegistered"), [childAdded]("GI.Gst.Interfaces.ChildProxy#g:method:childAdded"), [childRemoved]("GI.Gst.Interfaces.ChildProxy#g:method:childRemoved"), [commit]("GI.GES.Objects.Track#g:method:commit"), [continueState]("GI.Gst.Objects.Element#g:method:continueState"), [createAllPads]("GI.Gst.Objects.Element#g:method:createAllPads"), [defaultError]("GI.Gst.Objects.Object#g:method:defaultError"), [findUnlinkedPad]("GI.Gst.Objects.Bin#g:method:findUnlinkedPad"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.GES.Interfaces.MetaContainer#g:method:foreach"), [foreachPad]("GI.Gst.Objects.Element#g:method:foreachPad"), [foreachSinkPad]("GI.Gst.Objects.Element#g:method:foreachSinkPad"), [foreachSrcPad]("GI.Gst.Objects.Element#g:method:foreachSrcPad"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasActiveControlBindings]("GI.Gst.Objects.Object#g:method:hasActiveControlBindings"), [hasAncestor]("GI.Gst.Objects.Object#g:method:hasAncestor"), [hasAsAncestor]("GI.Gst.Objects.Object#g:method:hasAsAncestor"), [hasAsParent]("GI.Gst.Objects.Object#g:method:hasAsParent"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isLockedState]("GI.Gst.Objects.Element#g:method:isLockedState"), [iterateAllByElementFactoryName]("GI.Gst.Objects.Bin#g:method:iterateAllByElementFactoryName"), [iterateAllByInterface]("GI.Gst.Objects.Bin#g:method:iterateAllByInterface"), [iterateElements]("GI.Gst.Objects.Bin#g:method:iterateElements"), [iteratePads]("GI.Gst.Objects.Element#g:method:iteratePads"), [iterateRecurse]("GI.Gst.Objects.Bin#g:method:iterateRecurse"), [iterateSinkPads]("GI.Gst.Objects.Element#g:method:iterateSinkPads"), [iterateSinks]("GI.Gst.Objects.Bin#g:method:iterateSinks"), [iterateSorted]("GI.Gst.Objects.Bin#g:method:iterateSorted"), [iterateSources]("GI.Gst.Objects.Bin#g:method:iterateSources"), [iterateSrcPads]("GI.Gst.Objects.Element#g:method:iterateSrcPads"), [link]("GI.Gst.Objects.Element#g:method:link"), [linkFiltered]("GI.Gst.Objects.Element#g:method:linkFiltered"), [linkPads]("GI.Gst.Objects.Element#g:method:linkPads"), [linkPadsFiltered]("GI.Gst.Objects.Element#g:method:linkPadsFiltered"), [linkPadsFull]("GI.Gst.Objects.Element#g:method:linkPadsFull"), [lookup]("GI.Gst.Interfaces.ChildProxy#g:method:lookup"), [lostState]("GI.Gst.Objects.Element#g:method:lostState"), [messageFull]("GI.Gst.Objects.Element#g:method:messageFull"), [messageFullWithDetails]("GI.Gst.Objects.Element#g:method:messageFullWithDetails"), [metasToString]("GI.GES.Interfaces.MetaContainer#g:method:metasToString"), [noMorePads]("GI.Gst.Objects.Element#g:method:noMorePads"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [postMessage]("GI.Gst.Objects.Element#g:method:postMessage"), [provideClock]("GI.Gst.Objects.Element#g:method:provideClock"), [query]("GI.Gst.Objects.Element#g:method:query"), [queryConvert]("GI.Gst.Objects.Element#g:method:queryConvert"), [queryDuration]("GI.Gst.Objects.Element#g:method:queryDuration"), [queryPosition]("GI.Gst.Objects.Element#g:method:queryPosition"), [recalculateLatency]("GI.Gst.Objects.Bin#g:method:recalculateLatency"), [ref]("GI.Gst.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"), [releaseRequestPad]("GI.Gst.Objects.Element#g:method:releaseRequestPad"), [remove]("GI.Gst.Objects.Bin#g:method:remove"), [removeControlBinding]("GI.Gst.Objects.Object#g:method:removeControlBinding"), [removeElement]("GI.GES.Objects.Track#g:method:removeElement"), [removeElementFull]("GI.GES.Objects.Track#g:method:removeElementFull"), [removePad]("GI.Gst.Objects.Element#g:method:removePad"), [removePropertyNotifyWatch]("GI.Gst.Objects.Element#g:method:removePropertyNotifyWatch"), [requestPad]("GI.Gst.Objects.Element#g:method:requestPad"), [requestPadSimple]("GI.Gst.Objects.Element#g:method:requestPadSimple"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [seek]("GI.Gst.Objects.Element#g:method:seek"), [seekSimple]("GI.Gst.Objects.Element#g:method:seekSimple"), [sendEvent]("GI.Gst.Objects.Element#g:method:sendEvent"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [suggestNextSync]("GI.Gst.Objects.Object#g:method:suggestNextSync"), [syncChildrenStates]("GI.Gst.Objects.Bin#g:method:syncChildrenStates"), [syncStateWithParent]("GI.Gst.Objects.Element#g:method:syncStateWithParent"), [syncValues]("GI.Gst.Objects.Object#g:method:syncValues"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unlink]("GI.Gst.Objects.Element#g:method:unlink"), [unlinkPads]("GI.Gst.Objects.Element#g:method:unlinkPads"), [unparent]("GI.Gst.Objects.Object#g:method:unparent"), [unref]("GI.Gst.Objects.Object#g:method:unref"), [updateRestrictionCaps]("GI.GES.Objects.Track#g:method:updateRestrictionCaps"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getBaseTime]("GI.Gst.Objects.Element#g:method:getBaseTime"), [getBoolean]("GI.GES.Interfaces.MetaContainer#g:method:getBoolean"), [getBus]("GI.Gst.Objects.Element#g:method:getBus"), [getByInterface]("GI.Gst.Objects.Bin#g:method:getByInterface"), [getByName]("GI.Gst.Objects.Bin#g:method:getByName"), [getByNameRecurseUp]("GI.Gst.Objects.Bin#g:method:getByNameRecurseUp"), [getCaps]("GI.GES.Objects.Track#g:method:getCaps"), [getChildByIndex]("GI.Gst.Interfaces.ChildProxy#g:method:getChildByIndex"), [getChildByName]("GI.Gst.Interfaces.ChildProxy#g:method:getChildByName"), [getChildrenCount]("GI.Gst.Interfaces.ChildProxy#g:method:getChildrenCount"), [getClock]("GI.Gst.Objects.Element#g:method:getClock"), [getCompatiblePad]("GI.Gst.Objects.Element#g:method:getCompatiblePad"), [getCompatiblePadTemplate]("GI.Gst.Objects.Element#g:method:getCompatiblePadTemplate"), [getContext]("GI.Gst.Objects.Element#g:method:getContext"), [getContextUnlocked]("GI.Gst.Objects.Element#g:method:getContextUnlocked"), [getContexts]("GI.Gst.Objects.Element#g:method:getContexts"), [getControlBinding]("GI.Gst.Objects.Object#g:method:getControlBinding"), [getControlRate]("GI.Gst.Objects.Object#g:method:getControlRate"), [getCurrentClockTime]("GI.Gst.Objects.Element#g:method:getCurrentClockTime"), [getCurrentRunningTime]("GI.Gst.Objects.Element#g:method:getCurrentRunningTime"), [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"), [getElements]("GI.GES.Objects.Track#g:method:getElements"), [getFactory]("GI.Gst.Objects.Element#g:method:getFactory"), [getFloat]("GI.GES.Interfaces.MetaContainer#g:method:getFloat"), [getGValueArray]("GI.Gst.Objects.Object#g:method:getGValueArray"), [getInt]("GI.GES.Interfaces.MetaContainer#g:method:getInt"), [getInt64]("GI.GES.Interfaces.MetaContainer#g:method:getInt64"), [getMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:getMarkerList"), [getMeta]("GI.GES.Interfaces.MetaContainer#g:method:getMeta"), [getMetadata]("GI.Gst.Objects.Element#g:method:getMetadata"), [getMixing]("GI.GES.Objects.Track#g:method:getMixing"), [getName]("GI.Gst.Objects.Object#g:method:getName"), [getPadTemplate]("GI.Gst.Objects.Element#g:method:getPadTemplate"), [getPadTemplateList]("GI.Gst.Objects.Element#g:method:getPadTemplateList"), [getParent]("GI.Gst.Objects.Object#g:method:getParent"), [getPathString]("GI.Gst.Objects.Object#g:method:getPathString"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRequestPad]("GI.Gst.Objects.Element#g:method:getRequestPad"), [getRestrictionCaps]("GI.GES.Objects.Track#g:method:getRestrictionCaps"), [getStartTime]("GI.Gst.Objects.Element#g:method:getStartTime"), [getState]("GI.Gst.Objects.Element#g:method:getState"), [getStaticPad]("GI.Gst.Objects.Element#g:method:getStaticPad"), [getString]("GI.GES.Interfaces.MetaContainer#g:method:getString"), [getSuppressedFlags]("GI.Gst.Objects.Bin#g:method:getSuppressedFlags"), [getTimeline]("GI.GES.Objects.Track#g:method:getTimeline"), [getUint]("GI.GES.Interfaces.MetaContainer#g:method:getUint"), [getUint64]("GI.GES.Interfaces.MetaContainer#g:method:getUint64"), [getValue]("GI.Gst.Objects.Object#g:method:getValue").
-- 
-- ==== Setters
-- [setBaseTime]("GI.Gst.Objects.Element#g:method:setBaseTime"), [setBoolean]("GI.GES.Interfaces.MetaContainer#g:method:setBoolean"), [setBus]("GI.Gst.Objects.Element#g:method:setBus"), [setClock]("GI.Gst.Objects.Element#g:method:setClock"), [setContext]("GI.Gst.Objects.Element#g:method:setContext"), [setControlBindingDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingDisabled"), [setControlBindingsDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingsDisabled"), [setControlRate]("GI.Gst.Objects.Object#g:method:setControlRate"), [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"), [setFloat]("GI.GES.Interfaces.MetaContainer#g:method:setFloat"), [setInt]("GI.GES.Interfaces.MetaContainer#g:method:setInt"), [setInt64]("GI.GES.Interfaces.MetaContainer#g:method:setInt64"), [setLockedState]("GI.Gst.Objects.Element#g:method:setLockedState"), [setMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:setMarkerList"), [setMeta]("GI.GES.Interfaces.MetaContainer#g:method:setMeta"), [setMixing]("GI.GES.Objects.Track#g:method:setMixing"), [setName]("GI.Gst.Objects.Object#g:method:setName"), [setParent]("GI.Gst.Objects.Object#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRestrictionCaps]("GI.GES.Objects.Track#g:method:setRestrictionCaps"), [setStartTime]("GI.Gst.Objects.Element#g:method:setStartTime"), [setState]("GI.Gst.Objects.Element#g:method:setState"), [setString]("GI.GES.Interfaces.MetaContainer#g:method:setString"), [setSuppressedFlags]("GI.Gst.Objects.Bin#g:method:setSuppressedFlags"), [setTimeline]("GI.GES.Objects.Track#g:method:setTimeline"), [setUint]("GI.GES.Interfaces.MetaContainer#g:method:setUint"), [setUint64]("GI.GES.Interfaces.MetaContainer#g:method:setUint64").

#if defined(ENABLE_OVERLOADING)
    ResolveTrackMethod                      ,
#endif

-- ** addElement #method:addElement#

#if defined(ENABLE_OVERLOADING)
    TrackAddElementMethodInfo               ,
#endif
    trackAddElement                         ,


-- ** addElementFull #method:addElementFull#

#if defined(ENABLE_OVERLOADING)
    TrackAddElementFullMethodInfo           ,
#endif
    trackAddElementFull                     ,


-- ** commit #method:commit#

#if defined(ENABLE_OVERLOADING)
    TrackCommitMethodInfo                   ,
#endif
    trackCommit                             ,


-- ** getCaps #method:getCaps#

#if defined(ENABLE_OVERLOADING)
    TrackGetCapsMethodInfo                  ,
#endif
    trackGetCaps                            ,


-- ** getElements #method:getElements#

#if defined(ENABLE_OVERLOADING)
    TrackGetElementsMethodInfo              ,
#endif
    trackGetElements                        ,


-- ** getMixing #method:getMixing#

#if defined(ENABLE_OVERLOADING)
    TrackGetMixingMethodInfo                ,
#endif
    trackGetMixing                          ,


-- ** getRestrictionCaps #method:getRestrictionCaps#

#if defined(ENABLE_OVERLOADING)
    TrackGetRestrictionCapsMethodInfo       ,
#endif
    trackGetRestrictionCaps                 ,


-- ** getTimeline #method:getTimeline#

#if defined(ENABLE_OVERLOADING)
    TrackGetTimelineMethodInfo              ,
#endif
    trackGetTimeline                        ,


-- ** new #method:new#

    trackNew                                ,


-- ** removeElement #method:removeElement#

#if defined(ENABLE_OVERLOADING)
    TrackRemoveElementMethodInfo            ,
#endif
    trackRemoveElement                      ,


-- ** removeElementFull #method:removeElementFull#

#if defined(ENABLE_OVERLOADING)
    TrackRemoveElementFullMethodInfo        ,
#endif
    trackRemoveElementFull                  ,


-- ** setMixing #method:setMixing#

#if defined(ENABLE_OVERLOADING)
    TrackSetMixingMethodInfo                ,
#endif
    trackSetMixing                          ,


-- ** setRestrictionCaps #method:setRestrictionCaps#

#if defined(ENABLE_OVERLOADING)
    TrackSetRestrictionCapsMethodInfo       ,
#endif
    trackSetRestrictionCaps                 ,


-- ** setTimeline #method:setTimeline#

#if defined(ENABLE_OVERLOADING)
    TrackSetTimelineMethodInfo              ,
#endif
    trackSetTimeline                        ,


-- ** updateRestrictionCaps #method:updateRestrictionCaps#

#if defined(ENABLE_OVERLOADING)
    TrackUpdateRestrictionCapsMethodInfo    ,
#endif
    trackUpdateRestrictionCaps              ,




 -- * Properties


-- ** caps #attr:caps#
-- | The capabilities used to choose the output of the t'GI.GES.Objects.Track.Track'\'s
-- elements. Internally, this is used to select output streams when
-- several may be available, by determining whether its t'GI.Gst.Objects.Pad.Pad' is
-- compatible (see @/NleObject:caps/@ for @/nlecomposition/@). As such,
-- this is used as a weaker indication of the desired output type of the
-- track, **before** the [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps") is applied.
-- Therefore, this should be set to a *generic* superset of the
-- [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps"), such as \"video\/x-raw(ANY)\". In addition,
-- it should match with the track\'s [Track:trackType]("GI.GES.Objects.Track#g:attr:trackType").
-- 
-- Note that when you set this property, the t'GI.Gst.Structs.CapsFeatures.CapsFeatures' of all its
-- t'GI.Gst.Structs.Structure.Structure'-s will be automatically set to @/GST_CAPS_FEATURES_ANY/@.
-- 
-- Once a track has been added to a t'GI.GES.Objects.Timeline.Timeline', you should not change
-- this.
-- 
-- Default value: @/GST_CAPS_ANY/@.

#if defined(ENABLE_OVERLOADING)
    TrackCapsPropertyInfo                   ,
#endif
    constructTrackCaps                      ,
    getTrackCaps                            ,
#if defined(ENABLE_OVERLOADING)
    trackCaps                               ,
#endif


-- ** duration #attr:duration#
-- | Current duration of the track
-- 
-- Default value: O

#if defined(ENABLE_OVERLOADING)
    TrackDurationPropertyInfo               ,
#endif
    getTrackDuration                        ,
#if defined(ENABLE_OVERLOADING)
    trackDuration                           ,
#endif


-- ** id #attr:id#
-- | The @/nlecomposition:id/@ of the underlying @/nlecomposition/@.
-- 
-- /Since: 1.18/

#if defined(ENABLE_OVERLOADING)
    TrackIdPropertyInfo                     ,
#endif
    clearTrackId                            ,
    constructTrackId                        ,
    getTrackId                              ,
    setTrackId                              ,
#if defined(ENABLE_OVERLOADING)
    trackId                                 ,
#endif


-- ** mixing #attr:mixing#
-- | Whether the track should support the mixing of t'GI.GES.Objects.Layer.Layer' data, such
-- as composing the video data of each layer (when part of the video
-- data is transparent, the next layer will become visible) or adding
-- together the audio data. As such, for audio and video tracks, you\'ll
-- likely want to keep this set to 'P.True'.

#if defined(ENABLE_OVERLOADING)
    TrackMixingPropertyInfo                 ,
#endif
    constructTrackMixing                    ,
    getTrackMixing                          ,
    setTrackMixing                          ,
#if defined(ENABLE_OVERLOADING)
    trackMixing                             ,
#endif


-- ** restrictionCaps #attr:restrictionCaps#
-- | The capabilities that specifies the final output format of the
-- t'GI.GES.Objects.Track.Track'. For example, for a video track, it would specify the
-- height, width, framerate and other properties of the stream.
-- 
-- You may change this property after the track has been added to a
-- t'GI.GES.Objects.Timeline.Timeline', but it must remain compatible with the track\'s
-- [Track:caps]("GI.GES.Objects.Track#g:attr:caps").
-- 
-- Default value: @/GST_CAPS_ANY/@.

#if defined(ENABLE_OVERLOADING)
    TrackRestrictionCapsPropertyInfo        ,
#endif
    constructTrackRestrictionCaps           ,
    getTrackRestrictionCaps                 ,
    setTrackRestrictionCaps                 ,
#if defined(ENABLE_OVERLOADING)
    trackRestrictionCaps                    ,
#endif


-- ** trackType #attr:trackType#
-- | The track type of the track. This controls the type of
-- t'GI.GES.Objects.TrackElement.TrackElement'-s that can be added to the track. This should
-- match with the track\'s [Track:caps]("GI.GES.Objects.Track#g:attr:caps").
-- 
-- Once a track has been added to a t'GI.GES.Objects.Timeline.Timeline', you should not change
-- this.

#if defined(ENABLE_OVERLOADING)
    TrackTrackTypePropertyInfo              ,
#endif
    constructTrackTrackType                 ,
    getTrackTrackType                       ,
#if defined(ENABLE_OVERLOADING)
    trackTrackType                          ,
#endif




 -- * Signals


-- ** commited #signal:commited#

    TrackCommitedCallback                   ,
#if defined(ENABLE_OVERLOADING)
    TrackCommitedSignalInfo                 ,
#endif
    afterTrackCommited                      ,
    onTrackCommited                         ,


-- ** trackElementAdded #signal:trackElementAdded#

    TrackTrackElementAddedCallback          ,
#if defined(ENABLE_OVERLOADING)
    TrackTrackElementAddedSignalInfo        ,
#endif
    afterTrackTrackElementAdded             ,
    onTrackTrackElementAdded                ,


-- ** trackElementRemoved #signal:trackElementRemoved#

    TrackTrackElementRemovedCallback        ,
#if defined(ENABLE_OVERLOADING)
    TrackTrackElementRemovedSignalInfo      ,
#endif
    afterTrackTrackElementRemoved           ,
    onTrackTrackElementRemoved              ,




    ) 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.Flags as GES.Flags
import {-# SOURCE #-} qualified GI.GES.Interfaces.MetaContainer as GES.MetaContainer
import {-# SOURCE #-} qualified GI.GES.Objects.Timeline as GES.Timeline
import {-# SOURCE #-} qualified GI.GES.Objects.TrackElement as GES.TrackElement
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Interfaces.ChildProxy as Gst.ChildProxy
import qualified GI.Gst.Objects.Bin as Gst.Bin
import qualified GI.Gst.Objects.Element as Gst.Element
import qualified GI.Gst.Objects.Object as Gst.Object
import qualified GI.Gst.Structs.Caps as Gst.Caps

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

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

foreign import ccall "ges_track_get_type"
    c_ges_track_get_type :: IO B.Types.GType

instance B.Types.TypedObject Track where
    glibType :: IO GType
glibType = IO GType
c_ges_track_get_type

instance B.Types.GObject Track

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

instance O.HasParentTypes Track
type instance O.ParentTypes Track = '[Gst.Bin.Bin, Gst.Element.Element, Gst.Object.Object, GObject.Object.Object, GES.MetaContainer.MetaContainer, Gst.ChildProxy.ChildProxy]

-- | Cast to `Track`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTrack :: (MIO.MonadIO m, IsTrack o) => o -> m Track
toTrack :: forall (m :: * -> *) o. (MonadIO m, IsTrack o) => o -> m Track
toTrack = 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 Track -> Track
Track

-- | Convert 'Track' 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 Track) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ges_track_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Track -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Track
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 Track)
    gvalueSet_ Ptr GValue
gv (P.Just Track
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Track
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Track)
gvalueGet_ Ptr GValue
gv = do
        Ptr Track
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Track)
        if Ptr Track
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 Track -> Track
Track Ptr Track
ptr
        else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveTrackMethod (t :: Symbol) (o :: *) :: * where
    ResolveTrackMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo
    ResolveTrackMethod "add" o = Gst.Bin.BinAddMethodInfo
    ResolveTrackMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolveTrackMethod "addElement" o = TrackAddElementMethodInfo
    ResolveTrackMethod "addElementFull" o = TrackAddElementFullMethodInfo
    ResolveTrackMethod "addMetasFromString" o = GES.MetaContainer.MetaContainerAddMetasFromStringMethodInfo
    ResolveTrackMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo
    ResolveTrackMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo
    ResolveTrackMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo
    ResolveTrackMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTrackMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTrackMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo
    ResolveTrackMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo
    ResolveTrackMethod "checkMetaRegistered" o = GES.MetaContainer.MetaContainerCheckMetaRegisteredMethodInfo
    ResolveTrackMethod "childAdded" o = Gst.ChildProxy.ChildProxyChildAddedMethodInfo
    ResolveTrackMethod "childRemoved" o = Gst.ChildProxy.ChildProxyChildRemovedMethodInfo
    ResolveTrackMethod "commit" o = TrackCommitMethodInfo
    ResolveTrackMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo
    ResolveTrackMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo
    ResolveTrackMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolveTrackMethod "findUnlinkedPad" o = Gst.Bin.BinFindUnlinkedPadMethodInfo
    ResolveTrackMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTrackMethod "foreach" o = GES.MetaContainer.MetaContainerForeachMethodInfo
    ResolveTrackMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo
    ResolveTrackMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo
    ResolveTrackMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo
    ResolveTrackMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTrackMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTrackMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolveTrackMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolveTrackMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolveTrackMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolveTrackMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTrackMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo
    ResolveTrackMethod "iterateAllByElementFactoryName" o = Gst.Bin.BinIterateAllByElementFactoryNameMethodInfo
    ResolveTrackMethod "iterateAllByInterface" o = Gst.Bin.BinIterateAllByInterfaceMethodInfo
    ResolveTrackMethod "iterateElements" o = Gst.Bin.BinIterateElementsMethodInfo
    ResolveTrackMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo
    ResolveTrackMethod "iterateRecurse" o = Gst.Bin.BinIterateRecurseMethodInfo
    ResolveTrackMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo
    ResolveTrackMethod "iterateSinks" o = Gst.Bin.BinIterateSinksMethodInfo
    ResolveTrackMethod "iterateSorted" o = Gst.Bin.BinIterateSortedMethodInfo
    ResolveTrackMethod "iterateSources" o = Gst.Bin.BinIterateSourcesMethodInfo
    ResolveTrackMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo
    ResolveTrackMethod "link" o = Gst.Element.ElementLinkMethodInfo
    ResolveTrackMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo
    ResolveTrackMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo
    ResolveTrackMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo
    ResolveTrackMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo
    ResolveTrackMethod "lookup" o = Gst.ChildProxy.ChildProxyLookupMethodInfo
    ResolveTrackMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo
    ResolveTrackMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo
    ResolveTrackMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo
    ResolveTrackMethod "metasToString" o = GES.MetaContainer.MetaContainerMetasToStringMethodInfo
    ResolveTrackMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo
    ResolveTrackMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTrackMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTrackMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo
    ResolveTrackMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo
    ResolveTrackMethod "query" o = Gst.Element.ElementQueryMethodInfo
    ResolveTrackMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo
    ResolveTrackMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo
    ResolveTrackMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo
    ResolveTrackMethod "recalculateLatency" o = Gst.Bin.BinRecalculateLatencyMethodInfo
    ResolveTrackMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolveTrackMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTrackMethod "registerMeta" o = GES.MetaContainer.MetaContainerRegisterMetaMethodInfo
    ResolveTrackMethod "registerMetaBoolean" o = GES.MetaContainer.MetaContainerRegisterMetaBooleanMethodInfo
    ResolveTrackMethod "registerMetaDate" o = GES.MetaContainer.MetaContainerRegisterMetaDateMethodInfo
    ResolveTrackMethod "registerMetaDateTime" o = GES.MetaContainer.MetaContainerRegisterMetaDateTimeMethodInfo
    ResolveTrackMethod "registerMetaDouble" o = GES.MetaContainer.MetaContainerRegisterMetaDoubleMethodInfo
    ResolveTrackMethod "registerMetaFloat" o = GES.MetaContainer.MetaContainerRegisterMetaFloatMethodInfo
    ResolveTrackMethod "registerMetaInt" o = GES.MetaContainer.MetaContainerRegisterMetaIntMethodInfo
    ResolveTrackMethod "registerMetaInt64" o = GES.MetaContainer.MetaContainerRegisterMetaInt64MethodInfo
    ResolveTrackMethod "registerMetaString" o = GES.MetaContainer.MetaContainerRegisterMetaStringMethodInfo
    ResolveTrackMethod "registerMetaUint" o = GES.MetaContainer.MetaContainerRegisterMetaUintMethodInfo
    ResolveTrackMethod "registerMetaUint64" o = GES.MetaContainer.MetaContainerRegisterMetaUint64MethodInfo
    ResolveTrackMethod "registerStaticMeta" o = GES.MetaContainer.MetaContainerRegisterStaticMetaMethodInfo
    ResolveTrackMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo
    ResolveTrackMethod "remove" o = Gst.Bin.BinRemoveMethodInfo
    ResolveTrackMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolveTrackMethod "removeElement" o = TrackRemoveElementMethodInfo
    ResolveTrackMethod "removeElementFull" o = TrackRemoveElementFullMethodInfo
    ResolveTrackMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo
    ResolveTrackMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo
    ResolveTrackMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo
    ResolveTrackMethod "requestPadSimple" o = Gst.Element.ElementRequestPadSimpleMethodInfo
    ResolveTrackMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTrackMethod "seek" o = Gst.Element.ElementSeekMethodInfo
    ResolveTrackMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo
    ResolveTrackMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo
    ResolveTrackMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTrackMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTrackMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolveTrackMethod "syncChildrenStates" o = Gst.Bin.BinSyncChildrenStatesMethodInfo
    ResolveTrackMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo
    ResolveTrackMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolveTrackMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTrackMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo
    ResolveTrackMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo
    ResolveTrackMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolveTrackMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolveTrackMethod "updateRestrictionCaps" o = TrackUpdateRestrictionCapsMethodInfo
    ResolveTrackMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTrackMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo
    ResolveTrackMethod "getBoolean" o = GES.MetaContainer.MetaContainerGetBooleanMethodInfo
    ResolveTrackMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo
    ResolveTrackMethod "getByInterface" o = Gst.Bin.BinGetByInterfaceMethodInfo
    ResolveTrackMethod "getByName" o = Gst.Bin.BinGetByNameMethodInfo
    ResolveTrackMethod "getByNameRecurseUp" o = Gst.Bin.BinGetByNameRecurseUpMethodInfo
    ResolveTrackMethod "getCaps" o = TrackGetCapsMethodInfo
    ResolveTrackMethod "getChildByIndex" o = Gst.ChildProxy.ChildProxyGetChildByIndexMethodInfo
    ResolveTrackMethod "getChildByName" o = Gst.ChildProxy.ChildProxyGetChildByNameMethodInfo
    ResolveTrackMethod "getChildrenCount" o = Gst.ChildProxy.ChildProxyGetChildrenCountMethodInfo
    ResolveTrackMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo
    ResolveTrackMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo
    ResolveTrackMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo
    ResolveTrackMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo
    ResolveTrackMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo
    ResolveTrackMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo
    ResolveTrackMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolveTrackMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolveTrackMethod "getCurrentClockTime" o = Gst.Element.ElementGetCurrentClockTimeMethodInfo
    ResolveTrackMethod "getCurrentRunningTime" o = Gst.Element.ElementGetCurrentRunningTimeMethodInfo
    ResolveTrackMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTrackMethod "getDate" o = GES.MetaContainer.MetaContainerGetDateMethodInfo
    ResolveTrackMethod "getDateTime" o = GES.MetaContainer.MetaContainerGetDateTimeMethodInfo
    ResolveTrackMethod "getDouble" o = GES.MetaContainer.MetaContainerGetDoubleMethodInfo
    ResolveTrackMethod "getElements" o = TrackGetElementsMethodInfo
    ResolveTrackMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo
    ResolveTrackMethod "getFloat" o = GES.MetaContainer.MetaContainerGetFloatMethodInfo
    ResolveTrackMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolveTrackMethod "getInt" o = GES.MetaContainer.MetaContainerGetIntMethodInfo
    ResolveTrackMethod "getInt64" o = GES.MetaContainer.MetaContainerGetInt64MethodInfo
    ResolveTrackMethod "getMarkerList" o = GES.MetaContainer.MetaContainerGetMarkerListMethodInfo
    ResolveTrackMethod "getMeta" o = GES.MetaContainer.MetaContainerGetMetaMethodInfo
    ResolveTrackMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo
    ResolveTrackMethod "getMixing" o = TrackGetMixingMethodInfo
    ResolveTrackMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolveTrackMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo
    ResolveTrackMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo
    ResolveTrackMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolveTrackMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolveTrackMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTrackMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTrackMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo
    ResolveTrackMethod "getRestrictionCaps" o = TrackGetRestrictionCapsMethodInfo
    ResolveTrackMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo
    ResolveTrackMethod "getState" o = Gst.Element.ElementGetStateMethodInfo
    ResolveTrackMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo
    ResolveTrackMethod "getString" o = GES.MetaContainer.MetaContainerGetStringMethodInfo
    ResolveTrackMethod "getSuppressedFlags" o = Gst.Bin.BinGetSuppressedFlagsMethodInfo
    ResolveTrackMethod "getTimeline" o = TrackGetTimelineMethodInfo
    ResolveTrackMethod "getUint" o = GES.MetaContainer.MetaContainerGetUintMethodInfo
    ResolveTrackMethod "getUint64" o = GES.MetaContainer.MetaContainerGetUint64MethodInfo
    ResolveTrackMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolveTrackMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo
    ResolveTrackMethod "setBoolean" o = GES.MetaContainer.MetaContainerSetBooleanMethodInfo
    ResolveTrackMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo
    ResolveTrackMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo
    ResolveTrackMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo
    ResolveTrackMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolveTrackMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolveTrackMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolveTrackMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTrackMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTrackMethod "setDate" o = GES.MetaContainer.MetaContainerSetDateMethodInfo
    ResolveTrackMethod "setDateTime" o = GES.MetaContainer.MetaContainerSetDateTimeMethodInfo
    ResolveTrackMethod "setDouble" o = GES.MetaContainer.MetaContainerSetDoubleMethodInfo
    ResolveTrackMethod "setFloat" o = GES.MetaContainer.MetaContainerSetFloatMethodInfo
    ResolveTrackMethod "setInt" o = GES.MetaContainer.MetaContainerSetIntMethodInfo
    ResolveTrackMethod "setInt64" o = GES.MetaContainer.MetaContainerSetInt64MethodInfo
    ResolveTrackMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo
    ResolveTrackMethod "setMarkerList" o = GES.MetaContainer.MetaContainerSetMarkerListMethodInfo
    ResolveTrackMethod "setMeta" o = GES.MetaContainer.MetaContainerSetMetaMethodInfo
    ResolveTrackMethod "setMixing" o = TrackSetMixingMethodInfo
    ResolveTrackMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolveTrackMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolveTrackMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTrackMethod "setRestrictionCaps" o = TrackSetRestrictionCapsMethodInfo
    ResolveTrackMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo
    ResolveTrackMethod "setState" o = Gst.Element.ElementSetStateMethodInfo
    ResolveTrackMethod "setString" o = GES.MetaContainer.MetaContainerSetStringMethodInfo
    ResolveTrackMethod "setSuppressedFlags" o = Gst.Bin.BinSetSuppressedFlagsMethodInfo
    ResolveTrackMethod "setTimeline" o = TrackSetTimelineMethodInfo
    ResolveTrackMethod "setUint" o = GES.MetaContainer.MetaContainerSetUintMethodInfo
    ResolveTrackMethod "setUint64" o = GES.MetaContainer.MetaContainerSetUint64MethodInfo
    ResolveTrackMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal Track::commited
-- | This signal will be emitted once the changes initiated by
-- 'GI.GES.Objects.Track.trackCommit' have been executed in the backend. In particular,
-- this will be emitted whenever the underlying @/nlecomposition/@ has been
-- committed (see @/nlecomposition::commited/@).
type TrackCommitedCallback =
    IO ()

type C_TrackCommitedCallback =
    Ptr Track ->                            -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TrackCommitedCallback :: 
    GObject a => (a -> TrackCommitedCallback) ->
    C_TrackCommitedCallback
wrap_TrackCommitedCallback :: forall a. GObject a => (a -> IO ()) -> C_TrackCommitedCallback
wrap_TrackCommitedCallback a -> IO ()
gi'cb Ptr Track
gi'selfPtr Ptr ()
_ = do
    forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Track
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \Track
gi'self -> a -> IO ()
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce Track
gi'self) 


-- | Connect a signal handler for the [commited](#signal:commited) 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' track #commited callback
-- @
-- 
-- 
onTrackCommited :: (IsTrack a, MonadIO m) => a -> ((?self :: a) => TrackCommitedCallback) -> m SignalHandlerId
onTrackCommited :: forall a (m :: * -> *).
(IsTrack a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onTrackCommited a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
    let wrapped' :: C_TrackCommitedCallback
wrapped' = forall a. GObject a => (a -> IO ()) -> C_TrackCommitedCallback
wrap_TrackCommitedCallback a -> IO ()
wrapped
    FunPtr C_TrackCommitedCallback
wrapped'' <- C_TrackCommitedCallback -> IO (FunPtr C_TrackCommitedCallback)
mk_TrackCommitedCallback C_TrackCommitedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"commited" FunPtr C_TrackCommitedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing

-- | Connect a signal handler for the [commited](#signal:commited) 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' track #commited 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.
-- 
afterTrackCommited :: (IsTrack a, MonadIO m) => a -> ((?self :: a) => TrackCommitedCallback) -> m SignalHandlerId
afterTrackCommited :: forall a (m :: * -> *).
(IsTrack a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterTrackCommited a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
    let wrapped' :: C_TrackCommitedCallback
wrapped' = forall a. GObject a => (a -> IO ()) -> C_TrackCommitedCallback
wrap_TrackCommitedCallback a -> IO ()
wrapped
    FunPtr C_TrackCommitedCallback
wrapped'' <- C_TrackCommitedCallback -> IO (FunPtr C_TrackCommitedCallback)
mk_TrackCommitedCallback C_TrackCommitedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"commited" FunPtr C_TrackCommitedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TrackCommitedSignalInfo
instance SignalInfo TrackCommitedSignalInfo where
    type HaskellCallbackType TrackCommitedSignalInfo = TrackCommitedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TrackCommitedCallback cb
        cb'' <- mk_TrackCommitedCallback cb'
        connectSignalFunPtr obj "commited" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Track::commited"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-Track.html#g:signal:commited"})

#endif

-- signal Track::track-element-added
-- | Will be emitted after a track element is added to the track.
type TrackTrackElementAddedCallback =
    GES.TrackElement.TrackElement
    -- ^ /@effect@/: The element that was added
    -> IO ()

type C_TrackTrackElementAddedCallback =
    Ptr Track ->                            -- object
    Ptr GES.TrackElement.TrackElement ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TrackTrackElementAddedCallback :: 
    GObject a => (a -> TrackTrackElementAddedCallback) ->
    C_TrackTrackElementAddedCallback
wrap_TrackTrackElementAddedCallback :: forall a.
GObject a =>
(a -> TrackTrackElementAddedCallback)
-> C_TrackTrackElementAddedCallback
wrap_TrackTrackElementAddedCallback a -> TrackTrackElementAddedCallback
gi'cb Ptr Track
gi'selfPtr Ptr TrackElement
effect Ptr ()
_ = do
    TrackElement
effect' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TrackElement -> TrackElement
GES.TrackElement.TrackElement) Ptr TrackElement
effect
    forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Track
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \Track
gi'self -> a -> TrackTrackElementAddedCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce Track
gi'self)  TrackElement
effect'


-- | Connect a signal handler for the [trackElementAdded](#signal:trackElementAdded) 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' track #trackElementAdded callback
-- @
-- 
-- 
onTrackTrackElementAdded :: (IsTrack a, MonadIO m) => a -> ((?self :: a) => TrackTrackElementAddedCallback) -> m SignalHandlerId
onTrackTrackElementAdded :: forall a (m :: * -> *).
(IsTrack a, MonadIO m) =>
a
-> ((?self::a) => TrackTrackElementAddedCallback)
-> m SignalHandlerId
onTrackTrackElementAdded a
obj (?self::a) => TrackTrackElementAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TrackTrackElementAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TrackTrackElementAddedCallback
cb
    let wrapped' :: C_TrackTrackElementAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TrackTrackElementAddedCallback)
-> C_TrackTrackElementAddedCallback
wrap_TrackTrackElementAddedCallback a -> TrackTrackElementAddedCallback
wrapped
    FunPtr C_TrackTrackElementAddedCallback
wrapped'' <- C_TrackTrackElementAddedCallback
-> IO (FunPtr C_TrackTrackElementAddedCallback)
mk_TrackTrackElementAddedCallback C_TrackTrackElementAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"track-element-added" FunPtr C_TrackTrackElementAddedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing

-- | Connect a signal handler for the [trackElementAdded](#signal:trackElementAdded) 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' track #trackElementAdded 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.
-- 
afterTrackTrackElementAdded :: (IsTrack a, MonadIO m) => a -> ((?self :: a) => TrackTrackElementAddedCallback) -> m SignalHandlerId
afterTrackTrackElementAdded :: forall a (m :: * -> *).
(IsTrack a, MonadIO m) =>
a
-> ((?self::a) => TrackTrackElementAddedCallback)
-> m SignalHandlerId
afterTrackTrackElementAdded a
obj (?self::a) => TrackTrackElementAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TrackTrackElementAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TrackTrackElementAddedCallback
cb
    let wrapped' :: C_TrackTrackElementAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TrackTrackElementAddedCallback)
-> C_TrackTrackElementAddedCallback
wrap_TrackTrackElementAddedCallback a -> TrackTrackElementAddedCallback
wrapped
    FunPtr C_TrackTrackElementAddedCallback
wrapped'' <- C_TrackTrackElementAddedCallback
-> IO (FunPtr C_TrackTrackElementAddedCallback)
mk_TrackTrackElementAddedCallback C_TrackTrackElementAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"track-element-added" FunPtr C_TrackTrackElementAddedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TrackTrackElementAddedSignalInfo
instance SignalInfo TrackTrackElementAddedSignalInfo where
    type HaskellCallbackType TrackTrackElementAddedSignalInfo = TrackTrackElementAddedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TrackTrackElementAddedCallback cb
        cb'' <- mk_TrackTrackElementAddedCallback cb'
        connectSignalFunPtr obj "track-element-added" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Track::track-element-added"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-Track.html#g:signal:trackElementAdded"})

#endif

-- signal Track::track-element-removed
-- | Will be emitted after a track element is removed from the track.
type TrackTrackElementRemovedCallback =
    GES.TrackElement.TrackElement
    -- ^ /@effect@/: The element that was removed
    -> IO ()

type C_TrackTrackElementRemovedCallback =
    Ptr Track ->                            -- object
    Ptr GES.TrackElement.TrackElement ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TrackTrackElementRemovedCallback :: 
    GObject a => (a -> TrackTrackElementRemovedCallback) ->
    C_TrackTrackElementRemovedCallback
wrap_TrackTrackElementRemovedCallback :: forall a.
GObject a =>
(a -> TrackTrackElementAddedCallback)
-> C_TrackTrackElementAddedCallback
wrap_TrackTrackElementRemovedCallback a -> TrackTrackElementAddedCallback
gi'cb Ptr Track
gi'selfPtr Ptr TrackElement
effect Ptr ()
_ = do
    TrackElement
effect' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TrackElement -> TrackElement
GES.TrackElement.TrackElement) Ptr TrackElement
effect
    forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Track
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \Track
gi'self -> a -> TrackTrackElementAddedCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce Track
gi'self)  TrackElement
effect'


-- | Connect a signal handler for the [trackElementRemoved](#signal:trackElementRemoved) 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' track #trackElementRemoved callback
-- @
-- 
-- 
onTrackTrackElementRemoved :: (IsTrack a, MonadIO m) => a -> ((?self :: a) => TrackTrackElementRemovedCallback) -> m SignalHandlerId
onTrackTrackElementRemoved :: forall a (m :: * -> *).
(IsTrack a, MonadIO m) =>
a
-> ((?self::a) => TrackTrackElementAddedCallback)
-> m SignalHandlerId
onTrackTrackElementRemoved a
obj (?self::a) => TrackTrackElementAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TrackTrackElementAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TrackTrackElementAddedCallback
cb
    let wrapped' :: C_TrackTrackElementAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TrackTrackElementAddedCallback)
-> C_TrackTrackElementAddedCallback
wrap_TrackTrackElementRemovedCallback a -> TrackTrackElementAddedCallback
wrapped
    FunPtr C_TrackTrackElementAddedCallback
wrapped'' <- C_TrackTrackElementAddedCallback
-> IO (FunPtr C_TrackTrackElementAddedCallback)
mk_TrackTrackElementRemovedCallback C_TrackTrackElementAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"track-element-removed" FunPtr C_TrackTrackElementAddedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing

-- | Connect a signal handler for the [trackElementRemoved](#signal:trackElementRemoved) 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' track #trackElementRemoved 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.
-- 
afterTrackTrackElementRemoved :: (IsTrack a, MonadIO m) => a -> ((?self :: a) => TrackTrackElementRemovedCallback) -> m SignalHandlerId
afterTrackTrackElementRemoved :: forall a (m :: * -> *).
(IsTrack a, MonadIO m) =>
a
-> ((?self::a) => TrackTrackElementAddedCallback)
-> m SignalHandlerId
afterTrackTrackElementRemoved a
obj (?self::a) => TrackTrackElementAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TrackTrackElementAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TrackTrackElementAddedCallback
cb
    let wrapped' :: C_TrackTrackElementAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TrackTrackElementAddedCallback)
-> C_TrackTrackElementAddedCallback
wrap_TrackTrackElementRemovedCallback a -> TrackTrackElementAddedCallback
wrapped
    FunPtr C_TrackTrackElementAddedCallback
wrapped'' <- C_TrackTrackElementAddedCallback
-> IO (FunPtr C_TrackTrackElementAddedCallback)
mk_TrackTrackElementRemovedCallback C_TrackTrackElementAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"track-element-removed" FunPtr C_TrackTrackElementAddedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TrackTrackElementRemovedSignalInfo
instance SignalInfo TrackTrackElementRemovedSignalInfo where
    type HaskellCallbackType TrackTrackElementRemovedSignalInfo = TrackTrackElementRemovedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TrackTrackElementRemovedCallback cb
        cb'' <- mk_TrackTrackElementRemovedCallback cb'
        connectSignalFunPtr obj "track-element-removed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Track::track-element-removed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-Track.html#g:signal:trackElementRemoved"})

#endif

-- VVV Prop "caps"
   -- Type: TInterface (Name {namespace = "Gst", name = "Caps"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@caps@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' track #caps
-- @
getTrackCaps :: (MonadIO m, IsTrack o) => o -> m Gst.Caps.Caps
getTrackCaps :: forall (m :: * -> *) o. (MonadIO m, IsTrack o) => o -> m Caps
getTrackCaps o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getTrackCaps" forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"caps" ManagedPtr Caps -> Caps
Gst.Caps.Caps

-- | Construct a `GValueConstruct` with valid value for the “@caps@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTrackCaps :: (IsTrack o, MIO.MonadIO m) => Gst.Caps.Caps -> m (GValueConstruct o)
constructTrackCaps :: forall o (m :: * -> *).
(IsTrack o, MonadIO m) =>
Caps -> m (GValueConstruct o)
constructTrackCaps Caps
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. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"caps" (forall a. a -> Maybe a
P.Just Caps
val)

#if defined(ENABLE_OVERLOADING)
data TrackCapsPropertyInfo
instance AttrInfo TrackCapsPropertyInfo where
    type AttrAllowedOps TrackCapsPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TrackCapsPropertyInfo = IsTrack
    type AttrSetTypeConstraint TrackCapsPropertyInfo = (~) Gst.Caps.Caps
    type AttrTransferTypeConstraint TrackCapsPropertyInfo = (~) Gst.Caps.Caps
    type AttrTransferType TrackCapsPropertyInfo = Gst.Caps.Caps
    type AttrGetType TrackCapsPropertyInfo = Gst.Caps.Caps
    type AttrLabel TrackCapsPropertyInfo = "caps"
    type AttrOrigin TrackCapsPropertyInfo = Track
    attrGet = getTrackCaps
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructTrackCaps
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Track.caps"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-Track.html#g:attr:caps"
        })
#endif

-- VVV Prop "duration"
   -- Type: TBasicType TUInt64
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' track #duration
-- @
getTrackDuration :: (MonadIO m, IsTrack o) => o -> m Word64
getTrackDuration :: forall (m :: * -> *) o. (MonadIO m, IsTrack o) => o -> m Word64
getTrackDuration 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 Word64
B.Properties.getObjectPropertyUInt64 o
obj String
"duration"

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

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

-- | Get the value of the “@id@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' track #id
-- @
getTrackId :: (MonadIO m, IsTrack o) => o -> m (Maybe T.Text)
getTrackId :: forall (m :: * -> *) o.
(MonadIO m, IsTrack o) =>
o -> m (Maybe Text)
getTrackId 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 (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"id"

-- | Set the value of the “@id@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' track [ #id 'Data.GI.Base.Attributes.:=' value ]
-- @
setTrackId :: (MonadIO m, IsTrack o) => o -> T.Text -> m ()
setTrackId :: forall (m :: * -> *) o. (MonadIO m, IsTrack o) => o -> Text -> m ()
setTrackId o
obj Text
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 -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"id" (forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTrackId :: (IsTrack o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructTrackId :: forall o (m :: * -> *).
(IsTrack o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructTrackId Text
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 -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"id" (forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@id@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #id
-- @
clearTrackId :: (MonadIO m, IsTrack o) => o -> m ()
clearTrackId :: forall (m :: * -> *) o. (MonadIO m, IsTrack o) => o -> m ()
clearTrackId o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"id" (forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data TrackIdPropertyInfo
instance AttrInfo TrackIdPropertyInfo where
    type AttrAllowedOps TrackIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TrackIdPropertyInfo = IsTrack
    type AttrSetTypeConstraint TrackIdPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint TrackIdPropertyInfo = (~) T.Text
    type AttrTransferType TrackIdPropertyInfo = T.Text
    type AttrGetType TrackIdPropertyInfo = (Maybe T.Text)
    type AttrLabel TrackIdPropertyInfo = "id"
    type AttrOrigin TrackIdPropertyInfo = Track
    attrGet = getTrackId
    attrSet = setTrackId
    attrTransfer _ v = do
        return v
    attrConstruct = constructTrackId
    attrClear = clearTrackId
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Track.id"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-Track.html#g:attr:id"
        })
#endif

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

-- | Get the value of the “@mixing@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' track #mixing
-- @
getTrackMixing :: (MonadIO m, IsTrack o) => o -> m Bool
getTrackMixing :: forall (m :: * -> *) o. (MonadIO m, IsTrack o) => o -> m Bool
getTrackMixing 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
"mixing"

-- | Set the value of the “@mixing@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' track [ #mixing 'Data.GI.Base.Attributes.:=' value ]
-- @
setTrackMixing :: (MonadIO m, IsTrack o) => o -> Bool -> m ()
setTrackMixing :: forall (m :: * -> *) o. (MonadIO m, IsTrack o) => o -> Bool -> m ()
setTrackMixing 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
"mixing" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@mixing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTrackMixing :: (IsTrack o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTrackMixing :: forall o (m :: * -> *).
(IsTrack o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTrackMixing 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
"mixing" Bool
val

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

-- VVV Prop "restriction-caps"
   -- Type: TInterface (Name {namespace = "Gst", name = "Caps"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

-- | Get the value of the “@restriction-caps@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' track #restrictionCaps
-- @
getTrackRestrictionCaps :: (MonadIO m, IsTrack o) => o -> m (Maybe Gst.Caps.Caps)
getTrackRestrictionCaps :: forall (m :: * -> *) o.
(MonadIO m, IsTrack o) =>
o -> m (Maybe Caps)
getTrackRestrictionCaps 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, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"restriction-caps" ManagedPtr Caps -> Caps
Gst.Caps.Caps

-- | Set the value of the “@restriction-caps@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' track [ #restrictionCaps 'Data.GI.Base.Attributes.:=' value ]
-- @
setTrackRestrictionCaps :: (MonadIO m, IsTrack o) => o -> Gst.Caps.Caps -> m ()
setTrackRestrictionCaps :: forall (m :: * -> *) o. (MonadIO m, IsTrack o) => o -> Caps -> m ()
setTrackRestrictionCaps o
obj Caps
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"restriction-caps" (forall a. a -> Maybe a
Just Caps
val)

-- | Construct a `GValueConstruct` with valid value for the “@restriction-caps@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTrackRestrictionCaps :: (IsTrack o, MIO.MonadIO m) => Gst.Caps.Caps -> m (GValueConstruct o)
constructTrackRestrictionCaps :: forall o (m :: * -> *).
(IsTrack o, MonadIO m) =>
Caps -> m (GValueConstruct o)
constructTrackRestrictionCaps Caps
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. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"restriction-caps" (forall a. a -> Maybe a
P.Just Caps
val)

#if defined(ENABLE_OVERLOADING)
data TrackRestrictionCapsPropertyInfo
instance AttrInfo TrackRestrictionCapsPropertyInfo where
    type AttrAllowedOps TrackRestrictionCapsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TrackRestrictionCapsPropertyInfo = IsTrack
    type AttrSetTypeConstraint TrackRestrictionCapsPropertyInfo = (~) Gst.Caps.Caps
    type AttrTransferTypeConstraint TrackRestrictionCapsPropertyInfo = (~) Gst.Caps.Caps
    type AttrTransferType TrackRestrictionCapsPropertyInfo = Gst.Caps.Caps
    type AttrGetType TrackRestrictionCapsPropertyInfo = (Maybe Gst.Caps.Caps)
    type AttrLabel TrackRestrictionCapsPropertyInfo = "restriction-caps"
    type AttrOrigin TrackRestrictionCapsPropertyInfo = Track
    attrGet = getTrackRestrictionCaps
    attrSet = setTrackRestrictionCaps
    attrTransfer _ v = do
        return v
    attrConstruct = constructTrackRestrictionCaps
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Track.restrictionCaps"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-Track.html#g:attr:restrictionCaps"
        })
#endif

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

-- | 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' track #trackType
-- @
getTrackTrackType :: (MonadIO m, IsTrack o) => o -> m [GES.Flags.TrackType]
getTrackTrackType :: forall (m :: * -> *) o.
(MonadIO m, IsTrack o) =>
o -> m [TrackType]
getTrackTrackType 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"

-- | 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`.
constructTrackTrackType :: (IsTrack o, MIO.MonadIO m) => [GES.Flags.TrackType] -> m (GValueConstruct o)
constructTrackTrackType :: forall o (m :: * -> *).
(IsTrack o, MonadIO m) =>
[TrackType] -> m (GValueConstruct o)
constructTrackTrackType [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 TrackTrackTypePropertyInfo
instance AttrInfo TrackTrackTypePropertyInfo where
    type AttrAllowedOps TrackTrackTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TrackTrackTypePropertyInfo = IsTrack
    type AttrSetTypeConstraint TrackTrackTypePropertyInfo = (~) [GES.Flags.TrackType]
    type AttrTransferTypeConstraint TrackTrackTypePropertyInfo = (~) [GES.Flags.TrackType]
    type AttrTransferType TrackTrackTypePropertyInfo = [GES.Flags.TrackType]
    type AttrGetType TrackTrackTypePropertyInfo = [GES.Flags.TrackType]
    type AttrLabel TrackTrackTypePropertyInfo = "track-type"
    type AttrOrigin TrackTrackTypePropertyInfo = Track
    attrGet = getTrackTrackType
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructTrackTrackType
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Track.trackType"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-Track.html#g:attr:trackType"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Track
type instance O.AttributeList Track = TrackAttributeList
type TrackAttributeList = ('[ '("asyncHandling", Gst.Bin.BinAsyncHandlingPropertyInfo), '("caps", TrackCapsPropertyInfo), '("duration", TrackDurationPropertyInfo), '("id", TrackIdPropertyInfo), '("messageForward", Gst.Bin.BinMessageForwardPropertyInfo), '("mixing", TrackMixingPropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("restrictionCaps", TrackRestrictionCapsPropertyInfo), '("trackType", TrackTrackTypePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
trackCaps :: AttrLabelProxy "caps"
trackCaps = AttrLabelProxy

trackDuration :: AttrLabelProxy "duration"
trackDuration = AttrLabelProxy

trackId :: AttrLabelProxy "id"
trackId = AttrLabelProxy

trackMixing :: AttrLabelProxy "mixing"
trackMixing = AttrLabelProxy

trackRestrictionCaps :: AttrLabelProxy "restrictionCaps"
trackRestrictionCaps = AttrLabelProxy

trackTrackType :: AttrLabelProxy "trackType"
trackTrackType = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Track = TrackSignalList
type TrackSignalList = ('[ '("childAdded", Gst.ChildProxy.ChildProxyChildAddedSignalInfo), '("childRemoved", Gst.ChildProxy.ChildProxyChildRemovedSignalInfo), '("commited", TrackCommitedSignalInfo), '("deepElementAdded", Gst.Bin.BinDeepElementAddedSignalInfo), '("deepElementRemoved", Gst.Bin.BinDeepElementRemovedSignalInfo), '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("doLatency", Gst.Bin.BinDoLatencySignalInfo), '("elementAdded", Gst.Bin.BinElementAddedSignalInfo), '("elementRemoved", Gst.Bin.BinElementRemovedSignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("notifyMeta", GES.MetaContainer.MetaContainerNotifyMetaSignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo), '("trackElementAdded", TrackTrackElementAddedSignalInfo), '("trackElementRemoved", TrackTrackElementRemovedSignalInfo)] :: [(Symbol, *)])

#endif

-- method Track::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "type"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTrack:track-type for the track"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "caps"
--           , argType = TInterface Name { namespace = "Gst" , name = "Caps" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTrack:caps for the track"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GES" , name = "Track" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_track_new" ges_track_new :: 
    CUInt ->                                -- type : TInterface (Name {namespace = "GES", name = "TrackType"})
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO (Ptr Track)

-- | Creates a new track with the given track-type and caps.
-- 
-- If /@type@/ is @/GES_TRACK_TYPE_VIDEO/@, and /@caps@/ is a subset of
-- \"video\/x-raw(ANY)\", then a t'GI.GES.Objects.VideoTrack.VideoTrack' is created. This will
-- automatically choose a gap creation method suitable for video data. You
-- will likely want to set [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps") separately. You may
-- prefer to use the 'GI.GES.Objects.VideoTrack.videoTrackNew' method instead.
-- 
-- If /@type@/ is @/GES_TRACK_TYPE_AUDIO/@, and /@caps@/ is a subset of
-- \"audio\/x-raw(ANY)\", then a t'GI.GES.Objects.AudioTrack.AudioTrack' is created. This will
-- automatically choose a gap creation method suitable for audio data, and
-- will set the [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps") to the default for
-- t'GI.GES.Objects.AudioTrack.AudioTrack'. You may prefer to use the 'GI.GES.Objects.AudioTrack.audioTrackNew' method
-- instead.
-- 
-- Otherwise, a plain t'GI.GES.Objects.Track.Track' is returned. You will likely want to set
-- the [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps") and call
-- @/ges_track_set_create_element_for_gap_func()/@ on the returned track.
trackNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    [GES.Flags.TrackType]
    -- ^ /@type@/: The [Track:trackType]("GI.GES.Objects.Track#g:attr:trackType") for the track
    -> Gst.Caps.Caps
    -- ^ /@caps@/: The [Track:caps]("GI.GES.Objects.Track#g:attr:caps") for the track
    -> m Track
    -- ^ __Returns:__ A new track.
trackNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[TrackType] -> Caps -> m Track
trackNew [TrackType]
type_ Caps
caps = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let type_' :: CUInt
type_' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TrackType]
type_
    Ptr Caps
caps' <- forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Caps
caps
    Ptr Track
result <- CUInt -> Ptr Caps -> IO (Ptr Track)
ges_track_new CUInt
type_' Ptr Caps
caps'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"trackNew" Ptr Track
result
    Track
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Track -> Track
Track) Ptr Track
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
    forall (m :: * -> *) a. Monad m => a -> m a
return Track
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Track::add_element
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "track"
--           , argType = TInterface Name { namespace = "GES" , name = "Track" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrack" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The element to add" , 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_add_element" ges_track_add_element :: 
    Ptr Track ->                            -- track : TInterface (Name {namespace = "GES", name = "Track"})
    Ptr GES.TrackElement.TrackElement ->    -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    IO CInt

-- | See 'GI.GES.Objects.Track.trackAddElement', which also gives an error.
trackAddElement ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a, GES.TrackElement.IsTrackElement b) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> b
    -- ^ /@object@/: The element to add
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@object@/ was successfully added to /@track@/.
trackAddElement :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTrack a, IsTrackElement b) =>
a -> b -> m Bool
trackAddElement a
track b
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
object
    CInt
result <- Ptr Track -> Ptr TrackElement -> IO CInt
ges_track_add_element Ptr Track
track' 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
track
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackAddElementMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsTrack a, GES.TrackElement.IsTrackElement b) => O.OverloadedMethod TrackAddElementMethodInfo a signature where
    overloadedMethod = trackAddElement

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


#endif

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

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

-- | Adds the given track element to the track, which takes ownership of the
-- element.
-- 
-- Note that this can fail if it would break a configuration rule of the
-- track\'s t'GI.GES.Objects.Timeline.Timeline'.
-- 
-- Note that a t'GI.GES.Objects.TrackElement.TrackElement' can only be added to one track.
-- 
-- /Since: 1.18/
trackAddElementFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a, GES.TrackElement.IsTrackElement b) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> b
    -- ^ /@object@/: The element to add
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
trackAddElementFull :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTrack a, IsTrackElement b) =>
a -> b -> m ()
trackAddElementFull a
track b
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
object
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Track -> Ptr TrackElement -> Ptr (Ptr GError) -> IO CInt
ges_track_add_element_full Ptr Track
track' Ptr TrackElement
object'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
object
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TrackAddElementFullMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTrack a, GES.TrackElement.IsTrackElement b) => O.OverloadedMethod TrackAddElementFullMethodInfo a signature where
    overloadedMethod = trackAddElementFull

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


#endif

-- method Track::commit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "track"
--           , argType = TInterface Name { namespace = "GES" , name = "Track" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrack" , 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_commit" ges_track_commit :: 
    Ptr Track ->                            -- track : TInterface (Name {namespace = "GES", name = "Track"})
    IO CInt

-- | Commits all the pending changes for the elements contained in the
-- track.
-- 
-- When changes are made to the timing or priority of elements within a
-- track, they are not directly executed for the underlying
-- @/nlecomposition/@ and its children. This method will finally execute
-- these changes so they are reflected in the data output of the track.
-- 
-- Any pending changes will be executed in the backend. The
-- [Timeline::commited]("GI.GES.Objects.Timeline#g:signal:commited") signal will be emitted once this has completed.
-- 
-- Note that 'GI.GES.Objects.Timeline.timelineCommit' will call this method on all of its
-- tracks, so you are unlikely to need to use this directly.
trackCommit ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if pending changes were committed, or 'P.False' if nothing
    -- needed to be committed.
trackCommit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrack a) =>
a -> m Bool
trackCommit a
track = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    CInt
result <- Ptr Track -> IO CInt
ges_track_commit Ptr Track
track'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackCommitMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTrack a) => O.OverloadedMethod TrackCommitMethodInfo a signature where
    overloadedMethod = trackCommit

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


#endif

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

foreign import ccall "ges_track_get_caps" ges_track_get_caps :: 
    Ptr Track ->                            -- track : TInterface (Name {namespace = "GES", name = "Track"})
    IO (Ptr Gst.Caps.Caps)

-- | Get the [Track:caps]("GI.GES.Objects.Track#g:attr:caps") of the track.
trackGetCaps ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> m Gst.Caps.Caps
    -- ^ __Returns:__ The caps of /@track@/.
trackGetCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrack a) =>
a -> m Caps
trackGetCaps a
track = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    Ptr Caps
result <- Ptr Track -> IO (Ptr Caps)
ges_track_get_caps Ptr Track
track'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"trackGetCaps" Ptr Caps
result
    Caps
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
    forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'

#if defined(ENABLE_OVERLOADING)
data TrackGetCapsMethodInfo
instance (signature ~ (m Gst.Caps.Caps), MonadIO m, IsTrack a) => O.OverloadedMethod TrackGetCapsMethodInfo a signature where
    overloadedMethod = trackGetCaps

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


#endif

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

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

-- | Gets the track elements contained in the track. The returned list is
-- sorted by the element\'s [TimelineElement:priority]("GI.GES.Objects.TimelineElement#g:attr:priority") and
-- [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start").
trackGetElements ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> m [GES.TrackElement.TrackElement]
    -- ^ __Returns:__ A list of
    -- all the t'GI.GES.Objects.TrackElement.TrackElement'-s in /@track@/.
trackGetElements :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrack a) =>
a -> m [TrackElement]
trackGetElements a
track = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    Ptr (GList (Ptr TrackElement))
result <- Ptr Track -> IO (Ptr (GList (Ptr TrackElement)))
ges_track_get_elements Ptr Track
track'
    [Ptr TrackElement]
result' <- forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr TrackElement))
result
    [TrackElement]
result'' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TrackElement -> TrackElement
GES.TrackElement.TrackElement) [Ptr TrackElement]
result'
    forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr TrackElement))
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
    forall (m :: * -> *) a. Monad m => a -> m a
return [TrackElement]
result''

#if defined(ENABLE_OVERLOADING)
data TrackGetElementsMethodInfo
instance (signature ~ (m [GES.TrackElement.TrackElement]), MonadIO m, IsTrack a) => O.OverloadedMethod TrackGetElementsMethodInfo a signature where
    overloadedMethod = trackGetElements

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


#endif

-- method Track::get_mixing
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "track"
--           , argType = TInterface Name { namespace = "GES" , name = "Track" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrack" , 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_get_mixing" ges_track_get_mixing :: 
    Ptr Track ->                            -- track : TInterface (Name {namespace = "GES", name = "Track"})
    IO CInt

-- | Gets the [Track:mixing]("GI.GES.Objects.Track#g:attr:mixing") of the track.
trackGetMixing ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> m Bool
    -- ^ __Returns:__ Whether /@track@/ is mixing.
trackGetMixing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrack a) =>
a -> m Bool
trackGetMixing a
track = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    CInt
result <- Ptr Track -> IO CInt
ges_track_get_mixing Ptr Track
track'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackGetMixingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTrack a) => O.OverloadedMethod TrackGetMixingMethodInfo a signature where
    overloadedMethod = trackGetMixing

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


#endif

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

foreign import ccall "ges_track_get_restriction_caps" ges_track_get_restriction_caps :: 
    Ptr Track ->                            -- track : TInterface (Name {namespace = "GES", name = "Track"})
    IO (Ptr Gst.Caps.Caps)

-- | Gets the [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps") of the track.
-- 
-- /Since: 1.18/
trackGetRestrictionCaps ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> m Gst.Caps.Caps
    -- ^ __Returns:__ The restriction-caps of /@track@/.
trackGetRestrictionCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrack a) =>
a -> m Caps
trackGetRestrictionCaps a
track = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    Ptr Caps
result <- Ptr Track -> IO (Ptr Caps)
ges_track_get_restriction_caps Ptr Track
track'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"trackGetRestrictionCaps" Ptr Caps
result
    Caps
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
    forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'

#if defined(ENABLE_OVERLOADING)
data TrackGetRestrictionCapsMethodInfo
instance (signature ~ (m Gst.Caps.Caps), MonadIO m, IsTrack a) => O.OverloadedMethod TrackGetRestrictionCapsMethodInfo a signature where
    overloadedMethod = trackGetRestrictionCaps

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


#endif

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

foreign import ccall "ges_track_get_timeline" ges_track_get_timeline :: 
    Ptr Track ->                            -- track : TInterface (Name {namespace = "GES", name = "Track"})
    IO (Ptr GES.Timeline.Timeline)

-- | Get the timeline this track belongs to.
trackGetTimeline ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> m (Maybe GES.Timeline.Timeline)
    -- ^ __Returns:__ The timeline that /@track@/ belongs to, or 'P.Nothing' if
    -- it does not belong to a timeline.
trackGetTimeline :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrack a) =>
a -> m (Maybe Timeline)
trackGetTimeline a
track = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    Ptr Timeline
result <- Ptr Track -> IO (Ptr Timeline)
ges_track_get_timeline Ptr Track
track'
    Maybe Timeline
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Timeline
result forall a b. (a -> b) -> a -> b
$ \Ptr Timeline
result' -> do
        Timeline
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Timeline -> Timeline
GES.Timeline.Timeline) Ptr Timeline
result'
        forall (m :: * -> *) a. Monad m => a -> m a
return Timeline
result''
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Timeline
maybeResult

#if defined(ENABLE_OVERLOADING)
data TrackGetTimelineMethodInfo
instance (signature ~ (m (Maybe GES.Timeline.Timeline)), MonadIO m, IsTrack a) => O.OverloadedMethod TrackGetTimelineMethodInfo a signature where
    overloadedMethod = trackGetTimeline

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


#endif

-- method Track::remove_element
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "track"
--           , argType = TInterface Name { namespace = "GES" , name = "Track" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrack" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The element to remove"
--                 , 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_remove_element" ges_track_remove_element :: 
    Ptr Track ->                            -- track : TInterface (Name {namespace = "GES", name = "Track"})
    Ptr GES.TrackElement.TrackElement ->    -- object : TInterface (Name {namespace = "GES", name = "TrackElement"})
    IO CInt

-- | See 'GI.GES.Objects.Track.trackRemoveElementFull', which also returns an error.
trackRemoveElement ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a, GES.TrackElement.IsTrackElement b) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> b
    -- ^ /@object@/: The element to remove
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@object@/ was successfully removed from /@track@/.
trackRemoveElement :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTrack a, IsTrackElement b) =>
a -> b -> m Bool
trackRemoveElement a
track b
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
object
    CInt
result <- Ptr Track -> Ptr TrackElement -> IO CInt
ges_track_remove_element Ptr Track
track' 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
track
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
object
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TrackRemoveElementMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsTrack a, GES.TrackElement.IsTrackElement b) => O.OverloadedMethod TrackRemoveElementMethodInfo a signature where
    overloadedMethod = trackRemoveElement

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


#endif

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

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

-- | Removes the given track element from the track, which revokes
-- ownership of the element.
-- 
-- /Since: 1.18/
trackRemoveElementFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a, GES.TrackElement.IsTrackElement b) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> b
    -- ^ /@object@/: The element to remove
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
trackRemoveElementFull :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTrack a, IsTrackElement b) =>
a -> b -> m ()
trackRemoveElementFull a
track b
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    Ptr TrackElement
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
object
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Track -> Ptr TrackElement -> Ptr (Ptr GError) -> IO CInt
ges_track_remove_element_full Ptr Track
track' Ptr TrackElement
object'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
object
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TrackRemoveElementFullMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTrack a, GES.TrackElement.IsTrackElement b) => O.OverloadedMethod TrackRemoveElementFullMethodInfo a signature where
    overloadedMethod = trackRemoveElementFull

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


#endif

-- method Track::set_mixing
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "track"
--           , argType = TInterface Name { namespace = "GES" , name = "Track" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrack" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mixing"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether @track should be mixing"
--                 , 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_set_mixing" ges_track_set_mixing :: 
    Ptr Track ->                            -- track : TInterface (Name {namespace = "GES", name = "Track"})
    CInt ->                                 -- mixing : TBasicType TBoolean
    IO ()

-- | Sets the [Track:mixing]("GI.GES.Objects.Track#g:attr:mixing") for the track.
trackSetMixing ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> Bool
    -- ^ /@mixing@/: Whether /@track@/ should be mixing
    -> m ()
trackSetMixing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrack a) =>
a -> Bool -> m ()
trackSetMixing a
track Bool
mixing = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    let mixing' :: CInt
mixing' = (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
mixing
    Ptr Track -> CInt -> IO ()
ges_track_set_mixing Ptr Track
track' CInt
mixing'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TrackSetMixingMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTrack a) => O.OverloadedMethod TrackSetMixingMethodInfo a signature where
    overloadedMethod = trackSetMixing

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


#endif

-- method Track::set_restriction_caps
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "track"
--           , argType = TInterface Name { namespace = "GES" , name = "Track" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrack" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "caps"
--           , argType = TInterface Name { namespace = "Gst" , name = "Caps" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new restriction-caps for @track"
--                 , 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_set_restriction_caps" ges_track_set_restriction_caps :: 
    Ptr Track ->                            -- track : TInterface (Name {namespace = "GES", name = "Track"})
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO ()

-- | Sets the [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps") for the track.
-- 
-- > **NOTE**: Restriction caps are **not** taken into account when
-- > using [Pipeline:mode]("GI.GES.Objects.Pipeline#g:attr:mode")=@/GES_PIPELINE_MODE_SMART_RENDER/@.
trackSetRestrictionCaps ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> Gst.Caps.Caps
    -- ^ /@caps@/: The new restriction-caps for /@track@/
    -> m ()
trackSetRestrictionCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrack a) =>
a -> Caps -> m ()
trackSetRestrictionCaps a
track Caps
caps = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    Ptr Caps
caps' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
    Ptr Track -> Ptr Caps -> IO ()
ges_track_set_restriction_caps Ptr Track
track' Ptr Caps
caps'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TrackSetRestrictionCapsMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m ()), MonadIO m, IsTrack a) => O.OverloadedMethod TrackSetRestrictionCapsMethodInfo a signature where
    overloadedMethod = trackSetRestrictionCaps

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


#endif

-- method Track::set_timeline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "track"
--           , argType = TInterface Name { namespace = "GES" , name = "Track" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A #GESTrack\n@timeline (nullable): A #GESTimeline"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timeline"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Timeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , 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_set_timeline" ges_track_set_timeline :: 
    Ptr Track ->                            -- track : TInterface (Name {namespace = "GES", name = "Track"})
    Ptr GES.Timeline.Timeline ->            -- timeline : TInterface (Name {namespace = "GES", name = "Timeline"})
    IO ()

-- | Informs the track that it belongs to the given timeline. Calling this
-- does not actually add the track to the timeline. For that, you should
-- use 'GI.GES.Objects.Timeline.timelineAddTrack', which will also take care of informing
-- the track that it belongs to the timeline. As such, there is no need
-- for you to call this method.
trackSetTimeline ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a, GES.Timeline.IsTimeline b) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -- /@timeline@/ (nullable): A t'GI.GES.Objects.Timeline.Timeline'
    -> b
    -> m ()
trackSetTimeline :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTrack a, IsTimeline b) =>
a -> b -> m ()
trackSetTimeline a
track b
timeline = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    Ptr Timeline
timeline' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
timeline
    Ptr Track -> Ptr Timeline -> IO ()
ges_track_set_timeline Ptr Track
track' Ptr Timeline
timeline'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
timeline
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TrackSetTimelineMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTrack a, GES.Timeline.IsTimeline b) => O.OverloadedMethod TrackSetTimelineMethodInfo a signature where
    overloadedMethod = trackSetTimeline

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


#endif

-- method Track::update_restriction_caps
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "track"
--           , argType = TInterface Name { namespace = "GES" , name = "Track" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTrack" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "caps"
--           , argType = TInterface Name { namespace = "Gst" , name = "Caps" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The caps to update the restriction-caps with"
--                 , 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_update_restriction_caps" ges_track_update_restriction_caps :: 
    Ptr Track ->                            -- track : TInterface (Name {namespace = "GES", name = "Track"})
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO ()

-- | Updates the [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps") of the track using the fields
-- found in the given caps. Each of the t'GI.Gst.Structs.Structure.Structure'-s in /@caps@/ is
-- compared against the existing structure with the same index in the
-- current [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps"). If there is no corresponding
-- existing structure at that index, then the new structure is simply
-- copied to that index. Otherwise, any fields in the new structure are
-- copied into the existing structure. This will replace existing values,
-- and may introduce new ones, but any fields \'missing\' in the new
-- structure are left unchanged in the existing structure.
-- 
-- For example, if the existing [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps") are
-- \"video\/x-raw, width=480, height=360\", and the updating caps is
-- \"video\/x-raw, format=I420, width=500; video\/x-bayer, width=400\", then
-- the new [Track:restrictionCaps]("GI.GES.Objects.Track#g:attr:restrictionCaps") after calling this will be
-- \"video\/x-raw, width=500, height=360, format=I420; video\/x-bayer,
-- width=400\".
trackUpdateRestrictionCaps ::
    (B.CallStack.HasCallStack, MonadIO m, IsTrack a) =>
    a
    -- ^ /@track@/: A t'GI.GES.Objects.Track.Track'
    -> Gst.Caps.Caps
    -- ^ /@caps@/: The caps to update the restriction-caps with
    -> m ()
trackUpdateRestrictionCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTrack a) =>
a -> Caps -> m ()
trackUpdateRestrictionCaps a
track Caps
caps = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Track
track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
track
    Ptr Caps
caps' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
    Ptr Track -> Ptr Caps -> IO ()
ges_track_update_restriction_caps Ptr Track
track' Ptr Caps
caps'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
track
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TrackUpdateRestrictionCapsMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m ()), MonadIO m, IsTrack a) => O.OverloadedMethod TrackUpdateRestrictionCapsMethodInfo a signature where
    overloadedMethod = trackUpdateRestrictionCaps

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


#endif