{-# 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.TimelineElement.TimelineElement' will have some temporal extent in its
-- corresponding [TimelineElement:timeline]("GI.GES.Objects.TimelineElement#g:attr:timeline"), controlled by its
-- [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") and [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration"). This
-- determines when its content will be displayed, or its effect applied,
-- in the timeline. Several objects may overlap within a given
-- t'GI.GES.Objects.Timeline.Timeline', in which case their [TimelineElement:priority]("GI.GES.Objects.TimelineElement#g:attr:priority") is used
-- to determine their ordering in the timeline. Priority is mostly handled
-- internally by t'GI.GES.Objects.Layer.Layer'-s and t'GI.GES.Objects.Clip.Clip'-s.
-- 
-- A timeline element can have a [TimelineElement:parent]("GI.GES.Objects.TimelineElement#g:attr:parent"),
-- such as a t'GI.GES.Objects.Clip.Clip', which is responsible for controlling its timing.
-- 
-- == Editing
-- 
-- Elements can be moved around in their [TimelineElement:timeline]("GI.GES.Objects.TimelineElement#g:attr:timeline") by
-- setting their [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") and
-- [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") using 'GI.GES.Objects.TimelineElement.timelineElementSetStart'
-- and 'GI.GES.Objects.TimelineElement.timelineElementSetDuration'. Additionally, which parts of
-- the underlying content are played in the timeline can be adjusted by
-- setting the [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") using
-- 'GI.GES.Objects.TimelineElement.timelineElementSetInpoint'. The library also provides
-- 'GI.GES.Objects.TimelineElement.timelineElementEdit', with various t'GI.GES.Enums.EditMode'-s, which can
-- adjust these properties in a convenient way, as well as introduce
-- similar changes in neighbouring or later elements in the timeline.
-- 
-- However, a timeline may refuse a change in these properties if they
-- would place the timeline in an unsupported configuration. See
-- t'GI.GES.Objects.Timeline.Timeline' for its overlap rules.
-- 
-- Additionally, an edit may be refused if it would place one of the
-- timing properties out of bounds (such as a negative time value for
-- [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start"), or having insufficient internal
-- content to last for the desired [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration")).
-- 
-- == Time Coordinates
-- 
-- There are three main sets of time coordinates to consider when using
-- timeline elements:
-- 
-- + Timeline coordinates: these are the time coordinates used in the
--   output of the timeline in its t'GI.GES.Objects.Track.Track'-s. Each track share the same
--   coordinates, so there is only one set of coordinates for the
--   timeline. These extend indefinitely from 0. The times used for
--   editing (including setting [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") and
--   [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration")) use these coordinates, since these
--   define when an element is present and for how long the element lasts
--   for in the timeline.
-- + Internal source coordinates: these are the time coordinates used
--   internally at the element\'s output. This is only really defined for
--   t'GI.GES.Objects.TrackElement.TrackElement'-s, where it refers to time coordinates used at the
--   final source pad of the wrapped t'GI.Gst.Objects.Element.Element'-s. However, these
--   coordinates may also be used in a t'GI.GES.Objects.Clip.Clip' in reference to its
--   children. In particular, these are the coordinates used for
--   [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") and [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration").
-- + Internal sink coordinates: these are the time coordinates used
--   internally at the element\'s input. A t'GI.GES.Objects.Source.Source' has no input, so
--   these would be undefined. Otherwise, for most t'GI.GES.Objects.TrackElement.TrackElement'-s
--   these will be the same set of coordinates as the internal source
--   coordinates because the element does not change the timing
--   internally. Only t'GI.GES.Objects.BaseEffect.BaseEffect' can support elements where these
--   are different. See t'GI.GES.Objects.BaseEffect.BaseEffect' for more information.
-- 
-- You can determine the timeline time for a given internal source time
-- in a t'GI.GES.Objects.Track.Track' in a t'GI.GES.Objects.Clip.Clip' using
-- 'GI.GES.Objects.Clip.clipGetTimelineTimeFromInternalTime', and vice versa using
-- 'GI.GES.Objects.Clip.clipGetInternalTimeFromTimelineTime', for the purposes of
-- editing and setting timings properties.
-- 
-- == Children Properties
-- 
-- If a timeline element owns another t'GI.Gst.Objects.Object.Object' and wishes to expose
-- some of its properties, it can do so by registering the property as one
-- of the timeline element\'s children properties using
-- 'GI.GES.Objects.TimelineElement.timelineElementAddChildProperty'. The registered property of
-- the child can then be read and set using the
-- 'GI.GES.Objects.TimelineElement.timelineElementGetChildProperty' and
-- 'GI.GES.Objects.TimelineElement.timelineElementSetChildProperty' methods, respectively. Some
-- sub-classed objects will be created with pre-registered children
-- properties; for example, to expose part of an underlying t'GI.Gst.Objects.Element.Element'
-- that is used internally. The registered properties can be listed with
-- 'GI.GES.Objects.TimelineElement.timelineElementListChildrenProperties'.

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

module GI.GES.Objects.TimelineElement
    ( 
#if defined(ENABLE_OVERLOADING)
    TimelineElementListChildrenPropertiesMethodInfo,
#endif

-- * Exported types
    TimelineElement(..)                     ,
    IsTimelineElement                       ,
    toTimelineElement                       ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addChildProperty]("GI.GES.Objects.TimelineElement#g:method:addChildProperty"), [addMetasFromString]("GI.GES.Interfaces.MetaContainer#g:method:addMetasFromString"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [checkMetaRegistered]("GI.GES.Interfaces.MetaContainer#g:method:checkMetaRegistered"), [copy]("GI.GES.Objects.TimelineElement#g:method:copy"), [edit]("GI.GES.Objects.TimelineElement#g:method:edit"), [editFull]("GI.GES.Objects.TimelineElement#g:method:editFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.GES.Interfaces.MetaContainer#g:method:foreach"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [listChildrenProperties]("GI.GES.Objects.TimelineElement#g:method:listChildrenProperties"), [lookupChild]("GI.GES.Objects.TimelineElement#g:method:lookupChild"), [metasToString]("GI.GES.Interfaces.MetaContainer#g:method:metasToString"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [paste]("GI.GES.Objects.TimelineElement#g:method:paste"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [registerMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerMeta"), [registerMetaBoolean]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaBoolean"), [registerMetaDate]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDate"), [registerMetaDateTime]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDateTime"), [registerMetaDouble]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDouble"), [registerMetaFloat]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaFloat"), [registerMetaInt]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt"), [registerMetaInt64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt64"), [registerMetaString]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaString"), [registerMetaUint]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint"), [registerMetaUint64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint64"), [registerStaticMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerStaticMeta"), [removeChildProperty]("GI.GES.Objects.TimelineElement#g:method:removeChildProperty"), [ripple]("GI.GES.Objects.TimelineElement#g:method:ripple"), [rippleEnd]("GI.GES.Objects.TimelineElement#g:method:rippleEnd"), [rollEnd]("GI.GES.Objects.TimelineElement#g:method:rollEnd"), [rollStart]("GI.GES.Objects.TimelineElement#g:method:rollStart"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [trim]("GI.GES.Objects.TimelineElement#g:method:trim"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAsset]("GI.GES.Interfaces.Extractable#g:method:getAsset"), [getBoolean]("GI.GES.Interfaces.MetaContainer#g:method:getBoolean"), [getChildProperty]("GI.GES.Objects.TimelineElement#g:method:getChildProperty"), [getChildPropertyByPspec]("GI.GES.Objects.TimelineElement#g:method:getChildPropertyByPspec"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDate]("GI.GES.Interfaces.MetaContainer#g:method:getDate"), [getDateTime]("GI.GES.Interfaces.MetaContainer#g:method:getDateTime"), [getDouble]("GI.GES.Interfaces.MetaContainer#g:method:getDouble"), [getDuration]("GI.GES.Objects.TimelineElement#g:method:getDuration"), [getFloat]("GI.GES.Interfaces.MetaContainer#g:method:getFloat"), [getId]("GI.GES.Interfaces.Extractable#g:method:getId"), [getInpoint]("GI.GES.Objects.TimelineElement#g:method:getInpoint"), [getInt]("GI.GES.Interfaces.MetaContainer#g:method:getInt"), [getInt64]("GI.GES.Interfaces.MetaContainer#g:method:getInt64"), [getLayerPriority]("GI.GES.Objects.TimelineElement#g:method:getLayerPriority"), [getMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:getMarkerList"), [getMaxDuration]("GI.GES.Objects.TimelineElement#g:method:getMaxDuration"), [getMeta]("GI.GES.Interfaces.MetaContainer#g:method:getMeta"), [getName]("GI.GES.Objects.TimelineElement#g:method:getName"), [getNaturalFramerate]("GI.GES.Objects.TimelineElement#g:method:getNaturalFramerate"), [getParent]("GI.GES.Objects.TimelineElement#g:method:getParent"), [getPriority]("GI.GES.Objects.TimelineElement#g:method:getPriority"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getStart]("GI.GES.Objects.TimelineElement#g:method:getStart"), [getString]("GI.GES.Interfaces.MetaContainer#g:method:getString"), [getTimeline]("GI.GES.Objects.TimelineElement#g:method:getTimeline"), [getToplevelParent]("GI.GES.Objects.TimelineElement#g:method:getToplevelParent"), [getTrackTypes]("GI.GES.Objects.TimelineElement#g:method:getTrackTypes"), [getUint]("GI.GES.Interfaces.MetaContainer#g:method:getUint"), [getUint64]("GI.GES.Interfaces.MetaContainer#g:method:getUint64").
-- 
-- ==== Setters
-- [setAsset]("GI.GES.Interfaces.Extractable#g:method:setAsset"), [setBoolean]("GI.GES.Interfaces.MetaContainer#g:method:setBoolean"), [setChildProperty]("GI.GES.Objects.TimelineElement#g:method:setChildProperty"), [setChildPropertyByPspec]("GI.GES.Objects.TimelineElement#g:method:setChildPropertyByPspec"), [setChildPropertyFull]("GI.GES.Objects.TimelineElement#g:method:setChildPropertyFull"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDate]("GI.GES.Interfaces.MetaContainer#g:method:setDate"), [setDateTime]("GI.GES.Interfaces.MetaContainer#g:method:setDateTime"), [setDouble]("GI.GES.Interfaces.MetaContainer#g:method:setDouble"), [setDuration]("GI.GES.Objects.TimelineElement#g:method:setDuration"), [setFloat]("GI.GES.Interfaces.MetaContainer#g:method:setFloat"), [setInpoint]("GI.GES.Objects.TimelineElement#g:method:setInpoint"), [setInt]("GI.GES.Interfaces.MetaContainer#g:method:setInt"), [setInt64]("GI.GES.Interfaces.MetaContainer#g:method:setInt64"), [setMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:setMarkerList"), [setMaxDuration]("GI.GES.Objects.TimelineElement#g:method:setMaxDuration"), [setMeta]("GI.GES.Interfaces.MetaContainer#g:method:setMeta"), [setName]("GI.GES.Objects.TimelineElement#g:method:setName"), [setParent]("GI.GES.Objects.TimelineElement#g:method:setParent"), [setPriority]("GI.GES.Objects.TimelineElement#g:method:setPriority"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setStart]("GI.GES.Objects.TimelineElement#g:method:setStart"), [setString]("GI.GES.Interfaces.MetaContainer#g:method:setString"), [setTimeline]("GI.GES.Objects.TimelineElement#g:method:setTimeline"), [setUint]("GI.GES.Interfaces.MetaContainer#g:method:setUint"), [setUint64]("GI.GES.Interfaces.MetaContainer#g:method:setUint64").

#if defined(ENABLE_OVERLOADING)
    ResolveTimelineElementMethod            ,
#endif

-- ** addChildProperty #method:addChildProperty#

#if defined(ENABLE_OVERLOADING)
    TimelineElementAddChildPropertyMethodInfo,
#endif
    timelineElementAddChildProperty         ,


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    TimelineElementCopyMethodInfo           ,
#endif
    timelineElementCopy                     ,


-- ** edit #method:edit#

#if defined(ENABLE_OVERLOADING)
    TimelineElementEditMethodInfo           ,
#endif
    timelineElementEdit                     ,


-- ** editFull #method:editFull#

#if defined(ENABLE_OVERLOADING)
    TimelineElementEditFullMethodInfo       ,
#endif
    timelineElementEditFull                 ,


-- ** getChildProperty #method:getChildProperty#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetChildPropertyMethodInfo,
#endif
    timelineElementGetChildProperty         ,


-- ** getChildPropertyByPspec #method:getChildPropertyByPspec#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetChildPropertyByPspecMethodInfo,
#endif
    timelineElementGetChildPropertyByPspec  ,


-- ** getDuration #method:getDuration#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetDurationMethodInfo    ,
#endif
    timelineElementGetDuration              ,


-- ** getInpoint #method:getInpoint#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetInpointMethodInfo     ,
#endif
    timelineElementGetInpoint               ,


-- ** getLayerPriority #method:getLayerPriority#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetLayerPriorityMethodInfo,
#endif
    timelineElementGetLayerPriority         ,


-- ** getMaxDuration #method:getMaxDuration#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetMaxDurationMethodInfo ,
#endif
    timelineElementGetMaxDuration           ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetNameMethodInfo        ,
#endif
    timelineElementGetName                  ,


-- ** getNaturalFramerate #method:getNaturalFramerate#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetNaturalFramerateMethodInfo,
#endif
    timelineElementGetNaturalFramerate      ,


-- ** getParent #method:getParent#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetParentMethodInfo      ,
#endif
    timelineElementGetParent                ,


-- ** getPriority #method:getPriority#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetPriorityMethodInfo    ,
#endif
    timelineElementGetPriority              ,


-- ** getStart #method:getStart#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetStartMethodInfo       ,
#endif
    timelineElementGetStart                 ,


-- ** getTimeline #method:getTimeline#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetTimelineMethodInfo    ,
#endif
    timelineElementGetTimeline              ,


-- ** getToplevelParent #method:getToplevelParent#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetToplevelParentMethodInfo,
#endif
    timelineElementGetToplevelParent        ,


-- ** getTrackTypes #method:getTrackTypes#

#if defined(ENABLE_OVERLOADING)
    TimelineElementGetTrackTypesMethodInfo  ,
#endif
    timelineElementGetTrackTypes            ,


-- ** lookupChild #method:lookupChild#

#if defined(ENABLE_OVERLOADING)
    TimelineElementLookupChildMethodInfo    ,
#endif
    timelineElementLookupChild              ,


-- ** paste #method:paste#

#if defined(ENABLE_OVERLOADING)
    TimelineElementPasteMethodInfo          ,
#endif
    timelineElementPaste                    ,


-- ** removeChildProperty #method:removeChildProperty#

#if defined(ENABLE_OVERLOADING)
    TimelineElementRemoveChildPropertyMethodInfo,
#endif
    timelineElementRemoveChildProperty      ,


-- ** ripple #method:ripple#

#if defined(ENABLE_OVERLOADING)
    TimelineElementRippleMethodInfo         ,
#endif
    timelineElementRipple                   ,


-- ** rippleEnd #method:rippleEnd#

#if defined(ENABLE_OVERLOADING)
    TimelineElementRippleEndMethodInfo      ,
#endif
    timelineElementRippleEnd                ,


-- ** rollEnd #method:rollEnd#

#if defined(ENABLE_OVERLOADING)
    TimelineElementRollEndMethodInfo        ,
#endif
    timelineElementRollEnd                  ,


-- ** rollStart #method:rollStart#

#if defined(ENABLE_OVERLOADING)
    TimelineElementRollStartMethodInfo      ,
#endif
    timelineElementRollStart                ,


-- ** setChildProperty #method:setChildProperty#

#if defined(ENABLE_OVERLOADING)
    TimelineElementSetChildPropertyMethodInfo,
#endif
    timelineElementSetChildProperty         ,


-- ** setChildPropertyByPspec #method:setChildPropertyByPspec#

#if defined(ENABLE_OVERLOADING)
    TimelineElementSetChildPropertyByPspecMethodInfo,
#endif
    timelineElementSetChildPropertyByPspec  ,


-- ** setChildPropertyFull #method:setChildPropertyFull#

#if defined(ENABLE_OVERLOADING)
    TimelineElementSetChildPropertyFullMethodInfo,
#endif
    timelineElementSetChildPropertyFull     ,


-- ** setDuration #method:setDuration#

#if defined(ENABLE_OVERLOADING)
    TimelineElementSetDurationMethodInfo    ,
#endif
    timelineElementSetDuration              ,


-- ** setInpoint #method:setInpoint#

#if defined(ENABLE_OVERLOADING)
    TimelineElementSetInpointMethodInfo     ,
#endif
    timelineElementSetInpoint               ,


-- ** setMaxDuration #method:setMaxDuration#

#if defined(ENABLE_OVERLOADING)
    TimelineElementSetMaxDurationMethodInfo ,
#endif
    timelineElementSetMaxDuration           ,


-- ** setName #method:setName#

#if defined(ENABLE_OVERLOADING)
    TimelineElementSetNameMethodInfo        ,
#endif
    timelineElementSetName                  ,


-- ** setParent #method:setParent#

#if defined(ENABLE_OVERLOADING)
    TimelineElementSetParentMethodInfo      ,
#endif
    timelineElementSetParent                ,


-- ** setPriority #method:setPriority#

#if defined(ENABLE_OVERLOADING)
    TimelineElementSetPriorityMethodInfo    ,
#endif
    timelineElementSetPriority              ,


-- ** setStart #method:setStart#

#if defined(ENABLE_OVERLOADING)
    TimelineElementSetStartMethodInfo       ,
#endif
    timelineElementSetStart                 ,


-- ** setTimeline #method:setTimeline#

#if defined(ENABLE_OVERLOADING)
    TimelineElementSetTimelineMethodInfo    ,
#endif
    timelineElementSetTimeline              ,


-- ** trim #method:trim#

#if defined(ENABLE_OVERLOADING)
    TimelineElementTrimMethodInfo           ,
#endif
    timelineElementTrim                     ,




 -- * Properties


-- ** duration #attr:duration#
-- | The duration that the element is in effect for in the timeline (a
-- time difference in nanoseconds using the time coordinates of the
-- timeline). For example, for a source element, this would determine
-- for how long it should output its internal content for. For an
-- operation element, this would determine for how long its effect
-- should be applied to any source content.

#if defined(ENABLE_OVERLOADING)
    TimelineElementDurationPropertyInfo     ,
#endif
    constructTimelineElementDuration        ,
    getTimelineElementDuration              ,
    setTimelineElementDuration              ,
#if defined(ENABLE_OVERLOADING)
    timelineElementDuration                 ,
#endif


-- ** inPoint #attr:inPoint#
-- | The initial offset to use internally when outputting content (in
-- nanoseconds, but in the time coordinates of the internal content).
-- 
-- For example, for a t'GI.GES.Objects.VideoUriSource.VideoUriSource' that references some media
-- file, the \"internal content\" is the media file data, and the
-- in-point would correspond to some timestamp in the media file.
-- When playing the timeline, and when the element is first reached at
-- timeline-time [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start"), it will begin outputting the
-- data from the timestamp in-point **onwards**, until it reaches the
-- end of its [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") in the timeline.
-- 
-- For elements that have no internal content, this should be kept
-- as 0.

#if defined(ENABLE_OVERLOADING)
    TimelineElementInPointPropertyInfo      ,
#endif
    constructTimelineElementInPoint         ,
    getTimelineElementInPoint               ,
    setTimelineElementInPoint               ,
#if defined(ENABLE_OVERLOADING)
    timelineElementInPoint                  ,
#endif


-- ** maxDuration #attr:maxDuration#
-- | The full duration of internal content that is available (a time
-- difference in nanoseconds using the time coordinates of the internal
-- content).
-- 
-- This will act as a cap on the [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") of the
-- element (which is in the same time coordinates), and will sometimes
-- be used to limit the [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") of the element in
-- the timeline.
-- 
-- For example, for a t'GI.GES.Objects.VideoUriSource.VideoUriSource' that references some media
-- file, this would be the length of the media file.
-- 
-- For elements that have no internal content, or whose content is
-- indefinite, this should be kept as 'GI.Gst.Constants.CLOCK_TIME_NONE'.

#if defined(ENABLE_OVERLOADING)
    TimelineElementMaxDurationPropertyInfo  ,
#endif
    constructTimelineElementMaxDuration     ,
    getTimelineElementMaxDuration           ,
    setTimelineElementMaxDuration           ,
#if defined(ENABLE_OVERLOADING)
    timelineElementMaxDuration              ,
#endif


-- ** name #attr:name#
-- | The name of the element. This should be unique within its timeline.

#if defined(ENABLE_OVERLOADING)
    TimelineElementNamePropertyInfo         ,
#endif
    clearTimelineElementName                ,
    constructTimelineElementName            ,
    getTimelineElementName                  ,
    setTimelineElementName                  ,
#if defined(ENABLE_OVERLOADING)
    timelineElementName                     ,
#endif


-- ** parent #attr:parent#
-- | The parent container of the element.

#if defined(ENABLE_OVERLOADING)
    TimelineElementParentPropertyInfo       ,
#endif
    clearTimelineElementParent              ,
    constructTimelineElementParent          ,
    getTimelineElementParent                ,
    setTimelineElementParent                ,
#if defined(ENABLE_OVERLOADING)
    timelineElementParent                   ,
#endif


-- ** priority #attr:priority#
-- | The priority of the element.

#if defined(ENABLE_OVERLOADING)
    TimelineElementPriorityPropertyInfo     ,
#endif
    constructTimelineElementPriority        ,
    getTimelineElementPriority              ,
    setTimelineElementPriority              ,
#if defined(ENABLE_OVERLOADING)
    timelineElementPriority                 ,
#endif


-- ** serialize #attr:serialize#
-- | Whether the element should be serialized.

#if defined(ENABLE_OVERLOADING)
    TimelineElementSerializePropertyInfo    ,
#endif
    constructTimelineElementSerialize       ,
    getTimelineElementSerialize             ,
    setTimelineElementSerialize             ,
#if defined(ENABLE_OVERLOADING)
    timelineElementSerialize                ,
#endif


-- ** start #attr:start#
-- | The starting position of the element in the timeline (in nanoseconds
-- and in the time coordinates of the timeline). For example, for a
-- source element, this would determine the time at which it should
-- start outputting its internal content. For an operation element, this
-- would determine the time at which it should start applying its effect
-- to any source content.

#if defined(ENABLE_OVERLOADING)
    TimelineElementStartPropertyInfo        ,
#endif
    constructTimelineElementStart           ,
    getTimelineElementStart                 ,
    setTimelineElementStart                 ,
#if defined(ENABLE_OVERLOADING)
    timelineElementStart                    ,
#endif


-- ** timeline #attr:timeline#
-- | The timeline that the element lies within.

#if defined(ENABLE_OVERLOADING)
    TimelineElementTimelinePropertyInfo     ,
#endif
    clearTimelineElementTimeline            ,
    constructTimelineElementTimeline        ,
    getTimelineElementTimeline              ,
    setTimelineElementTimeline              ,
#if defined(ENABLE_OVERLOADING)
    timelineElementTimeline                 ,
#endif




 -- * Signals


-- ** childPropertyAdded #signal:childPropertyAdded#

    TimelineElementChildPropertyAddedCallback,
#if defined(ENABLE_OVERLOADING)
    TimelineElementChildPropertyAddedSignalInfo,
#endif
    afterTimelineElementChildPropertyAdded  ,
    onTimelineElementChildPropertyAdded     ,


-- ** childPropertyRemoved #signal:childPropertyRemoved#

    TimelineElementChildPropertyRemovedCallback,
#if defined(ENABLE_OVERLOADING)
    TimelineElementChildPropertyRemovedSignalInfo,
#endif
    afterTimelineElementChildPropertyRemoved,
    onTimelineElementChildPropertyRemoved   ,


-- ** deepNotify #signal:deepNotify#

    TimelineElementDeepNotifyCallback       ,
#if defined(ENABLE_OVERLOADING)
    TimelineElementDeepNotifySignalInfo     ,
#endif
    afterTimelineElementDeepNotify          ,
    onTimelineElementDeepNotify             ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import {-# SOURCE #-} qualified GI.GES.Enums as GES.Enums
import {-# SOURCE #-} qualified GI.GES.Flags as GES.Flags
import {-# SOURCE #-} qualified GI.GES.Interfaces.Extractable as GES.Extractable
import {-# SOURCE #-} qualified GI.GES.Interfaces.MetaContainer as GES.MetaContainer
import {-# SOURCE #-} qualified GI.GES.Objects.Layer as GES.Layer
import {-# SOURCE #-} qualified GI.GES.Objects.Timeline as GES.Timeline
import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "ges_timeline_element_get_type"
    c_ges_timeline_element_get_type :: IO B.Types.GType

instance B.Types.TypedObject TimelineElement where
    glibType :: IO GType
glibType = IO GType
c_ges_timeline_element_get_type

instance B.Types.GObject TimelineElement

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

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

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

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

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

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

#endif

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

#endif

-- signal TimelineElement::child-property-added
-- | Emitted when the element has a new child property registered. See
-- 'GI.GES.Objects.TimelineElement.timelineElementAddChildProperty'.
-- 
-- Note that some GES elements will be automatically created with
-- pre-registered children properties. You can use
-- 'GI.GES.Objects.TimelineElement.timelineElementListChildrenProperties' to list these.
-- 
-- /Since: 1.18/
type TimelineElementChildPropertyAddedCallback =
    GObject.Object.Object
    -- ^ /@propObject@/: The child whose property has been registered
    -> GParamSpec
    -- ^ /@prop@/: The specification for the property that has been registered
    -> IO ()

type C_TimelineElementChildPropertyAddedCallback =
    Ptr TimelineElement ->                  -- object
    Ptr GObject.Object.Object ->
    Ptr GParamSpec ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TimelineElementChildPropertyAddedCallback :: 
    GObject a => (a -> TimelineElementChildPropertyAddedCallback) ->
    C_TimelineElementChildPropertyAddedCallback
wrap_TimelineElementChildPropertyAddedCallback :: forall a.
GObject a =>
(a -> TimelineElementChildPropertyAddedCallback)
-> C_TimelineElementChildPropertyAddedCallback
wrap_TimelineElementChildPropertyAddedCallback a -> TimelineElementChildPropertyAddedCallback
gi'cb Ptr TimelineElement
gi'selfPtr Ptr Object
propObject Ptr GParamSpec
prop Ptr ()
_ = do
    Object
propObject' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
propObject
    GParamSpec
prop' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
prop
    forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TimelineElement
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \TimelineElement
gi'self -> a -> TimelineElementChildPropertyAddedCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce TimelineElement
gi'self)  Object
propObject' GParamSpec
prop'


-- | Connect a signal handler for the [childPropertyAdded](#signal:childPropertyAdded) 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' timelineElement #childPropertyAdded callback
-- @
-- 
-- 
onTimelineElementChildPropertyAdded :: (IsTimelineElement a, MonadIO m) => a -> ((?self :: a) => TimelineElementChildPropertyAddedCallback) -> m SignalHandlerId
onTimelineElementChildPropertyAdded :: forall a (m :: * -> *).
(IsTimelineElement a, MonadIO m) =>
a
-> ((?self::a) => TimelineElementChildPropertyAddedCallback)
-> m SignalHandlerId
onTimelineElementChildPropertyAdded a
obj (?self::a) => TimelineElementChildPropertyAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TimelineElementChildPropertyAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TimelineElementChildPropertyAddedCallback
cb
    let wrapped' :: C_TimelineElementChildPropertyAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TimelineElementChildPropertyAddedCallback)
-> C_TimelineElementChildPropertyAddedCallback
wrap_TimelineElementChildPropertyAddedCallback a -> TimelineElementChildPropertyAddedCallback
wrapped
    FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' <- C_TimelineElementChildPropertyAddedCallback
-> IO (FunPtr C_TimelineElementChildPropertyAddedCallback)
mk_TimelineElementChildPropertyAddedCallback C_TimelineElementChildPropertyAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"child-property-added" FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing

-- | Connect a signal handler for the [childPropertyAdded](#signal:childPropertyAdded) 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' timelineElement #childPropertyAdded 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.
-- 
afterTimelineElementChildPropertyAdded :: (IsTimelineElement a, MonadIO m) => a -> ((?self :: a) => TimelineElementChildPropertyAddedCallback) -> m SignalHandlerId
afterTimelineElementChildPropertyAdded :: forall a (m :: * -> *).
(IsTimelineElement a, MonadIO m) =>
a
-> ((?self::a) => TimelineElementChildPropertyAddedCallback)
-> m SignalHandlerId
afterTimelineElementChildPropertyAdded a
obj (?self::a) => TimelineElementChildPropertyAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TimelineElementChildPropertyAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TimelineElementChildPropertyAddedCallback
cb
    let wrapped' :: C_TimelineElementChildPropertyAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TimelineElementChildPropertyAddedCallback)
-> C_TimelineElementChildPropertyAddedCallback
wrap_TimelineElementChildPropertyAddedCallback a -> TimelineElementChildPropertyAddedCallback
wrapped
    FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' <- C_TimelineElementChildPropertyAddedCallback
-> IO (FunPtr C_TimelineElementChildPropertyAddedCallback)
mk_TimelineElementChildPropertyAddedCallback C_TimelineElementChildPropertyAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"child-property-added" FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TimelineElementChildPropertyAddedSignalInfo
instance SignalInfo TimelineElementChildPropertyAddedSignalInfo where
    type HaskellCallbackType TimelineElementChildPropertyAddedSignalInfo = TimelineElementChildPropertyAddedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TimelineElementChildPropertyAddedCallback cb
        cb'' <- mk_TimelineElementChildPropertyAddedCallback cb'
        connectSignalFunPtr obj "child-property-added" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TimelineElement::child-property-added"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TimelineElement.html#g:signal:childPropertyAdded"})

#endif

-- signal TimelineElement::child-property-removed
-- | Emitted when the element has a child property unregistered. See
-- 'GI.GES.Objects.TimelineElement.timelineElementRemoveChildProperty'.
-- 
-- /Since: 1.18/
type TimelineElementChildPropertyRemovedCallback =
    GObject.Object.Object
    -- ^ /@propObject@/: The child whose property has been unregistered
    -> GParamSpec
    -- ^ /@prop@/: The specification for the property that has been unregistered
    -> IO ()

type C_TimelineElementChildPropertyRemovedCallback =
    Ptr TimelineElement ->                  -- object
    Ptr GObject.Object.Object ->
    Ptr GParamSpec ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TimelineElementChildPropertyRemovedCallback :: 
    GObject a => (a -> TimelineElementChildPropertyRemovedCallback) ->
    C_TimelineElementChildPropertyRemovedCallback
wrap_TimelineElementChildPropertyRemovedCallback :: forall a.
GObject a =>
(a -> TimelineElementChildPropertyAddedCallback)
-> C_TimelineElementChildPropertyAddedCallback
wrap_TimelineElementChildPropertyRemovedCallback a -> TimelineElementChildPropertyAddedCallback
gi'cb Ptr TimelineElement
gi'selfPtr Ptr Object
propObject Ptr GParamSpec
prop Ptr ()
_ = do
    Object
propObject' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
propObject
    GParamSpec
prop' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
prop
    forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TimelineElement
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \TimelineElement
gi'self -> a -> TimelineElementChildPropertyAddedCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce TimelineElement
gi'self)  Object
propObject' GParamSpec
prop'


-- | Connect a signal handler for the [childPropertyRemoved](#signal:childPropertyRemoved) 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' timelineElement #childPropertyRemoved callback
-- @
-- 
-- 
onTimelineElementChildPropertyRemoved :: (IsTimelineElement a, MonadIO m) => a -> ((?self :: a) => TimelineElementChildPropertyRemovedCallback) -> m SignalHandlerId
onTimelineElementChildPropertyRemoved :: forall a (m :: * -> *).
(IsTimelineElement a, MonadIO m) =>
a
-> ((?self::a) => TimelineElementChildPropertyAddedCallback)
-> m SignalHandlerId
onTimelineElementChildPropertyRemoved a
obj (?self::a) => TimelineElementChildPropertyAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TimelineElementChildPropertyAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TimelineElementChildPropertyAddedCallback
cb
    let wrapped' :: C_TimelineElementChildPropertyAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TimelineElementChildPropertyAddedCallback)
-> C_TimelineElementChildPropertyAddedCallback
wrap_TimelineElementChildPropertyRemovedCallback a -> TimelineElementChildPropertyAddedCallback
wrapped
    FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' <- C_TimelineElementChildPropertyAddedCallback
-> IO (FunPtr C_TimelineElementChildPropertyAddedCallback)
mk_TimelineElementChildPropertyRemovedCallback C_TimelineElementChildPropertyAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"child-property-removed" FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing

-- | Connect a signal handler for the [childPropertyRemoved](#signal:childPropertyRemoved) 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' timelineElement #childPropertyRemoved 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.
-- 
afterTimelineElementChildPropertyRemoved :: (IsTimelineElement a, MonadIO m) => a -> ((?self :: a) => TimelineElementChildPropertyRemovedCallback) -> m SignalHandlerId
afterTimelineElementChildPropertyRemoved :: forall a (m :: * -> *).
(IsTimelineElement a, MonadIO m) =>
a
-> ((?self::a) => TimelineElementChildPropertyAddedCallback)
-> m SignalHandlerId
afterTimelineElementChildPropertyRemoved a
obj (?self::a) => TimelineElementChildPropertyAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TimelineElementChildPropertyAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TimelineElementChildPropertyAddedCallback
cb
    let wrapped' :: C_TimelineElementChildPropertyAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TimelineElementChildPropertyAddedCallback)
-> C_TimelineElementChildPropertyAddedCallback
wrap_TimelineElementChildPropertyRemovedCallback a -> TimelineElementChildPropertyAddedCallback
wrapped
    FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' <- C_TimelineElementChildPropertyAddedCallback
-> IO (FunPtr C_TimelineElementChildPropertyAddedCallback)
mk_TimelineElementChildPropertyRemovedCallback C_TimelineElementChildPropertyAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"child-property-removed" FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TimelineElementChildPropertyRemovedSignalInfo
instance SignalInfo TimelineElementChildPropertyRemovedSignalInfo where
    type HaskellCallbackType TimelineElementChildPropertyRemovedSignalInfo = TimelineElementChildPropertyRemovedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TimelineElementChildPropertyRemovedCallback cb
        cb'' <- mk_TimelineElementChildPropertyRemovedCallback cb'
        connectSignalFunPtr obj "child-property-removed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TimelineElement::child-property-removed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TimelineElement.html#g:signal:childPropertyRemoved"})

#endif

-- signal TimelineElement::deep-notify
-- | Emitted when a child of the element has one of its registered
-- properties set. See 'GI.GES.Objects.TimelineElement.timelineElementAddChildProperty'.
-- Note that unlike [Object::notify]("GI.GObject.Objects.Object#g:signal:notify"), a child property name can not be
-- used as a signal detail.
type TimelineElementDeepNotifyCallback =
    GObject.Object.Object
    -- ^ /@propObject@/: The child whose property has been set
    -> GParamSpec
    -- ^ /@prop@/: The specification for the property that been set
    -> IO ()

type C_TimelineElementDeepNotifyCallback =
    Ptr TimelineElement ->                  -- object
    Ptr GObject.Object.Object ->
    Ptr GParamSpec ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TimelineElementDeepNotifyCallback :: 
    GObject a => (a -> TimelineElementDeepNotifyCallback) ->
    C_TimelineElementDeepNotifyCallback
wrap_TimelineElementDeepNotifyCallback :: forall a.
GObject a =>
(a -> TimelineElementChildPropertyAddedCallback)
-> C_TimelineElementChildPropertyAddedCallback
wrap_TimelineElementDeepNotifyCallback a -> TimelineElementChildPropertyAddedCallback
gi'cb Ptr TimelineElement
gi'selfPtr Ptr Object
propObject Ptr GParamSpec
prop Ptr ()
_ = do
    Object
propObject' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
propObject
    GParamSpec
prop' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
prop
    forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TimelineElement
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \TimelineElement
gi'self -> a -> TimelineElementChildPropertyAddedCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce TimelineElement
gi'self)  Object
propObject' GParamSpec
prop'


-- | Connect a signal handler for the [deepNotify](#signal:deepNotify) 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' timelineElement #deepNotify callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@deep-notify::detail@” instead.
-- 
onTimelineElementDeepNotify :: (IsTimelineElement a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => TimelineElementDeepNotifyCallback) -> m SignalHandlerId
onTimelineElementDeepNotify :: forall a (m :: * -> *).
(IsTimelineElement a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => TimelineElementChildPropertyAddedCallback)
-> m SignalHandlerId
onTimelineElementDeepNotify a
obj Maybe Text
detail (?self::a) => TimelineElementChildPropertyAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TimelineElementChildPropertyAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TimelineElementChildPropertyAddedCallback
cb
    let wrapped' :: C_TimelineElementChildPropertyAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TimelineElementChildPropertyAddedCallback)
-> C_TimelineElementChildPropertyAddedCallback
wrap_TimelineElementDeepNotifyCallback a -> TimelineElementChildPropertyAddedCallback
wrapped
    FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' <- C_TimelineElementChildPropertyAddedCallback
-> IO (FunPtr C_TimelineElementChildPropertyAddedCallback)
mk_TimelineElementDeepNotifyCallback C_TimelineElementChildPropertyAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"deep-notify" FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
detail

-- | Connect a signal handler for the [deepNotify](#signal:deepNotify) 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' timelineElement #deepNotify callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@deep-notify::detail@” instead.
-- 
-- 
-- 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.
-- 
afterTimelineElementDeepNotify :: (IsTimelineElement a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => TimelineElementDeepNotifyCallback) -> m SignalHandlerId
afterTimelineElementDeepNotify :: forall a (m :: * -> *).
(IsTimelineElement a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => TimelineElementChildPropertyAddedCallback)
-> m SignalHandlerId
afterTimelineElementDeepNotify a
obj Maybe Text
detail (?self::a) => TimelineElementChildPropertyAddedCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> TimelineElementChildPropertyAddedCallback
wrapped a
self = let ?self = a
self in (?self::a) => TimelineElementChildPropertyAddedCallback
cb
    let wrapped' :: C_TimelineElementChildPropertyAddedCallback
wrapped' = forall a.
GObject a =>
(a -> TimelineElementChildPropertyAddedCallback)
-> C_TimelineElementChildPropertyAddedCallback
wrap_TimelineElementDeepNotifyCallback a -> TimelineElementChildPropertyAddedCallback
wrapped
    FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' <- C_TimelineElementChildPropertyAddedCallback
-> IO (FunPtr C_TimelineElementChildPropertyAddedCallback)
mk_TimelineElementDeepNotifyCallback C_TimelineElementChildPropertyAddedCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"deep-notify" FunPtr C_TimelineElementChildPropertyAddedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
detail


#if defined(ENABLE_OVERLOADING)
data TimelineElementDeepNotifySignalInfo
instance SignalInfo TimelineElementDeepNotifySignalInfo where
    type HaskellCallbackType TimelineElementDeepNotifySignalInfo = TimelineElementDeepNotifyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TimelineElementDeepNotifyCallback cb
        cb'' <- mk_TimelineElementDeepNotifyCallback cb'
        connectSignalFunPtr obj "deep-notify" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TimelineElement::deep-notify"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TimelineElement.html#g:signal:deepNotify"})

#endif

-- VVV Prop "duration"
   -- Type: TBasicType TUInt64
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,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' timelineElement #duration
-- @
getTimelineElementDuration :: (MonadIO m, IsTimelineElement o) => o -> m Word64
getTimelineElementDuration :: forall (m :: * -> *) o.
(MonadIO m, IsTimelineElement o) =>
o -> m Word64
getTimelineElementDuration 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"

-- | Set 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.set' timelineElement [ #duration 'Data.GI.Base.Attributes.:=' value ]
-- @
setTimelineElementDuration :: (MonadIO m, IsTimelineElement o) => o -> Word64 -> m ()
setTimelineElementDuration :: forall (m :: * -> *) o.
(MonadIO m, IsTimelineElement o) =>
o -> Word64 -> m ()
setTimelineElementDuration o
obj Word64
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 -> Word64 -> IO ()
B.Properties.setObjectPropertyUInt64 o
obj String
"duration" Word64
val

-- | Construct a `GValueConstruct` with valid value for the “@duration@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTimelineElementDuration :: (IsTimelineElement o, MIO.MonadIO m) => Word64 -> m (GValueConstruct o)
constructTimelineElementDuration :: forall o (m :: * -> *).
(IsTimelineElement o, MonadIO m) =>
Word64 -> m (GValueConstruct o)
constructTimelineElementDuration Word64
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 -> Word64 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt64 String
"duration" Word64
val

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

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

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

-- | Set the value of the “@in-point@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' timelineElement [ #inPoint 'Data.GI.Base.Attributes.:=' value ]
-- @
setTimelineElementInPoint :: (MonadIO m, IsTimelineElement o) => o -> Word64 -> m ()
setTimelineElementInPoint :: forall (m :: * -> *) o.
(MonadIO m, IsTimelineElement o) =>
o -> Word64 -> m ()
setTimelineElementInPoint o
obj Word64
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 -> Word64 -> IO ()
B.Properties.setObjectPropertyUInt64 o
obj String
"in-point" Word64
val

-- | Construct a `GValueConstruct` with valid value for the “@in-point@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTimelineElementInPoint :: (IsTimelineElement o, MIO.MonadIO m) => Word64 -> m (GValueConstruct o)
constructTimelineElementInPoint :: forall o (m :: * -> *).
(IsTimelineElement o, MonadIO m) =>
Word64 -> m (GValueConstruct o)
constructTimelineElementInPoint Word64
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 -> Word64 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt64 String
"in-point" Word64
val

#if defined(ENABLE_OVERLOADING)
data TimelineElementInPointPropertyInfo
instance AttrInfo TimelineElementInPointPropertyInfo where
    type AttrAllowedOps TimelineElementInPointPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TimelineElementInPointPropertyInfo = IsTimelineElement
    type AttrSetTypeConstraint TimelineElementInPointPropertyInfo = (~) Word64
    type AttrTransferTypeConstraint TimelineElementInPointPropertyInfo = (~) Word64
    type AttrTransferType TimelineElementInPointPropertyInfo = Word64
    type AttrGetType TimelineElementInPointPropertyInfo = Word64
    type AttrLabel TimelineElementInPointPropertyInfo = "in-point"
    type AttrOrigin TimelineElementInPointPropertyInfo = TimelineElement
    attrGet = getTimelineElementInPoint
    attrSet = setTimelineElementInPoint
    attrTransfer _ v = do
        return v
    attrConstruct = constructTimelineElementInPoint
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TimelineElement.inPoint"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TimelineElement.html#g:attr:inPoint"
        })
#endif

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

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

-- | Set the value of the “@max-duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' timelineElement [ #maxDuration 'Data.GI.Base.Attributes.:=' value ]
-- @
setTimelineElementMaxDuration :: (MonadIO m, IsTimelineElement o) => o -> Word64 -> m ()
setTimelineElementMaxDuration :: forall (m :: * -> *) o.
(MonadIO m, IsTimelineElement o) =>
o -> Word64 -> m ()
setTimelineElementMaxDuration o
obj Word64
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 -> Word64 -> IO ()
B.Properties.setObjectPropertyUInt64 o
obj String
"max-duration" Word64
val

-- | Construct a `GValueConstruct` with valid value for the “@max-duration@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTimelineElementMaxDuration :: (IsTimelineElement o, MIO.MonadIO m) => Word64 -> m (GValueConstruct o)
constructTimelineElementMaxDuration :: forall o (m :: * -> *).
(IsTimelineElement o, MonadIO m) =>
Word64 -> m (GValueConstruct o)
constructTimelineElementMaxDuration Word64
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 -> Word64 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt64 String
"max-duration" Word64
val

#if defined(ENABLE_OVERLOADING)
data TimelineElementMaxDurationPropertyInfo
instance AttrInfo TimelineElementMaxDurationPropertyInfo where
    type AttrAllowedOps TimelineElementMaxDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TimelineElementMaxDurationPropertyInfo = IsTimelineElement
    type AttrSetTypeConstraint TimelineElementMaxDurationPropertyInfo = (~) Word64
    type AttrTransferTypeConstraint TimelineElementMaxDurationPropertyInfo = (~) Word64
    type AttrTransferType TimelineElementMaxDurationPropertyInfo = Word64
    type AttrGetType TimelineElementMaxDurationPropertyInfo = Word64
    type AttrLabel TimelineElementMaxDurationPropertyInfo = "max-duration"
    type AttrOrigin TimelineElementMaxDurationPropertyInfo = TimelineElement
    attrGet = getTimelineElementMaxDuration
    attrSet = setTimelineElementMaxDuration
    attrTransfer _ v = do
        return v
    attrConstruct = constructTimelineElementMaxDuration
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TimelineElement.maxDuration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TimelineElement.html#g:attr:maxDuration"
        })
#endif

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

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

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

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

-- | Set the value of the “@name@” 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' #name
-- @
clearTimelineElementName :: (MonadIO m, IsTimelineElement o) => o -> m ()
clearTimelineElementName :: forall (m :: * -> *) o.
(MonadIO m, IsTimelineElement o) =>
o -> m ()
clearTimelineElementName 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
"name" (forall a. Maybe a
Nothing :: Maybe T.Text)

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

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

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

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

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

-- | Set the value of the “@parent@” 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' #parent
-- @
clearTimelineElementParent :: (MonadIO m, IsTimelineElement o) => o -> m ()
clearTimelineElementParent :: forall (m :: * -> *) o.
(MonadIO m, IsTimelineElement o) =>
o -> m ()
clearTimelineElementParent o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"parent" (forall a. Maybe a
Nothing :: Maybe TimelineElement)

#if defined(ENABLE_OVERLOADING)
data TimelineElementParentPropertyInfo
instance AttrInfo TimelineElementParentPropertyInfo where
    type AttrAllowedOps TimelineElementParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TimelineElementParentPropertyInfo = IsTimelineElement
    type AttrSetTypeConstraint TimelineElementParentPropertyInfo = IsTimelineElement
    type AttrTransferTypeConstraint TimelineElementParentPropertyInfo = IsTimelineElement
    type AttrTransferType TimelineElementParentPropertyInfo = TimelineElement
    type AttrGetType TimelineElementParentPropertyInfo = (Maybe TimelineElement)
    type AttrLabel TimelineElementParentPropertyInfo = "parent"
    type AttrOrigin TimelineElementParentPropertyInfo = TimelineElement
    attrGet = getTimelineElementParent
    attrSet = setTimelineElementParent
    attrTransfer _ v = do
        unsafeCastTo TimelineElement v
    attrConstruct = constructTimelineElementParent
    attrClear = clearTimelineElementParent
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TimelineElement.parent"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TimelineElement.html#g:attr:parent"
        })
#endif

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

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

-- | Set the value of the “@priority@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' timelineElement [ #priority 'Data.GI.Base.Attributes.:=' value ]
-- @
setTimelineElementPriority :: (MonadIO m, IsTimelineElement o) => o -> Word32 -> m ()
setTimelineElementPriority :: forall (m :: * -> *) o.
(MonadIO m, IsTimelineElement o) =>
o -> Word32 -> m ()
setTimelineElementPriority o
obj Word32
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 -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"priority" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@priority@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTimelineElementPriority :: (IsTimelineElement o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructTimelineElementPriority :: forall o (m :: * -> *).
(IsTimelineElement o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructTimelineElementPriority Word32
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 -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"priority" Word32
val

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

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

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

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

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

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

-- VVV Prop "start"
   -- Type: TBasicType TUInt64
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

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

-- | Set the value of the “@start@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' timelineElement [ #start 'Data.GI.Base.Attributes.:=' value ]
-- @
setTimelineElementStart :: (MonadIO m, IsTimelineElement o) => o -> Word64 -> m ()
setTimelineElementStart :: forall (m :: * -> *) o.
(MonadIO m, IsTimelineElement o) =>
o -> Word64 -> m ()
setTimelineElementStart o
obj Word64
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 -> Word64 -> IO ()
B.Properties.setObjectPropertyUInt64 o
obj String
"start" Word64
val

-- | Construct a `GValueConstruct` with valid value for the “@start@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTimelineElementStart :: (IsTimelineElement o, MIO.MonadIO m) => Word64 -> m (GValueConstruct o)
constructTimelineElementStart :: forall o (m :: * -> *).
(IsTimelineElement o, MonadIO m) =>
Word64 -> m (GValueConstruct o)
constructTimelineElementStart Word64
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 -> Word64 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt64 String
"start" Word64
val

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

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

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

-- | Set the value of the “@timeline@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' timelineElement [ #timeline 'Data.GI.Base.Attributes.:=' value ]
-- @
setTimelineElementTimeline :: (MonadIO m, IsTimelineElement o, GES.Timeline.IsTimeline a) => o -> a -> m ()
setTimelineElementTimeline :: forall (m :: * -> *) o a.
(MonadIO m, IsTimelineElement o, IsTimeline a) =>
o -> a -> m ()
setTimelineElementTimeline o
obj a
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, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"timeline" (forall a. a -> Maybe a
Just a
val)

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

-- | Set the value of the “@timeline@” 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' #timeline
-- @
clearTimelineElementTimeline :: (MonadIO m, IsTimelineElement o) => o -> m ()
clearTimelineElementTimeline :: forall (m :: * -> *) o.
(MonadIO m, IsTimelineElement o) =>
o -> m ()
clearTimelineElementTimeline o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"timeline" (forall a. Maybe a
Nothing :: Maybe GES.Timeline.Timeline)

#if defined(ENABLE_OVERLOADING)
data TimelineElementTimelinePropertyInfo
instance AttrInfo TimelineElementTimelinePropertyInfo where
    type AttrAllowedOps TimelineElementTimelinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TimelineElementTimelinePropertyInfo = IsTimelineElement
    type AttrSetTypeConstraint TimelineElementTimelinePropertyInfo = GES.Timeline.IsTimeline
    type AttrTransferTypeConstraint TimelineElementTimelinePropertyInfo = GES.Timeline.IsTimeline
    type AttrTransferType TimelineElementTimelinePropertyInfo = GES.Timeline.Timeline
    type AttrGetType TimelineElementTimelinePropertyInfo = (Maybe GES.Timeline.Timeline)
    type AttrLabel TimelineElementTimelinePropertyInfo = "timeline"
    type AttrOrigin TimelineElementTimelinePropertyInfo = TimelineElement
    attrGet = getTimelineElementTimeline
    attrSet = setTimelineElementTimeline
    attrTransfer _ v = do
        unsafeCastTo GES.Timeline.Timeline v
    attrConstruct = constructTimelineElementTimeline
    attrClear = clearTimelineElementTimeline
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TimelineElement.timeline"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TimelineElement.html#g:attr:timeline"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TimelineElement
type instance O.AttributeList TimelineElement = TimelineElementAttributeList
type TimelineElementAttributeList = ('[ '("duration", TimelineElementDurationPropertyInfo), '("inPoint", TimelineElementInPointPropertyInfo), '("maxDuration", TimelineElementMaxDurationPropertyInfo), '("name", TimelineElementNamePropertyInfo), '("parent", TimelineElementParentPropertyInfo), '("priority", TimelineElementPriorityPropertyInfo), '("serialize", TimelineElementSerializePropertyInfo), '("start", TimelineElementStartPropertyInfo), '("timeline", TimelineElementTimelinePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
timelineElementDuration :: AttrLabelProxy "duration"
timelineElementDuration = AttrLabelProxy

timelineElementInPoint :: AttrLabelProxy "inPoint"
timelineElementInPoint = AttrLabelProxy

timelineElementMaxDuration :: AttrLabelProxy "maxDuration"
timelineElementMaxDuration = AttrLabelProxy

timelineElementName :: AttrLabelProxy "name"
timelineElementName = AttrLabelProxy

timelineElementParent :: AttrLabelProxy "parent"
timelineElementParent = AttrLabelProxy

timelineElementPriority :: AttrLabelProxy "priority"
timelineElementPriority = AttrLabelProxy

timelineElementSerialize :: AttrLabelProxy "serialize"
timelineElementSerialize = AttrLabelProxy

timelineElementStart :: AttrLabelProxy "start"
timelineElementStart = AttrLabelProxy

timelineElementTimeline :: AttrLabelProxy "timeline"
timelineElementTimeline = AttrLabelProxy

#endif

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

#endif

-- method TimelineElement::add_child_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The specification for the property to add"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GstObject who the property belongs to"
--                 , 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_timeline_element_add_child_property" ges_timeline_element_add_child_property :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    Ptr GObject.Object.Object ->            -- child : TInterface (Name {namespace = "GObject", name = "Object"})
    IO CInt

-- | Register a property of a child of the element to allow it to be
-- written with 'GI.GES.Objects.TimelineElement.timelineElementSetChildProperty' and read with
-- 'GI.GES.Objects.TimelineElement.timelineElementGetChildProperty'. A change in the property
-- will also appear in the [TimelineElement::deepNotify]("GI.GES.Objects.TimelineElement#g:signal:deepNotify") signal.
-- 
-- /@pspec@/ should be unique from other children properties that have been
-- registered on /@self@/.
timelineElementAddChildProperty ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a, GObject.Object.IsObject b) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> GParamSpec
    -- ^ /@pspec@/: The specification for the property to add
    -> b
    -- ^ /@child@/: The t'GI.Gst.Objects.Object.Object' who the property belongs to
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the property was successfully registered.
timelineElementAddChildProperty :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTimelineElement a, IsObject b) =>
a -> GParamSpec -> b -> m Bool
timelineElementAddChildProperty a
self GParamSpec
pspec b
child = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr GParamSpec
pspec' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr Object
child' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    CInt
result <- Ptr TimelineElement -> Ptr GParamSpec -> Ptr Object -> IO CInt
ges_timeline_element_add_child_property Ptr TimelineElement
self' Ptr GParamSpec
pspec' Ptr Object
child'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementAddChildPropertyMethodInfo
instance (signature ~ (GParamSpec -> b -> m Bool), MonadIO m, IsTimelineElement a, GObject.Object.IsObject b) => O.OverloadedMethod TimelineElementAddChildPropertyMethodInfo a signature where
    overloadedMethod = timelineElementAddChildProperty

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


#endif

-- method TimelineElement::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTimelineElement to copy"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "deep"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether the copy is needed for pasting"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GES" , name = "TimelineElement" })
-- throws : False
-- Skip return : False

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

-- | Create a copy of /@self@/. All the properties of /@self@/ are copied into
-- a new element, with the exception of [TimelineElement:parent]("GI.GES.Objects.TimelineElement#g:attr:parent"),
-- [TimelineElement:timeline]("GI.GES.Objects.TimelineElement#g:attr:timeline") and [TimelineElement:name]("GI.GES.Objects.TimelineElement#g:attr:name"). Other data,
-- such the list of a t'GI.GES.Objects.Container.Container'\'s children, is **not** copied.
-- 
-- If /@deep@/ is 'P.True', then the new element is prepared so that it can be
-- used in 'GI.GES.Objects.TimelineElement.timelineElementPaste' or 'GI.GES.Objects.Timeline.timelinePasteElement'.
-- In the case of copying a t'GI.GES.Objects.Container.Container', this ensures that the children
-- of /@self@/ will also be pasted. The new element should not be used for
-- anything else and can only be used **once** in a pasting operation. In
-- particular, the new element itself is not an actual \'deep\' copy of
-- /@self@/, but should be thought of as an intermediate object used for a
-- single paste operation.
timelineElementCopy ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.TimelineElement.TimelineElement' to copy
    -> Bool
    -- ^ /@deep@/: Whether the copy is needed for pasting
    -> m TimelineElement
    -- ^ __Returns:__ The newly create element,
    -- copied from /@self@/.
timelineElementCopy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Bool -> m TimelineElement
timelineElementCopy a
self Bool
deep = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let deep' :: CInt
deep' = (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
deep
    Ptr TimelineElement
result <- Ptr TimelineElement -> CInt -> IO (Ptr TimelineElement)
ges_timeline_element_copy Ptr TimelineElement
self' CInt
deep'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"timelineElementCopy" Ptr TimelineElement
result
    TimelineElement
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TimelineElement -> TimelineElement
TimelineElement) Ptr TimelineElement
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return TimelineElement
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementCopyMethodInfo
instance (signature ~ (Bool -> m TimelineElement), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementCopyMethodInfo a signature where
    overloadedMethod = timelineElementCopy

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


#endif

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

-- | See 'GI.GES.Objects.TimelineElement.timelineElementEditFull', which also gives an error.
-- 
-- Note that the /@layers@/ argument is currently ignored, so you should
-- just pass 'P.Nothing'.
-- 
-- /Since: 1.18/
timelineElementEdit ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a, GES.Layer.IsLayer b) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.TimelineElement.TimelineElement' to edit
    -> [b]
    -- ^ /@layers@/: A whitelist of layers
    -- where the edit can be performed, 'P.Nothing' allows all layers in the
    -- timeline.
    -> Int64
    -- ^ /@newLayerPriority@/: The priority\/index of the layer /@self@/ should be
    -- moved to. -1 means no move
    -> GES.Enums.EditMode
    -- ^ /@mode@/: The edit mode
    -> GES.Enums.Edge
    -- ^ /@edge@/: The edge of /@self@/ where the edit should occur
    -> Word64
    -- ^ /@position@/: The edit position: a new location for the edge of /@self@/
    -- (in nanoseconds) in the timeline coordinates
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the edit of /@self@/ completed, 'P.False' on failure.
timelineElementEdit :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTimelineElement a, IsLayer b) =>
a -> [b] -> Int64 -> EditMode -> Edge -> Word64 -> m Bool
timelineElementEdit a
self [b]
layers Int64
newLayerPriority EditMode
mode Edge
edge Word64
position = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    [Ptr Layer]
layers' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [b]
layers
    Ptr (GList (Ptr Layer))
layers'' <- forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGList [Ptr Layer]
layers'
    let mode' :: CUInt
mode' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) EditMode
mode
    let edge' :: CUInt
edge' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Edge
edge
    CInt
result <- Ptr TimelineElement
-> Ptr (GList (Ptr Layer))
-> Int64
-> CUInt
-> CUInt
-> Word64
-> IO CInt
ges_timeline_element_edit Ptr TimelineElement
self' Ptr (GList (Ptr Layer))
layers'' Int64
newLayerPriority CUInt
mode' CUInt
edge' Word64
position
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [b]
layers
    forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Layer))
layers''
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

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

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


#endif

-- method TimelineElement::edit_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTimelineElement to edit"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "new_layer_priority"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The priority/index of the layer @self should be\nmoved to. -1 means no move"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "EditMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The edit mode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "edge"
--           , argType = TInterface Name { namespace = "GES" , name = "Edge" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The edge of @self where the edit should occur"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The edit position: a new location for the edge of @self\n(in nanoseconds) in the timeline coordinates"
--                 , 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_timeline_element_edit_full" ges_timeline_element_edit_full :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Int64 ->                                -- new_layer_priority : TBasicType TInt64
    CUInt ->                                -- mode : TInterface (Name {namespace = "GES", name = "EditMode"})
    CUInt ->                                -- edge : TInterface (Name {namespace = "GES", name = "Edge"})
    Word64 ->                               -- position : TBasicType TUInt64
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Edits the element within its timeline by adjusting its
-- [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start"), [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") or
-- [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint"), and potentially doing the same for
-- other elements in the timeline. See t'GI.GES.Enums.EditMode' for details about each
-- edit mode. An edit may fail if it would place one of these properties
-- out of bounds, or if it would place the timeline in an unsupported
-- configuration.
-- 
-- Note that if you act on a t'GI.GES.Objects.TrackElement.TrackElement', this will edit its parent
-- t'GI.GES.Objects.Clip.Clip' instead. Moreover, for any t'GI.GES.Objects.TimelineElement.TimelineElement', if you select
-- @/GES_EDGE_NONE/@ for @/GES_EDIT_MODE_NORMAL/@ or @/GES_EDIT_MODE_RIPPLE/@, this
-- will edit the toplevel instead, but still in such a way as to make the
-- [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") of /@self@/ reach the edit /@position@/.
-- 
-- Note that if the element\'s timeline has a
-- [Timeline:snappingDistance]("GI.GES.Objects.Timeline#g:attr:snappingDistance") set, then the edit position may be
-- snapped to the edge of some element under the edited element.
-- 
-- /@newLayerPriority@/ can be used to switch /@self@/, and other elements
-- moved by the edit, to a new layer. New layers may be be created if the
-- the corresponding layer priority\/index does not yet exist for the
-- timeline.
-- 
-- /Since: 1.18/
timelineElementEditFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.TimelineElement.TimelineElement' to edit
    -> Int64
    -- ^ /@newLayerPriority@/: The priority\/index of the layer /@self@/ should be
    -- moved to. -1 means no move
    -> GES.Enums.EditMode
    -- ^ /@mode@/: The edit mode
    -> GES.Enums.Edge
    -- ^ /@edge@/: The edge of /@self@/ where the edit should occur
    -> Word64
    -- ^ /@position@/: The edit position: a new location for the edge of /@self@/
    -- (in nanoseconds) in the timeline coordinates
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
timelineElementEditFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Int64 -> EditMode -> Edge -> Word64 -> m ()
timelineElementEditFull a
self Int64
newLayerPriority EditMode
mode Edge
edge Word64
position = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let mode' :: CUInt
mode' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) EditMode
mode
    let edge' :: CUInt
edge' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Edge
edge
    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 TimelineElement
-> Int64 -> CUInt -> CUInt -> Word64 -> Ptr (Ptr GError) -> IO CInt
ges_timeline_element_edit_full Ptr TimelineElement
self' Int64
newLayerPriority CUInt
mode' CUInt
edge' Word64
position
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data TimelineElementEditFullMethodInfo
instance (signature ~ (Int64 -> GES.Enums.EditMode -> GES.Enums.Edge -> Word64 -> m ()), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementEditFullMethodInfo a signature where
    overloadedMethod = timelineElementEditFull

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


#endif

-- method TimelineElement::get_child_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name of the child property to get"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The return location for the value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_timeline_element_get_child_property" ges_timeline_element_get_child_property :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    CString ->                              -- property_name : TBasicType TUTF8
    Ptr GValue ->                           -- value : TGValue
    IO CInt

-- | Gets the property of a child of the element.
-- 
-- /@propertyName@/ can either be in the format \"prop-name\" or
-- \"TypeName[propName](#g:signal:propName)\", where \"prop-name\" is the name of the property
-- to get (as used in @/g_object_get()/@), and \"TypeName\" is the type name of
-- the child (as returned by @/G_OBJECT_TYPE_NAME()/@). The latter format is
-- useful when two children of different types share the same property
-- name.
-- 
-- The first child found with the given \"prop-name\" property that was
-- registered with 'GI.GES.Objects.TimelineElement.timelineElementAddChildProperty' (and of the
-- type \"TypeName\", if it was given) will have the corresponding
-- property copied into /@value@/.
-- 
-- Note that @/ges_timeline_element_get_child_properties()/@ may be more
-- convenient for C programming.
timelineElementGetChildProperty ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> T.Text
    -- ^ /@propertyName@/: The name of the child property to get
    -> m ((Bool, GValue))
    -- ^ __Returns:__ 'P.True' if the property was found and copied to /@value@/.
timelineElementGetChildProperty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Text -> m (Bool, GValue)
timelineElementGetChildProperty a
self Text
propertyName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr GValue
value <- forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
    CInt
result <- Ptr TimelineElement -> CString -> Ptr GValue -> IO CInt
ges_timeline_element_get_child_property Ptr TimelineElement
self' CString
propertyName' Ptr GValue
value
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    GValue
value' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
value
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', GValue
value')

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetChildPropertyMethodInfo
instance (signature ~ (T.Text -> m ((Bool, GValue))), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetChildPropertyMethodInfo a signature where
    overloadedMethod = timelineElementGetChildProperty

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


#endif

-- method TimelineElement::get_child_property_by_pspec
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The specification of a registered child property to get"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The return location for the value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_timeline_element_get_child_property_by_pspec" ges_timeline_element_get_child_property_by_pspec :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    Ptr GValue ->                           -- value : TGValue
    IO ()

-- | Gets the property of a child of the element. Specifically, the property
-- corresponding to the /@pspec@/ used in
-- 'GI.GES.Objects.TimelineElement.timelineElementAddChildProperty' is copied into /@value@/.
timelineElementGetChildPropertyByPspec ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> GParamSpec
    -- ^ /@pspec@/: The specification of a registered child property to get
    -> m (GValue)
timelineElementGetChildPropertyByPspec :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> GParamSpec -> m GValue
timelineElementGetChildPropertyByPspec a
self GParamSpec
pspec = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr GParamSpec
pspec' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr GValue
value <- forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
    Ptr TimelineElement -> Ptr GParamSpec -> Ptr GValue -> IO ()
ges_timeline_element_get_child_property_by_pspec Ptr TimelineElement
self' Ptr GParamSpec
pspec' Ptr GValue
value
    GValue
value' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
value
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    forall (m :: * -> *) a. Monad m => a -> m a
return GValue
value'

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetChildPropertyByPspecMethodInfo
instance (signature ~ (GParamSpec -> m (GValue)), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetChildPropertyByPspecMethodInfo a signature where
    overloadedMethod = timelineElementGetChildPropertyByPspec

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


#endif

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

foreign import ccall "ges_timeline_element_get_duration" ges_timeline_element_get_duration :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    IO Word64

-- | Gets the [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") for the element.
timelineElementGetDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> m Word64
    -- ^ __Returns:__ The duration of /@self@/ (in nanoseconds).
timelineElementGetDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m Word64
timelineElementGetDuration a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word64
result <- Ptr TimelineElement -> IO Word64
ges_timeline_element_get_duration Ptr TimelineElement
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetDurationMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetDurationMethodInfo a signature where
    overloadedMethod = timelineElementGetDuration

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


#endif

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

foreign import ccall "ges_timeline_element_get_inpoint" ges_timeline_element_get_inpoint :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    IO Word64

-- | Gets the [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") for the element.
timelineElementGetInpoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> m Word64
    -- ^ __Returns:__ The in-point of /@self@/ (in nanoseconds).
timelineElementGetInpoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m Word64
timelineElementGetInpoint a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word64
result <- Ptr TimelineElement -> IO Word64
ges_timeline_element_get_inpoint Ptr TimelineElement
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetInpointMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetInpointMethodInfo a signature where
    overloadedMethod = timelineElementGetInpoint

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


#endif

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

foreign import ccall "ges_timeline_element_get_layer_priority" ges_timeline_element_get_layer_priority :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    IO Word32

-- | Gets the priority of the layer the element is in. A t'GI.GES.Objects.Group.Group' may span
-- several layers, so this would return the highest priority (numerically,
-- the smallest) amongst them.
-- 
-- /Since: 1.16/
timelineElementGetLayerPriority ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> m Word32
    -- ^ __Returns:__ The priority of the layer /@self@/ is in, or
    -- 'GI.GES.Constants.TIMELINE_ELEMENT_NO_LAYER_PRIORITY' if /@self@/ does not exist in a
    -- layer.
timelineElementGetLayerPriority :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m Word32
timelineElementGetLayerPriority a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr TimelineElement -> IO Word32
ges_timeline_element_get_layer_priority Ptr TimelineElement
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetLayerPriorityMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetLayerPriorityMethodInfo a signature where
    overloadedMethod = timelineElementGetLayerPriority

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


#endif

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

foreign import ccall "ges_timeline_element_get_max_duration" ges_timeline_element_get_max_duration :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    IO Word64

-- | Gets the [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") for the element.
timelineElementGetMaxDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> m Word64
    -- ^ __Returns:__ The max-duration of /@self@/ (in nanoseconds).
timelineElementGetMaxDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m Word64
timelineElementGetMaxDuration a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word64
result <- Ptr TimelineElement -> IO Word64
ges_timeline_element_get_max_duration Ptr TimelineElement
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetMaxDurationMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetMaxDurationMethodInfo a signature where
    overloadedMethod = timelineElementGetMaxDuration

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


#endif

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

foreign import ccall "ges_timeline_element_get_name" ges_timeline_element_get_name :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    IO CString

-- | Gets the [TimelineElement:name]("GI.GES.Objects.TimelineElement#g:attr:name") for the element.
timelineElementGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> m T.Text
    -- ^ __Returns:__ The name of /@self@/.
timelineElementGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m Text
timelineElementGetName a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr TimelineElement -> IO CString
ges_timeline_element_get_name Ptr TimelineElement
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"timelineElementGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
    forall a. Ptr a -> IO ()
freeMem CString
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetNameMethodInfo a signature where
    overloadedMethod = timelineElementGetName

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


#endif

-- method TimelineElement::get_natural_framerate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The #GESTimelineElement to get \"natural\" framerate from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "framerate_n"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The framerate numerator"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "framerate_d"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The framerate denominator"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_timeline_element_get_natural_framerate" ges_timeline_element_get_natural_framerate :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Ptr Int32 ->                            -- framerate_n : TBasicType TInt
    Ptr Int32 ->                            -- framerate_d : TBasicType TInt
    IO CInt

-- | Get the \"natural\" framerate of /@self@/. This is to say, for example
-- for a t'GI.GES.Objects.VideoUriSource.VideoUriSource' the framerate of the source.
-- 
-- Note that a t'GI.GES.Objects.AudioSource.AudioSource' may also have a natural framerate if it derives
-- from the same t'GI.GES.Objects.SourceClip.SourceClip' asset as a t'GI.GES.Objects.VideoSource.VideoSource', and its value will
-- be that of the video source. For example, if the uri of a t'GI.GES.Objects.UriClip.UriClip' points
-- to a file that contains both a video and audio stream, then the corresponding
-- t'GI.GES.Objects.AudioUriSource.AudioUriSource' will share the natural framerate of the corresponding
-- t'GI.GES.Objects.VideoUriSource.VideoUriSource'.
-- 
-- /Since: 1.18/
timelineElementGetNaturalFramerate ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.TimelineElement.TimelineElement' to get \"natural\" framerate from
    -> m ((Bool, Int32, Int32))
    -- ^ __Returns:__ Whether /@self@/ has a natural framerate or not, /@framerateN@/
    -- and /@framerateD@/ will be set to, respectively, 0 and -1 if it is
    -- not the case.
timelineElementGetNaturalFramerate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m (Bool, Int32, Int32)
timelineElementGetNaturalFramerate a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Int32
framerateN <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
framerateD <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    CInt
result <- Ptr TimelineElement -> Ptr Int32 -> Ptr Int32 -> IO CInt
ges_timeline_element_get_natural_framerate Ptr TimelineElement
self' Ptr Int32
framerateN Ptr Int32
framerateD
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Int32
framerateN' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
framerateN
    Int32
framerateD' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
framerateD
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. Ptr a -> IO ()
freeMem Ptr Int32
framerateN
    forall a. Ptr a -> IO ()
freeMem Ptr Int32
framerateD
    forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
framerateN', Int32
framerateD')

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetNaturalFramerateMethodInfo
instance (signature ~ (m ((Bool, Int32, Int32))), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetNaturalFramerateMethodInfo a signature where
    overloadedMethod = timelineElementGetNaturalFramerate

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


#endif

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

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

-- | Gets the [TimelineElement:parent]("GI.GES.Objects.TimelineElement#g:attr:parent") for the element.
timelineElementGetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> m (Maybe TimelineElement)
    -- ^ __Returns:__ The parent of /@self@/, or 'P.Nothing' if
    -- /@self@/ has no parent.
timelineElementGetParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m (Maybe TimelineElement)
timelineElementGetParent a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TimelineElement
result <- Ptr TimelineElement -> IO (Ptr TimelineElement)
ges_timeline_element_get_parent Ptr TimelineElement
self'
    Maybe TimelineElement
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TimelineElement
result forall a b. (a -> b) -> a -> b
$ \Ptr TimelineElement
result' -> do
        TimelineElement
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TimelineElement -> TimelineElement
TimelineElement) Ptr TimelineElement
result'
        forall (m :: * -> *) a. Monad m => a -> m a
return TimelineElement
result''
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TimelineElement
maybeResult

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetParentMethodInfo
instance (signature ~ (m (Maybe TimelineElement)), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetParentMethodInfo a signature where
    overloadedMethod = timelineElementGetParent

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


#endif

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

foreign import ccall "ges_timeline_element_get_priority" ges_timeline_element_get_priority :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    IO Word32

-- | Gets the [TimelineElement:priority]("GI.GES.Objects.TimelineElement#g:attr:priority") for the element.
timelineElementGetPriority ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> m Word32
    -- ^ __Returns:__ The priority of /@self@/.
timelineElementGetPriority :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m Word32
timelineElementGetPriority a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr TimelineElement -> IO Word32
ges_timeline_element_get_priority Ptr TimelineElement
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetPriorityMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetPriorityMethodInfo a signature where
    overloadedMethod = timelineElementGetPriority

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


#endif

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

foreign import ccall "ges_timeline_element_get_start" ges_timeline_element_get_start :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    IO Word64

-- | Gets the [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") for the element.
timelineElementGetStart ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> m Word64
    -- ^ __Returns:__ The start of /@self@/ (in nanoseconds).
timelineElementGetStart :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m Word64
timelineElementGetStart a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word64
result <- Ptr TimelineElement -> IO Word64
ges_timeline_element_get_start Ptr TimelineElement
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetStartMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetStartMethodInfo a signature where
    overloadedMethod = timelineElementGetStart

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


#endif

-- method TimelineElement::get_timeline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , 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_timeline_element_get_timeline" ges_timeline_element_get_timeline :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    IO (Ptr GES.Timeline.Timeline)

-- | Gets the [TimelineElement:timeline]("GI.GES.Objects.TimelineElement#g:attr:timeline") for the element.
timelineElementGetTimeline ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> m (Maybe GES.Timeline.Timeline)
    -- ^ __Returns:__ The timeline of /@self@/, or 'P.Nothing'
    -- if /@self@/ has no timeline.
timelineElementGetTimeline :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m (Maybe Timeline)
timelineElementGetTimeline a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Timeline
result <- Ptr TimelineElement -> IO (Ptr Timeline)
ges_timeline_element_get_timeline Ptr TimelineElement
self'
    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
wrapObject 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
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Timeline
maybeResult

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

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


#endif

-- method TimelineElement::get_toplevel_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The #GESTimelineElement to get the toplevel parent from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GES" , name = "TimelineElement" })
-- throws : False
-- Skip return : False

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

-- | Gets the toplevel [TimelineElement:parent]("GI.GES.Objects.TimelineElement#g:attr:parent") of the element.
timelineElementGetToplevelParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.TimelineElement.TimelineElement' to get the toplevel parent from
    -> m TimelineElement
    -- ^ __Returns:__ The toplevel parent of /@self@/.
timelineElementGetToplevelParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m TimelineElement
timelineElementGetToplevelParent a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TimelineElement
result <- Ptr TimelineElement -> IO (Ptr TimelineElement)
ges_timeline_element_get_toplevel_parent Ptr TimelineElement
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"timelineElementGetToplevelParent" Ptr TimelineElement
result
    TimelineElement
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TimelineElement -> TimelineElement
TimelineElement) Ptr TimelineElement
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return TimelineElement
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementGetToplevelParentMethodInfo
instance (signature ~ (m TimelineElement), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementGetToplevelParentMethodInfo a signature where
    overloadedMethod = timelineElementGetToplevelParent

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


#endif

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

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

-- | Gets the track types that the element can interact with, i.e. the type
-- of t'GI.GES.Objects.Track.Track' it can exist in, or will create t'GI.GES.Objects.TrackElement.TrackElement'-s for.
-- 
-- /Since: 1.6.0/
timelineElementGetTrackTypes ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> m [GES.Flags.TrackType]
    -- ^ __Returns:__ The track types that /@self@/ supports.
timelineElementGetTrackTypes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> m [TrackType]
timelineElementGetTrackTypes a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr TimelineElement -> IO CUInt
ges_timeline_element_get_track_types Ptr TimelineElement
self'
    let result' :: [TrackType]
result' = forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return [TrackType]
result'

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

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


#endif

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

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

#endif

-- method TimelineElement::lookup_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name of a child property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The return location for the\nfound child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The return location for the\nspecification of the child property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_timeline_element_lookup_child" ges_timeline_element_lookup_child :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    CString ->                              -- prop_name : TBasicType TUTF8
    Ptr (Ptr GObject.Object.Object) ->      -- child : TInterface (Name {namespace = "GObject", name = "Object"})
    Ptr (Ptr GParamSpec) ->                 -- pspec : TParamSpec
    IO CInt

-- | Looks up a child property of the element.
-- 
-- /@propName@/ can either be in the format \"prop-name\" or
-- \"TypeName[propName](#g:signal:propName)\", where \"prop-name\" is the name of the property
-- to look up (as used in @/g_object_get()/@), and \"TypeName\" is the type name
-- of the child (as returned by @/G_OBJECT_TYPE_NAME()/@). The latter format is
-- useful when two children of different types share the same property
-- name.
-- 
-- The first child found with the given \"prop-name\" property that was
-- registered with 'GI.GES.Objects.TimelineElement.timelineElementAddChildProperty' (and of the
-- type \"TypeName\", if it was given) will be passed to /@child@/, and the
-- registered specification of this property will be passed to /@pspec@/.
timelineElementLookupChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> T.Text
    -- ^ /@propName@/: The name of a child property
    -> m ((Bool, GObject.Object.Object, GParamSpec))
    -- ^ __Returns:__ 'P.True' if a child corresponding to the property was found, in
    -- which case /@child@/ and /@pspec@/ are set.
timelineElementLookupChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Text -> m (Bool, Object, GParamSpec)
timelineElementLookupChild a
self Text
propName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
propName' <- Text -> IO CString
textToCString Text
propName
    Ptr (Ptr Object)
child <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GObject.Object.Object))
    Ptr (Ptr GParamSpec)
pspec <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GParamSpec))
    CInt
result <- Ptr TimelineElement
-> CString -> Ptr (Ptr Object) -> Ptr (Ptr GParamSpec) -> IO CInt
ges_timeline_element_lookup_child Ptr TimelineElement
self' CString
propName' Ptr (Ptr Object)
child Ptr (Ptr GParamSpec)
pspec
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Ptr Object
child' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Object)
child
    Object
child'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
child'
    Ptr GParamSpec
pspec' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GParamSpec)
pspec
    GParamSpec
pspec'' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.wrapGParamSpecPtr Ptr GParamSpec
pspec'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. Ptr a -> IO ()
freeMem CString
propName'
    forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
child
    forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GParamSpec)
pspec
    forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Object
child'', GParamSpec
pspec'')

#if defined(ENABLE_OVERLOADING)
data TimelineElementLookupChildMethodInfo
instance (signature ~ (T.Text -> m ((Bool, GObject.Object.Object, GParamSpec))), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementLookupChildMethodInfo a signature where
    overloadedMethod = timelineElementLookupChild

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


#endif

-- method TimelineElement::paste
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTimelineElement to paste"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "paste_position"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The position in the timeline @element should be pasted\nto, i.e. the #GESTimelineElement:start value for the pasted element."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GES" , name = "TimelineElement" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_timeline_element_paste" ges_timeline_element_paste :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Word64 ->                               -- paste_position : TBasicType TUInt64
    IO (Ptr TimelineElement)

-- | Paste an element inside the same timeline and layer as /@self@/. /@self@/
-- **must** be the return of 'GI.GES.Objects.TimelineElement.timelineElementCopy' with @deep=TRUE@,
-- and it should not be changed before pasting.
-- /@self@/ is not placed in the timeline, instead a new element is created,
-- alike to the originally copied element. Note that the originally
-- copied element must stay within the same timeline and layer, at both
-- the point of copying and pasting.
-- 
-- Pasting may fail if it would place the timeline in an unsupported
-- configuration.
-- 
-- After calling this function /@element@/ should not be used. In particular,
-- /@element@/ can **not** be pasted again. Instead, you can copy the
-- returned element and paste that copy (although, this is only possible
-- if the paste was successful).
-- 
-- See also 'GI.GES.Objects.Timeline.timelinePasteElement'.
-- 
-- /Since: 1.6.0/
timelineElementPaste ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.TimelineElement.TimelineElement' to paste
    -> Word64
    -- ^ /@pastePosition@/: The position in the timeline /@element@/ should be pasted
    -- to, i.e. the [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") value for the pasted element.
    -> m (Maybe TimelineElement)
    -- ^ __Returns:__ The newly created element, or
    -- 'P.Nothing' if pasting fails.
timelineElementPaste :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Word64 -> m (Maybe TimelineElement)
timelineElementPaste a
self Word64
pastePosition = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TimelineElement
result <- Ptr TimelineElement -> Word64 -> IO (Ptr TimelineElement)
ges_timeline_element_paste Ptr TimelineElement
self' Word64
pastePosition
    Maybe TimelineElement
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TimelineElement
result forall a b. (a -> b) -> a -> b
$ \Ptr TimelineElement
result' -> do
        TimelineElement
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TimelineElement -> TimelineElement
TimelineElement) Ptr TimelineElement
result'
        forall (m :: * -> *) a. Monad m => a -> m a
return TimelineElement
result''
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TimelineElement
maybeResult

#if defined(ENABLE_OVERLOADING)
data TimelineElementPasteMethodInfo
instance (signature ~ (Word64 -> m (Maybe TimelineElement)), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementPasteMethodInfo a signature where
    overloadedMethod = timelineElementPaste

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


#endif

-- method TimelineElement::remove_child_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The specification for the property 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_timeline_element_remove_child_property" ges_timeline_element_remove_child_property :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    IO CInt

-- | Remove a child property from the element. /@pspec@/ should be a
-- specification that was passed to
-- 'GI.GES.Objects.TimelineElement.timelineElementAddChildProperty'. The corresponding property
-- will no longer be registered as a child property for the element.
timelineElementRemoveChildProperty ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> GParamSpec
    -- ^ /@pspec@/: The specification for the property to remove
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the property was successfully un-registered for /@self@/.
timelineElementRemoveChildProperty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> GParamSpec -> m Bool
timelineElementRemoveChildProperty a
self GParamSpec
pspec = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr GParamSpec
pspec' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    CInt
result <- Ptr TimelineElement -> Ptr GParamSpec -> IO CInt
ges_timeline_element_remove_child_property Ptr TimelineElement
self' Ptr GParamSpec
pspec'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementRemoveChildPropertyMethodInfo
instance (signature ~ (GParamSpec -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementRemoveChildPropertyMethodInfo a signature where
    overloadedMethod = timelineElementRemoveChildProperty

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


#endif

-- method TimelineElement::ripple
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTimelineElement to ripple"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new start time of @self in ripple mode"
--                 , 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_timeline_element_ripple" ges_timeline_element_ripple :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Word64 ->                               -- start : TBasicType TUInt64
    IO CInt

-- | Edits the start time of an element within its timeline in ripple mode.
-- See 'GI.GES.Objects.TimelineElement.timelineElementEdit' with @/GES_EDIT_MODE_RIPPLE/@ and
-- @/GES_EDGE_NONE/@.
timelineElementRipple ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.TimelineElement.TimelineElement' to ripple
    -> Word64
    -- ^ /@start@/: The new start time of /@self@/ in ripple mode
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the ripple edit of /@self@/ completed, 'P.False' on
    -- failure.
timelineElementRipple :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Word64 -> m Bool
timelineElementRipple a
self Word64
start = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TimelineElement -> Word64 -> IO CInt
ges_timeline_element_ripple Ptr TimelineElement
self' Word64
start
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementRippleMethodInfo
instance (signature ~ (Word64 -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementRippleMethodInfo a signature where
    overloadedMethod = timelineElementRipple

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


#endif

-- method TimelineElement::ripple_end
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTimelineElement to ripple"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new end time of @self in ripple mode"
--                 , 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_timeline_element_ripple_end" ges_timeline_element_ripple_end :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Word64 ->                               -- end : TBasicType TUInt64
    IO CInt

-- | Edits the end time of an element within its timeline in ripple mode.
-- See 'GI.GES.Objects.TimelineElement.timelineElementEdit' with @/GES_EDIT_MODE_RIPPLE/@ and
-- @/GES_EDGE_END/@.
timelineElementRippleEnd ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.TimelineElement.TimelineElement' to ripple
    -> Word64
    -- ^ /@end@/: The new end time of /@self@/ in ripple mode
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the ripple edit of /@self@/ completed, 'P.False' on
    -- failure.
timelineElementRippleEnd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Word64 -> m Bool
timelineElementRippleEnd a
self Word64
end = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TimelineElement -> Word64 -> IO CInt
ges_timeline_element_ripple_end Ptr TimelineElement
self' Word64
end
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementRippleEndMethodInfo
instance (signature ~ (Word64 -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementRippleEndMethodInfo a signature where
    overloadedMethod = timelineElementRippleEnd

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


#endif

-- method TimelineElement::roll_end
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTimelineElement to roll"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new end time of @self in roll mode"
--                 , 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_timeline_element_roll_end" ges_timeline_element_roll_end :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Word64 ->                               -- end : TBasicType TUInt64
    IO CInt

-- | Edits the end time of an element within its timeline in roll mode.
-- See 'GI.GES.Objects.TimelineElement.timelineElementEdit' with @/GES_EDIT_MODE_ROLL/@ and
-- @/GES_EDGE_END/@.
timelineElementRollEnd ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.TimelineElement.TimelineElement' to roll
    -> Word64
    -- ^ /@end@/: The new end time of /@self@/ in roll mode
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the roll edit of /@self@/ completed, 'P.False' on failure.
timelineElementRollEnd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Word64 -> m Bool
timelineElementRollEnd a
self Word64
end = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TimelineElement -> Word64 -> IO CInt
ges_timeline_element_roll_end Ptr TimelineElement
self' Word64
end
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementRollEndMethodInfo
instance (signature ~ (Word64 -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementRollEndMethodInfo a signature where
    overloadedMethod = timelineElementRollEnd

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


#endif

-- method TimelineElement::roll_start
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTimelineElement to roll"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new start time of @self in roll mode"
--                 , 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_timeline_element_roll_start" ges_timeline_element_roll_start :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Word64 ->                               -- start : TBasicType TUInt64
    IO CInt

-- | Edits the start time of an element within its timeline in roll mode.
-- See 'GI.GES.Objects.TimelineElement.timelineElementEdit' with @/GES_EDIT_MODE_ROLL/@ and
-- @/GES_EDGE_START/@.
timelineElementRollStart ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.TimelineElement.TimelineElement' to roll
    -> Word64
    -- ^ /@start@/: The new start time of /@self@/ in roll mode
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the roll edit of /@self@/ completed, 'P.False' on failure.
timelineElementRollStart :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Word64 -> m Bool
timelineElementRollStart a
self Word64
start = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TimelineElement -> Word64 -> IO CInt
ges_timeline_element_roll_start Ptr TimelineElement
self' Word64
start
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementRollStartMethodInfo
instance (signature ~ (Word64 -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementRollStartMethodInfo a signature where
    overloadedMethod = timelineElementRollStart

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


#endif

-- method TimelineElement::set_child_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name of the child property to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The value to set the property to"
--                 , 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_timeline_element_set_child_property" ges_timeline_element_set_child_property :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    CString ->                              -- property_name : TBasicType TUTF8
    Ptr GValue ->                           -- value : TGValue
    IO CInt

-- | See 'GI.GES.Objects.TimelineElement.timelineElementSetChildPropertyFull', which also gives an
-- error.
-- 
-- Note that @/ges_timeline_element_set_child_properties()/@ may be more
-- convenient for C programming.
timelineElementSetChildProperty ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> T.Text
    -- ^ /@propertyName@/: The name of the child property to set
    -> GValue
    -- ^ /@value@/: The value to set the property to
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the property was found and set.
timelineElementSetChildProperty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Text -> GValue -> m Bool
timelineElementSetChildProperty a
self Text
propertyName GValue
value = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr GValue
value' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
    CInt
result <- Ptr TimelineElement -> CString -> Ptr GValue -> IO CInt
ges_timeline_element_set_child_property Ptr TimelineElement
self' CString
propertyName' Ptr GValue
value'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
    forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementSetChildPropertyMethodInfo
instance (signature ~ (T.Text -> GValue -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementSetChildPropertyMethodInfo a signature where
    overloadedMethod = timelineElementSetChildProperty

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


#endif

-- method TimelineElement::set_child_property_by_pspec
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pspec"
--           , argType = TParamSpec
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The specification of a registered child property to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The value to set the property to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_timeline_element_set_child_property_by_pspec" ges_timeline_element_set_child_property_by_pspec :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Ptr GParamSpec ->                       -- pspec : TParamSpec
    Ptr GValue ->                           -- value : TGValue
    IO ()

-- | Sets the property of a child of the element. Specifically, the property
-- corresponding to the /@pspec@/ used in
-- 'GI.GES.Objects.TimelineElement.timelineElementAddChildProperty' is set to /@value@/.
timelineElementSetChildPropertyByPspec ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> GParamSpec
    -- ^ /@pspec@/: The specification of a registered child property to set
    -> GValue
    -- ^ /@value@/: The value to set the property to
    -> m ()
timelineElementSetChildPropertyByPspec :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> GParamSpec -> GValue -> m ()
timelineElementSetChildPropertyByPspec a
self GParamSpec
pspec GValue
value = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr GParamSpec
pspec' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
    Ptr GValue
value' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
    Ptr TimelineElement -> Ptr GParamSpec -> Ptr GValue -> IO ()
ges_timeline_element_set_child_property_by_pspec Ptr TimelineElement
self' Ptr GParamSpec
pspec' Ptr GValue
value'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TimelineElementSetChildPropertyByPspecMethodInfo
instance (signature ~ (GParamSpec -> GValue -> m ()), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementSetChildPropertyByPspecMethodInfo a signature where
    overloadedMethod = timelineElementSetChildPropertyByPspec

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


#endif

-- method TimelineElement::set_child_property_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name of the child property to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TGValue
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The value to set the property to"
--                 , 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_timeline_element_set_child_property_full" ges_timeline_element_set_child_property_full :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    CString ->                              -- property_name : TBasicType TUTF8
    Ptr GValue ->                           -- value : TGValue
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Sets the property of a child of the element.
-- 
-- /@propertyName@/ can either be in the format \"prop-name\" or
-- \"TypeName[propName](#g:signal:propName)\", where \"prop-name\" is the name of the property
-- to set (as used in @/g_object_set()/@), and \"TypeName\" is the type name of
-- the child (as returned by @/G_OBJECT_TYPE_NAME()/@). The latter format is
-- useful when two children of different types share the same property
-- name.
-- 
-- The first child found with the given \"prop-name\" property that was
-- registered with 'GI.GES.Objects.TimelineElement.timelineElementAddChildProperty' (and of the
-- type \"TypeName\", if it was given) will have the corresponding
-- property set to /@value@/. Other children that may have also matched the
-- property name (and type name) are left unchanged!
-- 
-- /Since: 1.18/
timelineElementSetChildPropertyFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> T.Text
    -- ^ /@propertyName@/: The name of the child property to set
    -> GValue
    -- ^ /@value@/: The value to set the property to
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
timelineElementSetChildPropertyFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Text -> GValue -> m ()
timelineElementSetChildPropertyFull a
self Text
propertyName GValue
value = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr GValue
value' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
    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 TimelineElement
-> CString -> Ptr GValue -> Ptr (Ptr GError) -> IO CInt
ges_timeline_element_set_child_property_full Ptr TimelineElement
self' CString
propertyName' Ptr GValue
value'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
        forall a. Ptr a -> IO ()
freeMem CString
propertyName'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
propertyName'
     )

#if defined(ENABLE_OVERLOADING)
data TimelineElementSetChildPropertyFullMethodInfo
instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementSetChildPropertyFullMethodInfo a signature where
    overloadedMethod = timelineElementSetChildPropertyFull

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


#endif

-- method TimelineElement::set_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "duration"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The desired duration in its timeline"
--                 , 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_timeline_element_set_duration" ges_timeline_element_set_duration :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Word64 ->                               -- duration : TBasicType TUInt64
    IO CInt

-- | Sets [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") for the element.
-- 
-- Whilst the element is part of a t'GI.GES.Objects.Timeline.Timeline', this is the same as
-- editing the element with 'GI.GES.Objects.TimelineElement.timelineElementEdit' under
-- @/GES_EDIT_MODE_TRIM/@ with @/GES_EDGE_END/@. In particular, the
-- [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") of the element may be snapped to a
-- different timeline time difference from the one given. In addition,
-- setting may fail if it would place the timeline in an unsupported
-- configuration, or the element does not have enough internal content to
-- last the desired duration.
timelineElementSetDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> Word64
    -- ^ /@duration@/: The desired duration in its timeline
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@duration@/ could be set for /@self@/.
timelineElementSetDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Word64 -> m Bool
timelineElementSetDuration a
self Word64
duration = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TimelineElement -> Word64 -> IO CInt
ges_timeline_element_set_duration Ptr TimelineElement
self' Word64
duration
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementSetDurationMethodInfo
instance (signature ~ (Word64 -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementSetDurationMethodInfo a signature where
    overloadedMethod = timelineElementSetDuration

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


#endif

-- method TimelineElement::set_inpoint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "inpoint"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The in-point, in internal time coordinates"
--                 , 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_timeline_element_set_inpoint" ges_timeline_element_set_inpoint :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Word64 ->                               -- inpoint : TBasicType TUInt64
    IO CInt

-- | Sets [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") for the element. If the new in-point
-- is above the current [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") of the element,
-- this method will fail.
timelineElementSetInpoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> Word64
    -- ^ /@inpoint@/: The in-point, in internal time coordinates
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@inpoint@/ could be set for /@self@/.
timelineElementSetInpoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Word64 -> m Bool
timelineElementSetInpoint a
self Word64
inpoint = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TimelineElement -> Word64 -> IO CInt
ges_timeline_element_set_inpoint Ptr TimelineElement
self' Word64
inpoint
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementSetInpointMethodInfo
instance (signature ~ (Word64 -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementSetInpointMethodInfo a signature where
    overloadedMethod = timelineElementSetInpoint

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


#endif

-- method TimelineElement::set_max_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "maxduration"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The maximum duration, in internal time coordinates"
--                 , 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_timeline_element_set_max_duration" ges_timeline_element_set_max_duration :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Word64 ->                               -- maxduration : TBasicType TUInt64
    IO CInt

-- | Sets [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") for the element. If the new
-- maximum duration is below the current [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") of
-- the element, this method will fail.
timelineElementSetMaxDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> Word64
    -- ^ /@maxduration@/: The maximum duration, in internal time coordinates
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@maxduration@/ could be set for /@self@/.
timelineElementSetMaxDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Word64 -> m Bool
timelineElementSetMaxDuration a
self Word64
maxduration = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TimelineElement -> Word64 -> IO CInt
ges_timeline_element_set_max_duration Ptr TimelineElement
self' Word64
maxduration
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementSetMaxDurationMethodInfo
instance (signature ~ (Word64 -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementSetMaxDurationMethodInfo a signature where
    overloadedMethod = timelineElementSetMaxDuration

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


#endif

-- method TimelineElement::set_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The name @self should take"
--                 , 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_timeline_element_set_name" ges_timeline_element_set_name :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    CString ->                              -- name : TBasicType TUTF8
    IO CInt

-- | Sets the [TimelineElement:name]("GI.GES.Objects.TimelineElement#g:attr:name") for the element. If 'P.Nothing' is given
-- for /@name@/, then the library will instead generate a new name based on
-- the type name of the element, such as the name \"uriclip3\" for a
-- t'GI.GES.Objects.UriClip.UriClip', and will set that name instead.
-- 
-- If /@self@/ already has a [TimelineElement:timeline]("GI.GES.Objects.TimelineElement#g:attr:timeline"), you should not
-- call this function with /@name@/ set to 'P.Nothing'.
-- 
-- You should ensure that, within each t'GI.GES.Objects.Timeline.Timeline', every element has a
-- unique name. If you call this function with /@name@/ as 'P.Nothing', then
-- the library should ensure that the set generated name is unique from
-- previously **generated** names. However, if you choose a /@name@/ that
-- interferes with the naming conventions of the library, the library will
-- attempt to ensure that the generated names will not conflict with the
-- chosen name, which may lead to a different name being set instead, but
-- the uniqueness between generated and user-chosen names is not
-- guaranteed.
timelineElementSetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> Maybe (T.Text)
    -- ^ /@name@/: The name /@self@/ should take
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@name@/ or a generated name for /@self@/ could be set.
timelineElementSetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Maybe Text -> m Bool
timelineElementSetName a
self Maybe Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeName <- case Maybe Text
name of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jName -> do
            CString
jName' <- Text -> IO CString
textToCString Text
jName
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jName'
    CInt
result <- Ptr TimelineElement -> CString -> IO CInt
ges_timeline_element_set_name Ptr TimelineElement
self' CString
maybeName
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. Ptr a -> IO ()
freeMem CString
maybeName
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementSetNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementSetNameMethodInfo a signature where
    overloadedMethod = timelineElementSetName

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


#endif

-- method TimelineElement::set_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #GESTimelineElement\n@parent (nullable): New parent of @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parent"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , 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_timeline_element_set_parent" ges_timeline_element_set_parent :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Ptr TimelineElement ->                  -- parent : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    IO CInt

-- | Sets the [TimelineElement:parent]("GI.GES.Objects.TimelineElement#g:attr:parent") for the element.
-- 
-- This is used internally and you should normally not call this. A
-- t'GI.GES.Objects.Container.Container' will set the [TimelineElement:parent]("GI.GES.Objects.TimelineElement#g:attr:parent") of its children
-- in 'GI.GES.Objects.Container.containerAdd' and 'GI.GES.Objects.Container.containerRemove'.
-- 
-- Note, if /@parent@/ is not 'P.Nothing', /@self@/ must not already have a parent
-- set. Therefore, if you wish to switch parents, you will need to call
-- this function twice: first to set the parent to 'P.Nothing', and then to the
-- new parent.
-- 
-- If /@parent@/ is not 'P.Nothing', you must ensure it already has a
-- (non-floating) reference to /@self@/ before calling this.
timelineElementSetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a, IsTimelineElement b) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -- /@parent@/ (nullable): New parent of /@self@/
    -> b
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@parent@/ could be set for /@self@/.
timelineElementSetParent :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTimelineElement a,
 IsTimelineElement b) =>
a -> b -> m Bool
timelineElementSetParent a
self b
parent = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TimelineElement
parent' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
parent
    CInt
result <- Ptr TimelineElement -> Ptr TimelineElement -> IO CInt
ges_timeline_element_set_parent Ptr TimelineElement
self' Ptr TimelineElement
parent'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
parent
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementSetParentMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsTimelineElement a, IsTimelineElement b) => O.OverloadedMethod TimelineElementSetParentMethodInfo a signature where
    overloadedMethod = timelineElementSetParent

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


#endif

-- method TimelineElement::set_priority
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "priority"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The priority" , 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_timeline_element_set_priority" ges_timeline_element_set_priority :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Word32 ->                               -- priority : TBasicType TUInt32
    IO CInt

{-# DEPRECATED timelineElementSetPriority ["(Since version 1.10)","All priority management is done by GES itself now.","To set t'GI.GES.Objects.Effect.Effect' priorities @/ges_clip_set_top_effect_index/@ should","be used."] #-}
-- | Sets the priority of the element within the containing layer.
timelineElementSetPriority ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> Word32
    -- ^ /@priority@/: The priority
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@priority@/ could be set for /@self@/.
timelineElementSetPriority :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Word32 -> m Bool
timelineElementSetPriority a
self Word32
priority = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TimelineElement -> Word32 -> IO CInt
ges_timeline_element_set_priority Ptr TimelineElement
self' Word32
priority
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementSetPriorityMethodInfo
instance (signature ~ (Word32 -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementSetPriorityMethodInfo a signature where
    overloadedMethod = timelineElementSetPriority

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


#endif

-- method TimelineElement::set_start
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESTimelineElement"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The desired start position of the element in its timeline"
--                 , 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_timeline_element_set_start" ges_timeline_element_set_start :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Word64 ->                               -- start : TBasicType TUInt64
    IO CInt

-- | Sets [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") for the element. If the element has a
-- parent, this will also move its siblings with the same shift.
-- 
-- Whilst the element is part of a t'GI.GES.Objects.Timeline.Timeline', this is the same as
-- editing the element with 'GI.GES.Objects.TimelineElement.timelineElementEdit' under
-- @/GES_EDIT_MODE_NORMAL/@ with @/GES_EDGE_NONE/@. In particular, the
-- [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") of the element may be snapped to a different
-- timeline time from the one given. In addition, setting may fail if it
-- would place the timeline in an unsupported configuration.
timelineElementSetStart ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -> Word64
    -- ^ /@start@/: The desired start position of the element in its timeline
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@start@/ could be set for /@self@/.
timelineElementSetStart :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Word64 -> m Bool
timelineElementSetStart a
self Word64
start = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TimelineElement -> Word64 -> IO CInt
ges_timeline_element_set_start Ptr TimelineElement
self' Word64
start
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementSetStartMethodInfo
instance (signature ~ (Word64 -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementSetStartMethodInfo a signature where
    overloadedMethod = timelineElementSetStart

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


#endif

-- method TimelineElement::set_timeline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #GESTimelineElement\n@timeline (nullable): The #GESTimeline @self should be in"
--                 , 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: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_timeline_element_set_timeline" ges_timeline_element_set_timeline :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Ptr GES.Timeline.Timeline ->            -- timeline : TInterface (Name {namespace = "GES", name = "Timeline"})
    IO CInt

-- | Sets the [TimelineElement:timeline]("GI.GES.Objects.TimelineElement#g:attr:timeline") of the element.
-- 
-- This is used internally and you should normally not call this. A
-- t'GI.GES.Objects.Clip.Clip' will have its [TimelineElement:timeline]("GI.GES.Objects.TimelineElement#g:attr:timeline") set through its
-- t'GI.GES.Objects.Layer.Layer'. A t'GI.GES.Objects.Track.Track' will similarly take care of setting the
-- [TimelineElement:timeline]("GI.GES.Objects.TimelineElement#g:attr:timeline") of its t'GI.GES.Objects.TrackElement.TrackElement'-s. A t'GI.GES.Objects.Group.Group'
-- will adopt the same [TimelineElement:timeline]("GI.GES.Objects.TimelineElement#g:attr:timeline") as its children.
-- 
-- If /@timeline@/ is 'P.Nothing', this will stop its current
-- [TimelineElement:timeline]("GI.GES.Objects.TimelineElement#g:attr:timeline") from tracking it, otherwise /@timeline@/ will
-- start tracking /@self@/. Note, in the latter case, /@self@/ must not already
-- have a timeline set. Therefore, if you wish to switch timelines, you
-- will need to call this function twice: first to set the timeline to
-- 'P.Nothing', and then to the new timeline.
timelineElementSetTimeline ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a, GES.Timeline.IsTimeline b) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.TimelineElement.TimelineElement'
    -- /@timeline@/ (nullable): The t'GI.GES.Objects.Timeline.Timeline' /@self@/ should be in
    -> b
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@timeline@/ could be set for /@self@/.
timelineElementSetTimeline :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTimelineElement a, IsTimeline b) =>
a -> b -> m Bool
timelineElementSetTimeline a
self b
timeline = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Timeline
timeline' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
timeline
    CInt
result <- Ptr TimelineElement -> Ptr Timeline -> IO CInt
ges_timeline_element_set_timeline Ptr TimelineElement
self' Ptr Timeline
timeline'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
timeline
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementSetTimelineMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsTimelineElement a, GES.Timeline.IsTimeline b) => O.OverloadedMethod TimelineElementSetTimelineMethodInfo a signature where
    overloadedMethod = timelineElementSetTimeline

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


#endif

-- method TimelineElement::trim
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TimelineElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTimelineElement to trim"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new start time of @self in trim mode"
--                 , 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_timeline_element_trim" ges_timeline_element_trim :: 
    Ptr TimelineElement ->                  -- self : TInterface (Name {namespace = "GES", name = "TimelineElement"})
    Word64 ->                               -- start : TBasicType TUInt64
    IO CInt

-- | Edits the start time of an element within its timeline in trim mode.
-- See 'GI.GES.Objects.TimelineElement.timelineElementEdit' with @/GES_EDIT_MODE_TRIM/@ and
-- @/GES_EDGE_START/@.
timelineElementTrim ::
    (B.CallStack.HasCallStack, MonadIO m, IsTimelineElement a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.TimelineElement.TimelineElement' to trim
    -> Word64
    -- ^ /@start@/: The new start time of /@self@/ in trim mode
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the trim edit of /@self@/ completed, 'P.False' on failure.
timelineElementTrim :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTimelineElement a) =>
a -> Word64 -> m Bool
timelineElementTrim a
self Word64
start = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TimelineElement
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TimelineElement -> Word64 -> IO CInt
ges_timeline_element_trim Ptr TimelineElement
self' Word64
start
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TimelineElementTrimMethodInfo
instance (signature ~ (Word64 -> m Bool), MonadIO m, IsTimelineElement a) => O.OverloadedMethod TimelineElementTrimMethodInfo a signature where
    overloadedMethod = timelineElementTrim

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


#endif