{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.GES.Objects.Clip.Clip'-s are the core objects of a t'GI.GES.Objects.Layer.Layer'. Each clip may exist in
-- a single layer but may control several t'GI.GES.Objects.TrackElement.TrackElement'-s that span
-- several t'GI.GES.Objects.Track.Track'-s. A clip will ensure that all its children share the
-- same [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") and [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") in
-- their tracks, which will match the [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") and
-- [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") of the clip itself. Therefore, changing
-- the timing of the clip will change the timing of the children, and a
-- change in the timing of a child will change the timing of the clip and
-- subsequently all its siblings. As such, a clip can be treated as a
-- singular object in its layer.
-- 
-- For most uses of a t'GI.GES.Objects.Timeline.Timeline', it is often sufficient to only
-- interact with t'GI.GES.Objects.Clip.Clip'-s directly, which will take care of creating and
-- organising the elements of the timeline\'s tracks.
-- 
-- == Core Children
-- 
-- In more detail, clips will usually have some *core* t'GI.GES.Objects.TrackElement.TrackElement'
-- children, which are created by the clip when it is added to a layer in
-- a timeline. The type and form of these core children will depend on the
-- clip\'s subclass. You can use 'GI.GES.Objects.TrackElement.trackElementIsCore' to determine
-- whether a track element is considered such a core track element. Note,
-- if a core track element is part of a clip, it will always be treated as
-- a core *child* of the clip. You can connect to the
-- [Container::childAdded]("GI.GES.Objects.Container#g:signal:childAdded") signal to be notified of their creation.
-- 
-- When a child is added to a clip, the timeline will select its tracks
-- using [Timeline::selectTracksForObject]("GI.GES.Objects.Timeline#g:signal:selectTracksForObject"). Note that it may be the
-- case that the child will still have no set [TrackElement:track]("GI.GES.Objects.TrackElement#g:attr:track")
-- after this process. For example, if the timeline does not have a track
-- of the corresponding [Track:trackType]("GI.GES.Objects.Track#g:attr:trackType"). A clip can safely contain
-- such children, which may have their track set later, although they will
-- play no functioning role in the timeline in the meantime.
-- 
-- If a clip may create track elements with various
-- [TrackElement:trackType]("GI.GES.Objects.TrackElement#g:attr:trackType")(s), such as a t'GI.GES.Objects.UriClip.UriClip', but you only
-- want it to create a subset of these types, you should set the
-- [Clip:supportedFormats]("GI.GES.Objects.Clip#g:attr:supportedFormats") of the clip to the subset of types. This
-- should be done *before* adding the clip to a layer.
-- 
-- If a clip will produce several core elements of the same
-- [TrackElement:trackType]("GI.GES.Objects.TrackElement#g:attr:trackType"), you should connect to the timeline\'s
-- [Timeline::selectTracksForObject]("GI.GES.Objects.Timeline#g:signal:selectTracksForObject") signal to coordinate which
-- tracks each element should land in. Note, no two core children within a
-- clip can share the same t'GI.GES.Objects.Track.Track', so you should not select the same
-- track for two separate core children. Provided you stick to this rule,
-- it is still safe to select several tracks for the same core child, the
-- core child will be copied into the additional tracks. You can manually
-- add the child to more tracks later using 'GI.GES.Objects.Clip.clipAddChildToTrack'.
-- If you do not wish to use a core child, you can always select no track.
-- 
-- The [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") of the clip will control the
-- [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") of its core children to be the same
-- value if their [TrackElement:hasInternalSource]("GI.GES.Objects.TrackElement#g:attr:hasInternalSource") is set to 'P.True'.
-- 
-- The [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") of the clip is the minimum
-- [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") of its core children. If you set its
-- value to anything other than its current value, this will also set the
-- [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") of all its core children to the same
-- value if their [TrackElement:hasInternalSource]("GI.GES.Objects.TrackElement#g:attr:hasInternalSource") is set to 'P.True'.
-- As a special case, whilst a clip does not yet have any core children,
-- its [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") may be set to indicate what its
-- value will be once they are created.
-- 
-- == Effects
-- 
-- Some subclasses (t'GI.GES.Objects.SourceClip.SourceClip' and t'GI.GES.Objects.BaseEffectClip.BaseEffectClip') may also allow
-- their objects to have additional non-core t'GI.GES.Objects.BaseEffect.BaseEffect'-s elements as
-- children. These are additional effects that are applied to the output
-- data of the core elements. They can be added to the clip using
-- 'GI.GES.Objects.Clip.clipAddTopEffect', which will take care of adding the effect to
-- the timeline\'s tracks. The new effect will be placed between the clip\'s
-- core track elements and its other effects. As such, the newly added
-- effect will be applied to any source data **before** the other existing
-- effects. You can change the ordering of effects using
-- 'GI.GES.Objects.Clip.clipSetTopEffectIndex'.
-- 
-- Tracks are selected for top effects in the same way as core children.
-- If you add a top effect to a clip before it is part of a timeline, and
-- later add the clip to a timeline, the track selection for the top
-- effects will occur just after the track selection for the core
-- children. If you add a top effect to a clip that is already part of a
-- timeline, the track selection will occur immediately. Since a top
-- effect must be applied on top of a core child, if you use
-- [Timeline::selectTracksForObject]("GI.GES.Objects.Timeline#g:signal:selectTracksForObject"), you should ensure that the
-- added effects are destined for a t'GI.GES.Objects.Track.Track' that already contains a core
-- child.
-- 
-- In addition, if the core child in the track is not
-- [TrackElement:active]("GI.GES.Objects.TrackElement#g:attr:active"), then neither can any of its effects be
-- [TrackElement:active]("GI.GES.Objects.TrackElement#g:attr:active"). Therefore, if a core child is made in-active,
-- all of the additional effects in the same track will also become
-- in-active. Similarly, if an effect is set to be active, then the core
-- child will also become active, but other effects will be left alone.
-- Finally, if an active effect is added to the track of an in-active core
-- child, it will become in-active as well. Note, in contrast, setting a
-- core child to be active, or an effect to be in-active will *not* change
-- the other children in the same track.
-- 
-- === Time Effects
-- 
-- Some effects also change the timing of their data (see t'GI.GES.Objects.BaseEffect.BaseEffect'
-- for what counts as a time effect). Note that a t'GI.GES.Objects.BaseEffectClip.BaseEffectClip' will
-- refuse time effects, but a t'GI.GES.Objects.Source.Source' will allow them.
-- 
-- When added to a clip, time effects may adjust the timing of other
-- children in the same track. Similarly, when changing the order of
-- effects, making them (in)-active, setting their time property values
-- or removing time effects. These can cause the [Clip:durationLimit]("GI.GES.Objects.Clip#g:attr:durationLimit")
-- to change in value. However, if such an operation would ever cause the
-- [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") to shrink such that a clip\'s t'GI.GES.Objects.Source.Source' is
-- totally overlapped in the timeline, the operation would be prevented.
-- Note that the same can happen when adding non-time effects with a
-- finite [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration").
-- 
-- Therefore, when working with time effects, you should -- more so than
-- usual -- not assume that setting the properties of the clip\'s children
-- will succeed. In particular, you should use
-- 'GI.GES.Objects.TimelineElement.timelineElementSetChildPropertyFull' when setting the time
-- properties.
-- 
-- If you wish to preserve the *internal* duration of a source in a clip
-- during these time effect operations, you can do something like the
-- following.
-- 
-- 
-- === /c code/
-- >void
-- >do_time_effect_change (GESClip * clip)
-- >{
-- >  GList *tmp, *children;
-- >  GESTrackElement *source;
-- >  GstClockTime source_outpoint;
-- >  GstClockTime new_end;
-- >  GError *error = NULL;
-- >
-- >  // choose some active source in a track to preserve the internal
-- >  // duration of
-- >  source = ges_clip_get_track_element (clip, NULL, GES_TYPE_SOURCE);
-- >
-- >  // note its current internal end time
-- >  source_outpoint = ges_clip_get_internal_time_from_timeline_time (
-- >        clip, source, GES_TIMELINE_ELEMENT_END (clip), NULL);
-- >
-- >  // handle invalid out-point
-- >
-- >  // stop the children's control sources from clamping when their
-- >  // out-point changes with a change in the time effects
-- >  children = ges_container_get_children (GES_CONTAINER (clip), FALSE);
-- >
-- >  for (tmp = children; tmp; tmp = tmp->next)
-- >    ges_track_element_set_auto_clamp_control_sources (tmp->data, FALSE);
-- >
-- >  // add time effect, or set their children properties, or move them around
-- >  ...
-- >  // user can make sure that if a time effect changes one source, we should
-- >  // also change the time effect for another source. E.g. if
-- >  // "GstVideorate::rate" is set to 2.0, we also set "GstPitch::rate" to
-- >  // 2.0
-- >
-- >  // Note the duration of the clip may have already changed if the
-- >  // duration-limit of the clip dropped below its current value
-- >
-- >  new_end = ges_clip_get_timeline_time_from_internal_time (
-- >        clip, source, source_outpoint, &error);
-- >  // handle error
-- >
-- >  if (!ges_timeline_elemnet_edit_full (GES_TIMELINE_ELEMENT (clip),
-- >        -1, GES_EDIT_MODE_TRIM, GES_EDGE_END, new_end, &error))
-- >    // handle error
-- >
-- >  for (tmp = children; tmp; tmp = tmp->next)
-- >    ges_track_element_set_auto_clamp_control_sources (tmp->data, TRUE);
-- >
-- >  g_list_free_full (children, gst_object_unref);
-- >  gst_object_unref (source);
-- >}
-- 

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

module GI.GES.Objects.Clip
    ( 

-- * Exported types
    Clip(..)                                ,
    IsClip                                  ,
    toClip                                  ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [add]("GI.GES.Objects.Container#g:method:add"), [addAsset]("GI.GES.Objects.Clip#g:method:addAsset"), [addChildProperty]("GI.GES.Objects.TimelineElement#g:method:addChildProperty"), [addChildToTrack]("GI.GES.Objects.Clip#g:method:addChildToTrack"), [addMetasFromString]("GI.GES.Interfaces.MetaContainer#g:method:addMetasFromString"), [addTopEffect]("GI.GES.Objects.Clip#g:method:addTopEffect"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [checkMetaRegistered]("GI.GES.Interfaces.MetaContainer#g:method:checkMetaRegistered"), [copy]("GI.GES.Objects.TimelineElement#g:method:copy"), [edit]("GI.GES.Objects.Container#g:method:edit"), [editFull]("GI.GES.Objects.TimelineElement#g:method:editFull"), [findTrackElement]("GI.GES.Objects.Clip#g:method:findTrackElement"), [findTrackElements]("GI.GES.Objects.Clip#g:method:findTrackElements"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.GES.Interfaces.MetaContainer#g:method:foreach"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [listChildrenProperties]("GI.GES.Objects.TimelineElement#g:method:listChildrenProperties"), [lookupChild]("GI.GES.Objects.TimelineElement#g:method:lookupChild"), [metasToString]("GI.GES.Interfaces.MetaContainer#g:method:metasToString"), [moveToLayer]("GI.GES.Objects.Clip#g:method:moveToLayer"), [moveToLayerFull]("GI.GES.Objects.Clip#g:method:moveToLayerFull"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [paste]("GI.GES.Objects.TimelineElement#g:method:paste"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [registerMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerMeta"), [registerMetaBoolean]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaBoolean"), [registerMetaDate]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDate"), [registerMetaDateTime]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDateTime"), [registerMetaDouble]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDouble"), [registerMetaFloat]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaFloat"), [registerMetaInt]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt"), [registerMetaInt64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt64"), [registerMetaString]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaString"), [registerMetaUint]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint"), [registerMetaUint64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint64"), [registerStaticMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerStaticMeta"), [remove]("GI.GES.Objects.Container#g:method:remove"), [removeChildProperty]("GI.GES.Objects.TimelineElement#g:method:removeChildProperty"), [removeTopEffect]("GI.GES.Objects.Clip#g:method:removeTopEffect"), [ripple]("GI.GES.Objects.TimelineElement#g:method:ripple"), [rippleEnd]("GI.GES.Objects.TimelineElement#g:method:rippleEnd"), [rollEnd]("GI.GES.Objects.TimelineElement#g:method:rollEnd"), [rollStart]("GI.GES.Objects.TimelineElement#g:method:rollStart"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [split]("GI.GES.Objects.Clip#g:method:split"), [splitFull]("GI.GES.Objects.Clip#g:method:splitFull"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [trim]("GI.GES.Objects.TimelineElement#g:method:trim"), [ungroup]("GI.GES.Objects.Container#g:method:ungroup"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAsset]("GI.GES.Interfaces.Extractable#g:method:getAsset"), [getBoolean]("GI.GES.Interfaces.MetaContainer#g:method:getBoolean"), [getChildProperty]("GI.GES.Objects.TimelineElement#g:method:getChildProperty"), [getChildPropertyByPspec]("GI.GES.Objects.TimelineElement#g:method:getChildPropertyByPspec"), [getChildren]("GI.GES.Objects.Container#g:method:getChildren"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDate]("GI.GES.Interfaces.MetaContainer#g:method:getDate"), [getDateTime]("GI.GES.Interfaces.MetaContainer#g:method:getDateTime"), [getDouble]("GI.GES.Interfaces.MetaContainer#g:method:getDouble"), [getDuration]("GI.GES.Objects.TimelineElement#g:method:getDuration"), [getDurationLimit]("GI.GES.Objects.Clip#g:method:getDurationLimit"), [getFloat]("GI.GES.Interfaces.MetaContainer#g:method:getFloat"), [getId]("GI.GES.Interfaces.Extractable#g:method:getId"), [getInpoint]("GI.GES.Objects.TimelineElement#g:method:getInpoint"), [getInt]("GI.GES.Interfaces.MetaContainer#g:method:getInt"), [getInt64]("GI.GES.Interfaces.MetaContainer#g:method:getInt64"), [getInternalTimeFromTimelineTime]("GI.GES.Objects.Clip#g:method:getInternalTimeFromTimelineTime"), [getLayer]("GI.GES.Objects.Clip#g:method:getLayer"), [getLayerPriority]("GI.GES.Objects.TimelineElement#g:method:getLayerPriority"), [getMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:getMarkerList"), [getMaxDuration]("GI.GES.Objects.TimelineElement#g:method:getMaxDuration"), [getMeta]("GI.GES.Interfaces.MetaContainer#g:method:getMeta"), [getName]("GI.GES.Objects.TimelineElement#g:method:getName"), [getNaturalFramerate]("GI.GES.Objects.TimelineElement#g:method:getNaturalFramerate"), [getParent]("GI.GES.Objects.TimelineElement#g:method:getParent"), [getPriority]("GI.GES.Objects.TimelineElement#g:method:getPriority"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getStart]("GI.GES.Objects.TimelineElement#g:method:getStart"), [getString]("GI.GES.Interfaces.MetaContainer#g:method:getString"), [getSupportedFormats]("GI.GES.Objects.Clip#g:method:getSupportedFormats"), [getTimeline]("GI.GES.Objects.TimelineElement#g:method:getTimeline"), [getTimelineTimeFromInternalTime]("GI.GES.Objects.Clip#g:method:getTimelineTimeFromInternalTime"), [getTimelineTimeFromSourceFrame]("GI.GES.Objects.Clip#g:method:getTimelineTimeFromSourceFrame"), [getTopEffectIndex]("GI.GES.Objects.Clip#g:method:getTopEffectIndex"), [getTopEffectPosition]("GI.GES.Objects.Clip#g:method:getTopEffectPosition"), [getTopEffects]("GI.GES.Objects.Clip#g:method:getTopEffects"), [getToplevelParent]("GI.GES.Objects.TimelineElement#g:method:getToplevelParent"), [getTrackTypes]("GI.GES.Objects.TimelineElement#g:method:getTrackTypes"), [getUint]("GI.GES.Interfaces.MetaContainer#g:method:getUint"), [getUint64]("GI.GES.Interfaces.MetaContainer#g:method:getUint64").
-- 
-- ==== 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"), [setSupportedFormats]("GI.GES.Objects.Clip#g:method:setSupportedFormats"), [setTimeline]("GI.GES.Objects.TimelineElement#g:method:setTimeline"), [setTopEffectIndex]("GI.GES.Objects.Clip#g:method:setTopEffectIndex"), [setTopEffectIndexFull]("GI.GES.Objects.Clip#g:method:setTopEffectIndexFull"), [setTopEffectPriority]("GI.GES.Objects.Clip#g:method:setTopEffectPriority"), [setUint]("GI.GES.Interfaces.MetaContainer#g:method:setUint"), [setUint64]("GI.GES.Interfaces.MetaContainer#g:method:setUint64").

#if defined(ENABLE_OVERLOADING)
    ResolveClipMethod                       ,
#endif

-- ** addAsset #method:addAsset#

#if defined(ENABLE_OVERLOADING)
    ClipAddAssetMethodInfo                  ,
#endif
    clipAddAsset                            ,


-- ** addChildToTrack #method:addChildToTrack#

#if defined(ENABLE_OVERLOADING)
    ClipAddChildToTrackMethodInfo           ,
#endif
    clipAddChildToTrack                     ,


-- ** addTopEffect #method:addTopEffect#

#if defined(ENABLE_OVERLOADING)
    ClipAddTopEffectMethodInfo              ,
#endif
    clipAddTopEffect                        ,


-- ** findTrackElement #method:findTrackElement#

#if defined(ENABLE_OVERLOADING)
    ClipFindTrackElementMethodInfo          ,
#endif
    clipFindTrackElement                    ,


-- ** findTrackElements #method:findTrackElements#

#if defined(ENABLE_OVERLOADING)
    ClipFindTrackElementsMethodInfo         ,
#endif
    clipFindTrackElements                   ,


-- ** getDurationLimit #method:getDurationLimit#

#if defined(ENABLE_OVERLOADING)
    ClipGetDurationLimitMethodInfo          ,
#endif
    clipGetDurationLimit                    ,


-- ** getInternalTimeFromTimelineTime #method:getInternalTimeFromTimelineTime#

#if defined(ENABLE_OVERLOADING)
    ClipGetInternalTimeFromTimelineTimeMethodInfo,
#endif
    clipGetInternalTimeFromTimelineTime     ,


-- ** getLayer #method:getLayer#

#if defined(ENABLE_OVERLOADING)
    ClipGetLayerMethodInfo                  ,
#endif
    clipGetLayer                            ,


-- ** getSupportedFormats #method:getSupportedFormats#

#if defined(ENABLE_OVERLOADING)
    ClipGetSupportedFormatsMethodInfo       ,
#endif
    clipGetSupportedFormats                 ,


-- ** getTimelineTimeFromInternalTime #method:getTimelineTimeFromInternalTime#

#if defined(ENABLE_OVERLOADING)
    ClipGetTimelineTimeFromInternalTimeMethodInfo,
#endif
    clipGetTimelineTimeFromInternalTime     ,


-- ** getTimelineTimeFromSourceFrame #method:getTimelineTimeFromSourceFrame#

#if defined(ENABLE_OVERLOADING)
    ClipGetTimelineTimeFromSourceFrameMethodInfo,
#endif
    clipGetTimelineTimeFromSourceFrame      ,


-- ** getTopEffectIndex #method:getTopEffectIndex#

#if defined(ENABLE_OVERLOADING)
    ClipGetTopEffectIndexMethodInfo         ,
#endif
    clipGetTopEffectIndex                   ,


-- ** getTopEffectPosition #method:getTopEffectPosition#

#if defined(ENABLE_OVERLOADING)
    ClipGetTopEffectPositionMethodInfo      ,
#endif
    clipGetTopEffectPosition                ,


-- ** getTopEffects #method:getTopEffects#

#if defined(ENABLE_OVERLOADING)
    ClipGetTopEffectsMethodInfo             ,
#endif
    clipGetTopEffects                       ,


-- ** moveToLayer #method:moveToLayer#

#if defined(ENABLE_OVERLOADING)
    ClipMoveToLayerMethodInfo               ,
#endif
    clipMoveToLayer                         ,


-- ** moveToLayerFull #method:moveToLayerFull#

#if defined(ENABLE_OVERLOADING)
    ClipMoveToLayerFullMethodInfo           ,
#endif
    clipMoveToLayerFull                     ,


-- ** removeTopEffect #method:removeTopEffect#

#if defined(ENABLE_OVERLOADING)
    ClipRemoveTopEffectMethodInfo           ,
#endif
    clipRemoveTopEffect                     ,


-- ** setSupportedFormats #method:setSupportedFormats#

#if defined(ENABLE_OVERLOADING)
    ClipSetSupportedFormatsMethodInfo       ,
#endif
    clipSetSupportedFormats                 ,


-- ** setTopEffectIndex #method:setTopEffectIndex#

#if defined(ENABLE_OVERLOADING)
    ClipSetTopEffectIndexMethodInfo         ,
#endif
    clipSetTopEffectIndex                   ,


-- ** setTopEffectIndexFull #method:setTopEffectIndexFull#

#if defined(ENABLE_OVERLOADING)
    ClipSetTopEffectIndexFullMethodInfo     ,
#endif
    clipSetTopEffectIndexFull               ,


-- ** setTopEffectPriority #method:setTopEffectPriority#

#if defined(ENABLE_OVERLOADING)
    ClipSetTopEffectPriorityMethodInfo      ,
#endif
    clipSetTopEffectPriority                ,


-- ** split #method:split#

#if defined(ENABLE_OVERLOADING)
    ClipSplitMethodInfo                     ,
#endif
    clipSplit                               ,


-- ** splitFull #method:splitFull#

#if defined(ENABLE_OVERLOADING)
    ClipSplitFullMethodInfo                 ,
#endif
    clipSplitFull                           ,




 -- * Properties


-- ** durationLimit #attr:durationLimit#
-- | The maximum [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") that can be *currently* set
-- for the clip, taking into account the [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint"),
-- [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration"), [TrackElement:active]("GI.GES.Objects.TrackElement#g:attr:active"), and
-- [TrackElement:track]("GI.GES.Objects.TrackElement#g:attr:track") properties of its children, as well as any
-- time effects. If there is no limit, this will be set to
-- 'GI.Gst.Constants.CLOCK_TIME_NONE'.
-- 
-- Note that whilst a clip has no children in any tracks, the limit will
-- be unknown, and similarly set to 'GI.Gst.Constants.CLOCK_TIME_NONE'.
-- 
-- If the duration-limit would ever go below the current
-- [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") of the clip due to a change in the above
-- variables, its [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") will be set to the new
-- limit.
-- 
-- /Since: 1.18/

#if defined(ENABLE_OVERLOADING)
    ClipDurationLimitPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    clipDurationLimit                       ,
#endif
    getClipDurationLimit                    ,


-- ** layer #attr:layer#
-- | The layer this clip lies in.
-- 
-- If you want to connect to this property\'s [Object::notify]("GI.GObject.Objects.Object#g:signal:notify") signal,
-- you should connect to it with @/g_signal_connect_after()/@ since the
-- signal emission may be stopped internally.

#if defined(ENABLE_OVERLOADING)
    ClipLayerPropertyInfo                   ,
#endif
#if defined(ENABLE_OVERLOADING)
    clipLayer                               ,
#endif
    getClipLayer                            ,


-- ** supportedFormats #attr:supportedFormats#
-- | The t'GI.GES.Flags.TrackType'-s that the clip supports, which it can create
-- t'GI.GES.Objects.TrackElement.TrackElement'-s for. Note that this can be a combination of
-- t'GI.GES.Flags.TrackType' flags to indicate support for several
-- [TrackElement:trackType]("GI.GES.Objects.TrackElement#g:attr:trackType") elements.

#if defined(ENABLE_OVERLOADING)
    ClipSupportedFormatsPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    clipSupportedFormats                    ,
#endif
    constructClipSupportedFormats           ,
    getClipSupportedFormats                 ,
    setClipSupportedFormats                 ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GES.Callbacks as GES.Callbacks
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.Asset as GES.Asset
import {-# SOURCE #-} qualified GI.GES.Objects.BaseEffect as GES.BaseEffect
import {-# SOURCE #-} qualified GI.GES.Objects.Container as GES.Container
import {-# SOURCE #-} qualified GI.GES.Objects.Group as GES.Group
import {-# SOURCE #-} qualified GI.GES.Objects.Layer as GES.Layer
import {-# SOURCE #-} qualified GI.GES.Objects.Marker as GES.Marker
import {-# SOURCE #-} qualified GI.GES.Objects.MarkerList as GES.MarkerList
import {-# SOURCE #-} qualified GI.GES.Objects.Operation as GES.Operation
import {-# SOURCE #-} qualified GI.GES.Objects.Timeline as GES.Timeline
import {-# SOURCE #-} qualified GI.GES.Objects.TimelineElement as GES.TimelineElement
import {-# SOURCE #-} qualified GI.GES.Objects.Track as GES.Track
import {-# SOURCE #-} qualified GI.GES.Objects.TrackElement as GES.TrackElement
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Date as GLib.Date
import qualified GI.GObject.Objects.InitiallyUnowned as GObject.InitiallyUnowned
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncInitable as Gio.AsyncInitable
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gst.Interfaces.ChildProxy as Gst.ChildProxy
import qualified GI.Gst.Objects.Bin as Gst.Bin
import qualified GI.Gst.Objects.ControlBinding as Gst.ControlBinding
import qualified GI.Gst.Objects.ControlSource as Gst.ControlSource
import qualified GI.Gst.Objects.Element as Gst.Element
import qualified GI.Gst.Objects.Object as Gst.Object
import qualified GI.Gst.Objects.Pad as Gst.Pad
import qualified GI.Gst.Structs.Caps as Gst.Caps
import qualified GI.Gst.Structs.DateTime as Gst.DateTime

#else
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.Asset as GES.Asset
import {-# SOURCE #-} qualified GI.GES.Objects.BaseEffect as GES.BaseEffect
import {-# SOURCE #-} qualified GI.GES.Objects.Container as GES.Container
import {-# SOURCE #-} qualified GI.GES.Objects.Layer as GES.Layer
import {-# SOURCE #-} qualified GI.GES.Objects.TimelineElement as GES.TimelineElement
import {-# SOURCE #-} qualified GI.GES.Objects.Track as GES.Track
import {-# SOURCE #-} qualified GI.GES.Objects.TrackElement as GES.TrackElement
import qualified GI.GObject.Objects.Object as GObject.Object

#endif

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

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

foreign import ccall "ges_clip_get_type"
    c_ges_clip_get_type :: IO B.Types.GType

instance B.Types.TypedObject Clip where
    glibType :: IO GType
glibType = IO GType
c_ges_clip_get_type

instance B.Types.GObject Clip

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

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

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

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

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

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

#endif

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

#endif

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

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

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

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

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

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data ClipSupportedFormatsPropertyInfo
instance AttrInfo ClipSupportedFormatsPropertyInfo where
    type AttrAllowedOps ClipSupportedFormatsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ClipSupportedFormatsPropertyInfo = IsClip
    type AttrSetTypeConstraint ClipSupportedFormatsPropertyInfo = (~) [GES.Flags.TrackType]
    type AttrTransferTypeConstraint ClipSupportedFormatsPropertyInfo = (~) [GES.Flags.TrackType]
    type AttrTransferType ClipSupportedFormatsPropertyInfo = [GES.Flags.TrackType]
    type AttrGetType ClipSupportedFormatsPropertyInfo = [GES.Flags.TrackType]
    type AttrLabel ClipSupportedFormatsPropertyInfo = "supported-formats"
    type AttrOrigin ClipSupportedFormatsPropertyInfo = Clip
    attrGet = getClipSupportedFormats
    attrSet = setClipSupportedFormats
    attrTransfer _ v = do
        return v
    attrConstruct = constructClipSupportedFormats
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Clip.supportedFormats"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-Clip.html#g:attr:supportedFormats"
        })
#endif

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

#if defined(ENABLE_OVERLOADING)
clipDurationLimit :: AttrLabelProxy "durationLimit"
clipDurationLimit = AttrLabelProxy

clipLayer :: AttrLabelProxy "layer"
clipLayer = AttrLabelProxy

clipSupportedFormats :: AttrLabelProxy "supportedFormats"
clipSupportedFormats = AttrLabelProxy

#endif

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

#endif

-- method Clip::add_asset
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "asset"
--           , argType = TInterface Name { namespace = "GES" , name = "Asset" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "An asset with #GES_TYPE_TRACK_ELEMENT as its\n#GESAsset:extractable-type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GES" , name = "TrackElement" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_clip_add_asset" ges_clip_add_asset :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.Asset.Asset ->                  -- asset : TInterface (Name {namespace = "GES", name = "Asset"})
    IO (Ptr GES.TrackElement.TrackElement)

-- | Extracts a t'GI.GES.Objects.TrackElement.TrackElement' from an asset and adds it to the clip.
-- This can be used to add effects that derive from the asset to the
-- clip, but this method is not intended to be used to create the core
-- elements of the clip.
clipAddAsset ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.Asset.IsAsset b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> b
    -- ^ /@asset@/: An asset with @/GES_TYPE_TRACK_ELEMENT/@ as its
    -- [Asset:extractableType]("GI.GES.Objects.Asset#g:attr:extractableType")
    -> m (Maybe GES.TrackElement.TrackElement)
    -- ^ __Returns:__ The newly created element, or
    -- 'P.Nothing' if an error occurred.
clipAddAsset :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsAsset b) =>
a -> b -> m (Maybe TrackElement)
clipAddAsset a
clip b
asset = IO (Maybe TrackElement) -> m (Maybe TrackElement)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TrackElement) -> m (Maybe TrackElement))
-> IO (Maybe TrackElement) -> m (Maybe TrackElement)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr Asset
asset' <- b -> IO (Ptr Asset)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
asset
    Ptr TrackElement
result <- Ptr Clip -> Ptr Asset -> IO (Ptr TrackElement)
ges_clip_add_asset Ptr Clip
clip' Ptr Asset
asset'
    Maybe TrackElement
maybeResult <- Ptr TrackElement
-> (Ptr TrackElement -> IO TrackElement) -> IO (Maybe TrackElement)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TrackElement
result ((Ptr TrackElement -> IO TrackElement) -> IO (Maybe TrackElement))
-> (Ptr TrackElement -> IO TrackElement) -> IO (Maybe TrackElement)
forall a b. (a -> b) -> a -> b
$ \Ptr TrackElement
result' -> do
        TrackElement
result'' <- ((ManagedPtr TrackElement -> TrackElement)
-> Ptr TrackElement -> IO TrackElement
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TrackElement -> TrackElement
GES.TrackElement.TrackElement) Ptr TrackElement
result'
        TrackElement -> IO TrackElement
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TrackElement
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
asset
    Maybe TrackElement -> IO (Maybe TrackElement)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TrackElement
maybeResult

#if defined(ENABLE_OVERLOADING)
data ClipAddAssetMethodInfo
instance (signature ~ (b -> m (Maybe GES.TrackElement.TrackElement)), MonadIO m, IsClip a, GES.Asset.IsAsset b) => O.OverloadedMethod ClipAddAssetMethodInfo a signature where
    overloadedMethod = clipAddAsset

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


#endif

-- method Clip::add_child_to_track
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A child of @clip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "track"
--           , argType = TInterface Name { namespace = "GES" , name = "Track" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The track to add @child to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GES" , name = "TrackElement" })
-- throws : True
-- Skip return : False

foreign import ccall "ges_clip_add_child_to_track" ges_clip_add_child_to_track :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.TrackElement.TrackElement ->    -- child : TInterface (Name {namespace = "GES", name = "TrackElement"})
    Ptr GES.Track.Track ->                  -- track : TInterface (Name {namespace = "GES", name = "Track"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr GES.TrackElement.TrackElement)

-- | Adds the track element child of the clip to a specific track.
-- 
-- If the given child is already in another track, this will create a copy
-- of the child, add it to the clip, and add this copy to the track.
-- 
-- You should only call this whilst a clip is part of a t'GI.GES.Objects.Timeline.Timeline', and
-- for tracks that are in the same timeline.
-- 
-- This method is an alternative to using the
-- [Timeline::selectTracksForObject]("GI.GES.Objects.Timeline#g:signal:selectTracksForObject") signal, but can be used to
-- complement it when, say, you wish to copy a clip\'s children from one
-- track into a new one.
-- 
-- When the child is a core child, it must be added to a track that does
-- not already contain another core child of the same clip. If it is not a
-- core child (an additional effect), then it must be added to a track
-- that already contains one of the core children of the same clip.
-- 
-- This method can also fail if the adding the track element to the track
-- would break a configuration rule of the corresponding t'GI.GES.Objects.Timeline.Timeline',
-- such as causing three sources to overlap at a single time, or causing
-- a source to completely overlap another in the same track.
-- 
-- /Since: 1.18/
clipAddChildToTrack ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.TrackElement.IsTrackElement b, GES.Track.IsTrack c) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> b
    -- ^ /@child@/: A child of /@clip@/
    -> c
    -- ^ /@track@/: The track to add /@child@/ to
    -> m GES.TrackElement.TrackElement
    -- ^ __Returns:__ The element that was added to /@track@/, either
    -- /@child@/ or a copy of child, or 'P.Nothing' if the element could not be added. /(Can throw 'Data.GI.Base.GError.GError')/
clipAddChildToTrack :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsClip a, IsTrackElement b, IsTrack c) =>
a -> b -> c -> m TrackElement
clipAddChildToTrack a
clip b
child c
track = IO TrackElement -> m TrackElement
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TrackElement -> m TrackElement)
-> IO TrackElement -> m TrackElement
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr TrackElement
child' <- b -> IO (Ptr TrackElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Track
track' <- c -> IO (Ptr Track)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
track
    IO TrackElement -> IO () -> IO TrackElement
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr TrackElement
result <- (Ptr (Ptr GError) -> IO (Ptr TrackElement))
-> IO (Ptr TrackElement)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr TrackElement))
 -> IO (Ptr TrackElement))
-> (Ptr (Ptr GError) -> IO (Ptr TrackElement))
-> IO (Ptr TrackElement)
forall a b. (a -> b) -> a -> b
$ Ptr Clip
-> Ptr TrackElement
-> Ptr Track
-> Ptr (Ptr GError)
-> IO (Ptr TrackElement)
ges_clip_add_child_to_track Ptr Clip
clip' Ptr TrackElement
child' Ptr Track
track'
        Text -> Ptr TrackElement -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"clipAddChildToTrack" Ptr TrackElement
result
        TrackElement
result' <- ((ManagedPtr TrackElement -> TrackElement)
-> Ptr TrackElement -> IO TrackElement
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TrackElement -> TrackElement
GES.TrackElement.TrackElement) Ptr TrackElement
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
        c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
track
        TrackElement -> IO TrackElement
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TrackElement
result'
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ClipAddChildToTrackMethodInfo
instance (signature ~ (b -> c -> m GES.TrackElement.TrackElement), MonadIO m, IsClip a, GES.TrackElement.IsTrackElement b, GES.Track.IsTrack c) => O.OverloadedMethod ClipAddChildToTrackMethodInfo a signature where
    overloadedMethod = clipAddChildToTrack

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


#endif

-- method Clip::add_top_effect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "BaseEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A top effect to add"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The index to add @effect at, or -1 to add at the highest,\n        see #ges_clip_get_top_effect_index for more information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ges_clip_add_top_effect" ges_clip_add_top_effect :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.BaseEffect.BaseEffect ->        -- effect : TInterface (Name {namespace = "GES", name = "BaseEffect"})
    Int32 ->                                -- index : TBasicType TInt
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Add a top effect to a clip at the given index.
-- 
-- Unlike using 'GI.GES.Objects.Container.containerAdd', this allows you to set the index
-- in advance. It will also check that no error occurred during the track
-- selection for the effect.
-- 
-- Note, only subclasses of t'GI.GES.Structs.ClipClass.ClipClass' that have
-- @/GES_CLIP_CLASS_CAN_ADD_EFFECTS/@ set to 'P.True' (such as t'GI.GES.Objects.SourceClip.SourceClip'
-- and t'GI.GES.Objects.BaseEffectClip.BaseEffectClip') can have additional top effects added.
-- 
-- Note, if the effect is a time effect, this may be refused if the clip
-- would not be able to adapt itself once the effect is added.
-- 
-- /Since: 1.18/
clipAddTopEffect ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> b
    -- ^ /@effect@/: A top effect to add
    -> Int32
    -- ^ /@index@/: The index to add /@effect@/ at, or -1 to add at the highest,
    --         see @/ges_clip_get_top_effect_index/@ for more information
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
clipAddTopEffect :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsBaseEffect b) =>
a -> b -> Int32 -> m ()
clipAddTopEffect a
clip b
effect Int32
index = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr BaseEffect
effect' <- b -> IO (Ptr BaseEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
effect
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Clip -> Ptr BaseEffect -> Int32 -> Ptr (Ptr GError) -> IO CInt
ges_clip_add_top_effect Ptr Clip
clip' Ptr BaseEffect
effect' Int32
index
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
effect
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ClipAddTopEffectMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) => O.OverloadedMethod ClipAddTopEffectMethodInfo a signature where
    overloadedMethod = clipAddTopEffect

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


#endif

-- method Clip::find_track_element
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "track"
--           , argType = TInterface Name { namespace = "GES" , name = "Track" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The track to search in, or %NULL to search in\nall tracks"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The type of track element to search for, or `G_TYPE_NONE` to\nmatch any type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GES" , name = "TrackElement" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_clip_find_track_element" ges_clip_find_track_element :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.Track.Track ->                  -- track : TInterface (Name {namespace = "GES", name = "Track"})
    CGType ->                               -- type : TBasicType TGType
    IO (Ptr GES.TrackElement.TrackElement)

-- | Finds an element controlled by the clip. If /@track@/ is given,
-- then only the track elements in /@track@/ are searched for. If /@type@/ is
-- given, then this function searches for a track element of the given
-- /@type@/.
-- 
-- Note, if multiple track elements in the clip match the given criteria,
-- this will return the element amongst them with the highest
-- [TimelineElement:priority]("GI.GES.Objects.TimelineElement#g:attr:priority") (numerically, the smallest). See
-- 'GI.GES.Objects.Clip.clipFindTrackElements' if you wish to find all such elements.
clipFindTrackElement ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.Track.IsTrack b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> Maybe (b)
    -- ^ /@track@/: The track to search in, or 'P.Nothing' to search in
    -- all tracks
    -> GType
    -- ^ /@type@/: The type of track element to search for, or @G_TYPE_NONE@ to
    -- match any type
    -> m (Maybe GES.TrackElement.TrackElement)
    -- ^ __Returns:__ The element controlled by
    -- /@clip@/, in /@track@/, and of the given /@type@/, or 'P.Nothing' if no such element
    -- could be found.
clipFindTrackElement :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsTrack b) =>
a -> Maybe b -> GType -> m (Maybe TrackElement)
clipFindTrackElement a
clip Maybe b
track GType
type_ = IO (Maybe TrackElement) -> m (Maybe TrackElement)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TrackElement) -> m (Maybe TrackElement))
-> IO (Maybe TrackElement) -> m (Maybe TrackElement)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr Track
maybeTrack <- case Maybe b
track of
        Maybe b
Nothing -> Ptr Track -> IO (Ptr Track)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Track
forall a. Ptr a
nullPtr
        Just b
jTrack -> do
            Ptr Track
jTrack' <- b -> IO (Ptr Track)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jTrack
            Ptr Track -> IO (Ptr Track)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Track
jTrack'
    let type_' :: Word64
type_' = GType -> Word64
gtypeToCGType GType
type_
    Ptr TrackElement
result <- Ptr Clip -> Ptr Track -> Word64 -> IO (Ptr TrackElement)
ges_clip_find_track_element Ptr Clip
clip' Ptr Track
maybeTrack Word64
type_'
    Maybe TrackElement
maybeResult <- Ptr TrackElement
-> (Ptr TrackElement -> IO TrackElement) -> IO (Maybe TrackElement)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TrackElement
result ((Ptr TrackElement -> IO TrackElement) -> IO (Maybe TrackElement))
-> (Ptr TrackElement -> IO TrackElement) -> IO (Maybe TrackElement)
forall a b. (a -> b) -> a -> b
$ \Ptr TrackElement
result' -> do
        TrackElement
result'' <- ((ManagedPtr TrackElement -> TrackElement)
-> Ptr TrackElement -> IO TrackElement
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TrackElement -> TrackElement
GES.TrackElement.TrackElement) Ptr TrackElement
result'
        TrackElement -> IO TrackElement
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TrackElement
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
track b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Maybe TrackElement -> IO (Maybe TrackElement)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TrackElement
maybeResult

#if defined(ENABLE_OVERLOADING)
data ClipFindTrackElementMethodInfo
instance (signature ~ (Maybe (b) -> GType -> m (Maybe GES.TrackElement.TrackElement)), MonadIO m, IsClip a, GES.Track.IsTrack b) => O.OverloadedMethod ClipFindTrackElementMethodInfo a signature where
    overloadedMethod = clipFindTrackElement

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


#endif

-- method Clip::find_track_elements
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "track"
--           , argType = TInterface Name { namespace = "GES" , name = "Track" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The track to search in, or %NULL to search in\nall tracks"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "track_type"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The track-type of the track element to search for, or\n#GES_TRACK_TYPE_UNKNOWN to match any track type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The type of track element to search for, or %G_TYPE_NONE to\nmatch any type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface Name { namespace = "GES" , name = "TrackElement" }))
-- throws : False
-- Skip return : False

foreign import ccall "ges_clip_find_track_elements" ges_clip_find_track_elements :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.Track.Track ->                  -- track : TInterface (Name {namespace = "GES", name = "Track"})
    CUInt ->                                -- track_type : TInterface (Name {namespace = "GES", name = "TrackType"})
    CGType ->                               -- type : TBasicType TGType
    IO (Ptr (GList (Ptr GES.TrackElement.TrackElement)))

-- | Finds the t'GI.GES.Objects.TrackElement.TrackElement'-s controlled by the clip that match the
-- given criteria. If /@track@/ is given as 'P.Nothing' and /@trackType@/ is given as
-- @/GES_TRACK_TYPE_UNKNOWN/@, then the search will match all elements in any
-- track, including those with no track, and of any
-- [TrackElement:trackType]("GI.GES.Objects.TrackElement#g:attr:trackType"). Otherwise, if /@track@/ is not 'P.Nothing', but
-- /@trackType@/ is @/GES_TRACK_TYPE_UNKNOWN/@, then only the track elements in
-- /@track@/ are searched for. Otherwise, if /@trackType@/ is not
-- @/GES_TRACK_TYPE_UNKNOWN/@, but /@track@/ is 'P.Nothing', then only the track
-- elements whose [TrackElement:trackType]("GI.GES.Objects.TrackElement#g:attr:trackType") matches /@trackType@/ are
-- searched for. Otherwise, when both are given, the track elements that
-- match **either** criteria are searched for. Therefore, if you wish to
-- only find elements in a specific track, you should give the track as
-- /@track@/, but you should not give the track\'s [Track:trackType]("GI.GES.Objects.Track#g:attr:trackType") as
-- /@trackType@/ because this would also select elements from other tracks
-- of the same type.
-- 
-- You may also give /@type@/ to _further_ restrict the search to track
-- elements of the given /@type@/.
clipFindTrackElements ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.Track.IsTrack b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> Maybe (b)
    -- ^ /@track@/: The track to search in, or 'P.Nothing' to search in
    -- all tracks
    -> [GES.Flags.TrackType]
    -- ^ /@trackType@/: The track-type of the track element to search for, or
    -- @/GES_TRACK_TYPE_UNKNOWN/@ to match any track type
    -> GType
    -- ^ /@type@/: The type of track element to search for, or @/G_TYPE_NONE/@ to
    -- match any type
    -> m [GES.TrackElement.TrackElement]
    -- ^ __Returns:__ A list of all
    -- the t'GI.GES.Objects.TrackElement.TrackElement'-s controlled by /@clip@/, in /@track@/ or of the given
    -- /@trackType@/, and of the given /@type@/.
clipFindTrackElements :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsTrack b) =>
a -> Maybe b -> [TrackType] -> GType -> m [TrackElement]
clipFindTrackElements a
clip Maybe b
track [TrackType]
trackType GType
type_ = IO [TrackElement] -> m [TrackElement]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TrackElement] -> m [TrackElement])
-> IO [TrackElement] -> m [TrackElement]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr Track
maybeTrack <- case Maybe b
track of
        Maybe b
Nothing -> Ptr Track -> IO (Ptr Track)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Track
forall a. Ptr a
nullPtr
        Just b
jTrack -> do
            Ptr Track
jTrack' <- b -> IO (Ptr Track)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jTrack
            Ptr Track -> IO (Ptr Track)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Track
jTrack'
    let trackType' :: CUInt
trackType' = [TrackType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TrackType]
trackType
    let type_' :: Word64
type_' = GType -> Word64
gtypeToCGType GType
type_
    Ptr (GList (Ptr TrackElement))
result <- Ptr Clip
-> Ptr Track
-> CUInt
-> Word64
-> IO (Ptr (GList (Ptr TrackElement)))
ges_clip_find_track_elements Ptr Clip
clip' Ptr Track
maybeTrack CUInt
trackType' Word64
type_'
    [Ptr TrackElement]
result' <- Ptr (GList (Ptr TrackElement)) -> IO [Ptr TrackElement]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr TrackElement))
result
    [TrackElement]
result'' <- (Ptr TrackElement -> IO TrackElement)
-> [Ptr TrackElement] -> IO [TrackElement]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr TrackElement -> TrackElement)
-> Ptr TrackElement -> IO TrackElement
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TrackElement -> TrackElement
GES.TrackElement.TrackElement) [Ptr TrackElement]
result'
    Ptr (GList (Ptr TrackElement)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr TrackElement))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
track b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    [TrackElement] -> IO [TrackElement]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [TrackElement]
result''

#if defined(ENABLE_OVERLOADING)
data ClipFindTrackElementsMethodInfo
instance (signature ~ (Maybe (b) -> [GES.Flags.TrackType] -> GType -> m [GES.TrackElement.TrackElement]), MonadIO m, IsClip a, GES.Track.IsTrack b) => O.OverloadedMethod ClipFindTrackElementsMethodInfo a signature where
    overloadedMethod = clipFindTrackElements

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


#endif

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

foreign import ccall "ges_clip_get_duration_limit" ges_clip_get_duration_limit :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    IO Word64

-- | Gets the [Clip:durationLimit]("GI.GES.Objects.Clip#g:attr:durationLimit") of the clip.
-- 
-- /Since: 1.18/
clipGetDurationLimit ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> m Word64
    -- ^ __Returns:__ The duration-limit of /@clip@/.
clipGetDurationLimit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClip a) =>
a -> m Word64
clipGetDurationLimit a
clip = IO Word64 -> m Word64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Word64
result <- Ptr Clip -> IO Word64
ges_clip_get_duration_limit Ptr Clip
clip'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    Word64 -> IO Word64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data ClipGetDurationLimitMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsClip a) => O.OverloadedMethod ClipGetDurationLimitMethodInfo a signature where
    overloadedMethod = clipGetDurationLimit

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


#endif

-- method Clip::get_internal_time_from_timeline_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "An #GESTrackElement:active child of @clip with a\n#GESTrackElement:track"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timeline_time"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A time in the timeline time coordinates"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt64)
-- throws : True
-- Skip return : False

foreign import ccall "ges_clip_get_internal_time_from_timeline_time" ges_clip_get_internal_time_from_timeline_time :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.TrackElement.TrackElement ->    -- child : TInterface (Name {namespace = "GES", name = "TrackElement"})
    Word64 ->                               -- timeline_time : TBasicType TUInt64
    Ptr (Ptr GError) ->                     -- error
    IO Word64

-- | Convert the timeline time to an internal source time of the child.
-- This will take any time effects placed on the clip into account (see
-- t'GI.GES.Objects.BaseEffect.BaseEffect' for what time effects are supported, and how to
-- declare them in GES).
-- 
-- When /@timelineTime@/ is above the [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") of /@clip@/,
-- this will return the internal time at which the content that appears at
-- /@timelineTime@/ in the output of the timeline is created in /@child@/. For
-- example, if /@timelineTime@/ corresponds to the current seek position,
-- this would let you know which part of a media file is being read.
-- 
-- This will be done assuming the clip has an indefinite end, so the
-- internal time may be beyond the current out-point of the child, or even
-- its [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration").
-- 
-- If, instead, /@timelineTime@/ is below the current
-- [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") of /@clip@/, this will return what you would
-- need to set the [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") of /@child@/ to if you set
-- the [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") of /@clip@/ to /@timelineTime@/ and wanted
-- to keep the content of /@child@/ currently found at the current
-- [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") of /@clip@/ at the same timeline position. If
-- this would be negative, the conversion fails. This is useful for
-- determining what [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") would result from a
-- @/GES_EDIT_MODE_TRIM/@ to /@timelineTime@/.
-- 
-- Note that whilst a clip has no time effects, this second return is
-- equivalent to finding the internal time at which the content that
-- appears at /@timelineTime@/ in the timeline can be found in /@child@/ if it
-- had indefinite extent in both directions. However, with non-linear time
-- effects this second return will be more distinct.
-- 
-- In either case, the returned time would be appropriate to use for the
-- [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") or [TimelineElement:maxDuration]("GI.GES.Objects.TimelineElement#g:attr:maxDuration") of the
-- child.
-- 
-- See 'GI.GES.Objects.Clip.clipGetTimelineTimeFromInternalTime', which performs the
-- reverse.
-- 
-- /Since: 1.18/
clipGetInternalTimeFromTimelineTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.TrackElement.IsTrackElement b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> b
    -- ^ /@child@/: An [TrackElement:active]("GI.GES.Objects.TrackElement#g:attr:active") child of /@clip@/ with a
    -- [TrackElement:track]("GI.GES.Objects.TrackElement#g:attr:track")
    -> Word64
    -- ^ /@timelineTime@/: A time in the timeline time coordinates
    -> m Word64
    -- ^ __Returns:__ The time in the internal coordinates of /@child@/ corresponding
    -- to /@timelineTime@/, or 'GI.Gst.Constants.CLOCK_TIME_NONE' if the conversion could not
    -- be performed. /(Can throw 'Data.GI.Base.GError.GError')/
clipGetInternalTimeFromTimelineTime :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsTrackElement b) =>
a -> b -> Word64 -> m Word64
clipGetInternalTimeFromTimelineTime a
clip b
child Word64
timelineTime = IO Word64 -> m Word64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr TrackElement
child' <- b -> IO (Ptr TrackElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    IO Word64 -> IO () -> IO Word64
forall a b. IO a -> IO b -> IO a
onException (do
        Word64
result <- (Ptr (Ptr GError) -> IO Word64) -> IO Word64
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO Word64) -> IO Word64)
-> (Ptr (Ptr GError) -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ Ptr Clip
-> Ptr TrackElement -> Word64 -> Ptr (Ptr GError) -> IO Word64
ges_clip_get_internal_time_from_timeline_time Ptr Clip
clip' Ptr TrackElement
child' Word64
timelineTime
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
        Word64 -> IO Word64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ClipGetInternalTimeFromTimelineTimeMethodInfo
instance (signature ~ (b -> Word64 -> m Word64), MonadIO m, IsClip a, GES.TrackElement.IsTrackElement b) => O.OverloadedMethod ClipGetInternalTimeFromTimelineTimeMethodInfo a signature where
    overloadedMethod = clipGetInternalTimeFromTimelineTime

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


#endif

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

foreign import ccall "ges_clip_get_layer" ges_clip_get_layer :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    IO (Ptr GES.Layer.Layer)

-- | Gets the [Clip:layer]("GI.GES.Objects.Clip#g:attr:layer") of the clip.
clipGetLayer ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> m (Maybe GES.Layer.Layer)
    -- ^ __Returns:__ The layer /@clip@/ is in, or 'P.Nothing' if
    -- /@clip@/ is not in any layer.
clipGetLayer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClip a) =>
a -> m (Maybe Layer)
clipGetLayer a
clip = IO (Maybe Layer) -> m (Maybe Layer)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Layer) -> m (Maybe Layer))
-> IO (Maybe Layer) -> m (Maybe Layer)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr Layer
result <- Ptr Clip -> IO (Ptr Layer)
ges_clip_get_layer Ptr Clip
clip'
    Maybe Layer
maybeResult <- Ptr Layer -> (Ptr Layer -> IO Layer) -> IO (Maybe Layer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Layer
result ((Ptr Layer -> IO Layer) -> IO (Maybe Layer))
-> (Ptr Layer -> IO Layer) -> IO (Maybe Layer)
forall a b. (a -> b) -> a -> b
$ \Ptr Layer
result' -> do
        Layer
result'' <- ((ManagedPtr Layer -> Layer) -> Ptr Layer -> IO Layer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Layer -> Layer
GES.Layer.Layer) Ptr Layer
result'
        Layer -> IO Layer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Layer
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    Maybe Layer -> IO (Maybe Layer)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Layer
maybeResult

#if defined(ENABLE_OVERLOADING)
data ClipGetLayerMethodInfo
instance (signature ~ (m (Maybe GES.Layer.Layer)), MonadIO m, IsClip a) => O.OverloadedMethod ClipGetLayerMethodInfo a signature where
    overloadedMethod = clipGetLayer

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


#endif

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

foreign import ccall "ges_clip_get_supported_formats" ges_clip_get_supported_formats :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    IO CUInt

-- | Gets the [Clip:supportedFormats]("GI.GES.Objects.Clip#g:attr:supportedFormats") of the clip.
clipGetSupportedFormats ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> m [GES.Flags.TrackType]
    -- ^ __Returns:__ The t'GI.GES.Flags.TrackType'-s supported by /@clip@/.
clipGetSupportedFormats :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClip a) =>
a -> m [TrackType]
clipGetSupportedFormats a
clip = IO [TrackType] -> m [TrackType]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TrackType] -> m [TrackType])
-> IO [TrackType] -> m [TrackType]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    CUInt
result <- Ptr Clip -> IO CUInt
ges_clip_get_supported_formats Ptr Clip
clip'
    let result' :: [TrackType]
result' = CUInt -> [TrackType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    [TrackType] -> IO [TrackType]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [TrackType]
result'

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

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


#endif

-- method Clip::get_timeline_time_from_internal_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackElement" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "An #GESTrackElement:active child of @clip with a\n#GESTrackElement:track"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "internal_time"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A time in the internal time coordinates of @child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt64)
-- throws : True
-- Skip return : False

foreign import ccall "ges_clip_get_timeline_time_from_internal_time" ges_clip_get_timeline_time_from_internal_time :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.TrackElement.TrackElement ->    -- child : TInterface (Name {namespace = "GES", name = "TrackElement"})
    Word64 ->                               -- internal_time : TBasicType TUInt64
    Ptr (Ptr GError) ->                     -- error
    IO Word64

-- | Convert the internal source time from the child to a timeline time.
-- This will take any time effects placed on the clip into account (see
-- t'GI.GES.Objects.BaseEffect.BaseEffect' for what time effects are supported, and how to
-- declare them in GES).
-- 
-- When /@internalTime@/ is above the [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") of
-- /@child@/, this will return the timeline time at which the internal
-- content found at /@internalTime@/ appears in the output of the timeline\'s
-- track. For example, this would let you know where in the timeline a
-- particular scene in a media file would appear.
-- 
-- This will be done assuming the clip has an indefinite end, so the
-- timeline time may be beyond the end of the clip, or even breaking its
-- [Clip:durationLimit]("GI.GES.Objects.Clip#g:attr:durationLimit").
-- 
-- If, instead, /@internalTime@/ is below the current
-- [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") of /@child@/, this will return what you would
-- need to set the [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") of /@clip@/ to if you set the
-- [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") of /@child@/ to /@internalTime@/ and wanted to
-- keep the content of /@child@/ currently found at the current
-- [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") of /@clip@/ at the same timeline position. If
-- this would be negative, the conversion fails. This is useful for
-- determining what position to use in a @/GES_EDIT_MODE_TRIM/@ if you wish
-- to trim to a specific point in the internal content, such as a
-- particular scene in a media file.
-- 
-- Note that whilst a clip has no time effects, this second return is
-- equivalent to finding the timeline time at which the content of /@child@/
-- at /@internalTime@/ would be found in the timeline if it had indefinite
-- extent in both directions. However, with non-linear time effects this
-- second return will be more distinct.
-- 
-- In either case, the returned time would be appropriate to use in
-- 'GI.GES.Objects.TimelineElement.timelineElementEdit' for @/GES_EDIT_MODE_TRIM/@, and similar, if
-- you wish to use a particular internal point as a reference. For
-- example, you could choose to end a clip at a certain internal
-- \'out-point\', similar to the [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint"), by
-- translating the desired end time into the timeline coordinates, and
-- using this position to trim the end of a clip.
-- 
-- See 'GI.GES.Objects.Clip.clipGetInternalTimeFromTimelineTime', which performs the
-- reverse, or 'GI.GES.Objects.Clip.clipGetTimelineTimeFromSourceFrame' which does
-- the same conversion, but using frame numbers.
-- 
-- /Since: 1.18/
clipGetTimelineTimeFromInternalTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.TrackElement.IsTrackElement b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> b
    -- ^ /@child@/: An [TrackElement:active]("GI.GES.Objects.TrackElement#g:attr:active") child of /@clip@/ with a
    -- [TrackElement:track]("GI.GES.Objects.TrackElement#g:attr:track")
    -> Word64
    -- ^ /@internalTime@/: A time in the internal time coordinates of /@child@/
    -> m Word64
    -- ^ __Returns:__ The time in the timeline coordinates corresponding to
    -- /@internalTime@/, or 'GI.Gst.Constants.CLOCK_TIME_NONE' if the conversion could not be
    -- performed. /(Can throw 'Data.GI.Base.GError.GError')/
clipGetTimelineTimeFromInternalTime :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsTrackElement b) =>
a -> b -> Word64 -> m Word64
clipGetTimelineTimeFromInternalTime a
clip b
child Word64
internalTime = IO Word64 -> m Word64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr TrackElement
child' <- b -> IO (Ptr TrackElement)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    IO Word64 -> IO () -> IO Word64
forall a b. IO a -> IO b -> IO a
onException (do
        Word64
result <- (Ptr (Ptr GError) -> IO Word64) -> IO Word64
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO Word64) -> IO Word64)
-> (Ptr (Ptr GError) -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ Ptr Clip
-> Ptr TrackElement -> Word64 -> Ptr (Ptr GError) -> IO Word64
ges_clip_get_timeline_time_from_internal_time Ptr Clip
clip' Ptr TrackElement
child' Word64
internalTime
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
        Word64 -> IO Word64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ClipGetTimelineTimeFromInternalTimeMethodInfo
instance (signature ~ (b -> Word64 -> m Word64), MonadIO m, IsClip a, GES.TrackElement.IsTrackElement b) => O.OverloadedMethod ClipGetTimelineTimeFromInternalTimeMethodInfo a signature where
    overloadedMethod = clipGetTimelineTimeFromInternalTime

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


#endif

-- method Clip::get_timeline_time_from_source_frame
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "frame_number"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The frame number to get the corresponding timestamp of\nin the timeline coordinates"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt64)
-- throws : True
-- Skip return : False

foreign import ccall "ges_clip_get_timeline_time_from_source_frame" ges_clip_get_timeline_time_from_source_frame :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Int64 ->                                -- frame_number : TBasicType TInt64
    Ptr (Ptr GError) ->                     -- error
    IO Word64

-- | Convert the source frame number to a timeline time. This acts the same
-- as 'GI.GES.Objects.Clip.clipGetTimelineTimeFromInternalTime' using the core
-- children of the clip and using the frame number to specify the internal
-- position, rather than a timestamp.
-- 
-- The returned timeline time can be used to seek or edit to a specific
-- frame.
-- 
-- Note that you can get the frame timestamp of a particular clip asset
-- with 'GI.GES.Objects.ClipAsset.clipAssetGetFrameTime'.
-- 
-- /Since: 1.18/
clipGetTimelineTimeFromSourceFrame ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> Int64
    -- ^ /@frameNumber@/: The frame number to get the corresponding timestamp of
    -- in the timeline coordinates
    -> m Word64
    -- ^ __Returns:__ The timestamp corresponding to /@frameNumber@/ in the core
    -- children of /@clip@/, in the timeline coordinates, or 'GI.Gst.Constants.CLOCK_TIME_NONE'
    -- if the conversion could not be performed. /(Can throw 'Data.GI.Base.GError.GError')/
clipGetTimelineTimeFromSourceFrame :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClip a) =>
a -> Int64 -> m Word64
clipGetTimelineTimeFromSourceFrame a
clip Int64
frameNumber = IO Word64 -> m Word64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    IO Word64 -> IO () -> IO Word64
forall a b. IO a -> IO b -> IO a
onException (do
        Word64
result <- (Ptr (Ptr GError) -> IO Word64) -> IO Word64
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO Word64) -> IO Word64)
-> (Ptr (Ptr GError) -> IO Word64) -> IO Word64
forall a b. (a -> b) -> a -> b
$ Ptr Clip -> Int64 -> Ptr (Ptr GError) -> IO Word64
ges_clip_get_timeline_time_from_source_frame Ptr Clip
clip' Int64
frameNumber
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
        Word64 -> IO Word64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ClipGetTimelineTimeFromSourceFrameMethodInfo
instance (signature ~ (Int64 -> m Word64), MonadIO m, IsClip a) => O.OverloadedMethod ClipGetTimelineTimeFromSourceFrameMethodInfo a signature where
    overloadedMethod = clipGetTimelineTimeFromSourceFrame

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


#endif

-- method Clip::get_top_effect_index
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "BaseEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The effect we want to get the index of"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "ges_clip_get_top_effect_index" ges_clip_get_top_effect_index :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.BaseEffect.BaseEffect ->        -- effect : TInterface (Name {namespace = "GES", name = "BaseEffect"})
    IO Int32

-- | Gets the internal index of an effect in the clip. The index of effects
-- in a clip will run from 0 to n-1, where n is the total number of
-- effects. If two effects share the same [TrackElement:track]("GI.GES.Objects.TrackElement#g:attr:track"), the
-- effect with the numerically lower index will be applied to the source
-- data **after** the other effect, i.e. output data will always flow from
-- a higher index effect to a lower index effect.
clipGetTopEffectIndex ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> b
    -- ^ /@effect@/: The effect we want to get the index of
    -> m Int32
    -- ^ __Returns:__ The index of /@effect@/ in /@clip@/, or -1 if something went wrong.
clipGetTopEffectIndex :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsBaseEffect b) =>
a -> b -> m Int32
clipGetTopEffectIndex a
clip b
effect = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr BaseEffect
effect' <- b -> IO (Ptr BaseEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
effect
    Int32
result <- Ptr Clip -> Ptr BaseEffect -> IO Int32
ges_clip_get_top_effect_index Ptr Clip
clip' Ptr BaseEffect
effect'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
effect
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ClipGetTopEffectIndexMethodInfo
instance (signature ~ (b -> m Int32), MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) => O.OverloadedMethod ClipGetTopEffectIndexMethodInfo a signature where
    overloadedMethod = clipGetTopEffectIndex

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


#endif

-- method Clip::get_top_effect_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "BaseEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "ges_clip_get_top_effect_position" ges_clip_get_top_effect_position :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.BaseEffect.BaseEffect ->        -- effect : TInterface (Name {namespace = "GES", name = "BaseEffect"})
    IO Int32

-- | /No description available in the introspection data./
clipGetTopEffectPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) =>
    a
    -> b
    -> m Int32
clipGetTopEffectPosition :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsBaseEffect b) =>
a -> b -> m Int32
clipGetTopEffectPosition a
clip b
effect = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr BaseEffect
effect' <- b -> IO (Ptr BaseEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
effect
    Int32
result <- Ptr Clip -> Ptr BaseEffect -> IO Int32
ges_clip_get_top_effect_position Ptr Clip
clip' Ptr BaseEffect
effect'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
effect
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ClipGetTopEffectPositionMethodInfo
instance (signature ~ (b -> m Int32), MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) => O.OverloadedMethod ClipGetTopEffectPositionMethodInfo a signature where
    overloadedMethod = clipGetTopEffectPosition

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


#endif

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

foreign import ccall "ges_clip_get_top_effects" ges_clip_get_top_effects :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    IO (Ptr (GList (Ptr GES.TrackElement.TrackElement)))

-- | Gets the t'GI.GES.Objects.BaseEffect.BaseEffect'-s that have been added to the clip. The
-- returned list is ordered by their internal index in the clip. See
-- 'GI.GES.Objects.Clip.clipGetTopEffectIndex'.
clipGetTopEffects ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> m [GES.TrackElement.TrackElement]
    -- ^ __Returns:__ A list of all
    -- t'GI.GES.Objects.BaseEffect.BaseEffect'-s that have been added to /@clip@/.
clipGetTopEffects :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClip a) =>
a -> m [TrackElement]
clipGetTopEffects a
clip = IO [TrackElement] -> m [TrackElement]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TrackElement] -> m [TrackElement])
-> IO [TrackElement] -> m [TrackElement]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr (GList (Ptr TrackElement))
result <- Ptr Clip -> IO (Ptr (GList (Ptr TrackElement)))
ges_clip_get_top_effects Ptr Clip
clip'
    [Ptr TrackElement]
result' <- Ptr (GList (Ptr TrackElement)) -> IO [Ptr TrackElement]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr TrackElement))
result
    [TrackElement]
result'' <- (Ptr TrackElement -> IO TrackElement)
-> [Ptr TrackElement] -> IO [TrackElement]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr TrackElement -> TrackElement)
-> Ptr TrackElement -> IO TrackElement
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TrackElement -> TrackElement
GES.TrackElement.TrackElement) [Ptr TrackElement]
result'
    Ptr (GList (Ptr TrackElement)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr TrackElement))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    [TrackElement] -> IO [TrackElement]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [TrackElement]
result''

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

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


#endif

-- method Clip::move_to_layer
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "layer"
--           , argType = TInterface Name { namespace = "GES" , name = "Layer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new layer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_clip_move_to_layer" ges_clip_move_to_layer :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.Layer.Layer ->                  -- layer : TInterface (Name {namespace = "GES", name = "Layer"})
    IO CInt

-- | See 'GI.GES.Objects.Clip.clipMoveToLayerFull', which also gives an error.
clipMoveToLayer ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.Layer.IsLayer b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> b
    -- ^ /@layer@/: The new layer
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@clip@/ was successfully moved to /@layer@/.
clipMoveToLayer :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsLayer b) =>
a -> b -> m Bool
clipMoveToLayer a
clip b
layer = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr Layer
layer' <- b -> IO (Ptr Layer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
layer
    CInt
result <- Ptr Clip -> Ptr Layer -> IO CInt
ges_clip_move_to_layer Ptr Clip
clip' Ptr Layer
layer'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
layer
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ClipMoveToLayerMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsClip a, GES.Layer.IsLayer b) => O.OverloadedMethod ClipMoveToLayerMethodInfo a signature where
    overloadedMethod = clipMoveToLayer

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


#endif

-- method Clip::move_to_layer_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "layer"
--           , argType = TInterface Name { namespace = "GES" , name = "Layer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The new layer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ges_clip_move_to_layer_full" ges_clip_move_to_layer_full :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.Layer.Layer ->                  -- layer : TInterface (Name {namespace = "GES", name = "Layer"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Moves a clip to a new layer. If the clip already exists in a layer, it
-- is first removed from its current layer before being added to the new
-- layer.
-- 
-- /Since: 1.18/
clipMoveToLayerFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.Layer.IsLayer b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> b
    -- ^ /@layer@/: The new layer
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
clipMoveToLayerFull :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsLayer b) =>
a -> b -> m ()
clipMoveToLayerFull a
clip b
layer = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr Layer
layer' <- b -> IO (Ptr Layer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
layer
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Clip -> Ptr Layer -> Ptr (Ptr GError) -> IO CInt
ges_clip_move_to_layer_full Ptr Clip
clip' Ptr Layer
layer'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
layer
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ClipMoveToLayerFullMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsClip a, GES.Layer.IsLayer b) => O.OverloadedMethod ClipMoveToLayerFullMethodInfo a signature where
    overloadedMethod = clipMoveToLayerFull

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


#endif

-- method Clip::remove_top_effect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "BaseEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The top effect to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ges_clip_remove_top_effect" ges_clip_remove_top_effect :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.BaseEffect.BaseEffect ->        -- effect : TInterface (Name {namespace = "GES", name = "BaseEffect"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Remove a top effect from the clip.
-- 
-- Note, if the effect is a time effect, this may be refused if the clip
-- would not be able to adapt itself once the effect is removed.
-- 
-- /Since: 1.18/
clipRemoveTopEffect ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> b
    -- ^ /@effect@/: The top effect to remove
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
clipRemoveTopEffect :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsBaseEffect b) =>
a -> b -> m ()
clipRemoveTopEffect a
clip b
effect = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr BaseEffect
effect' <- b -> IO (Ptr BaseEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
effect
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Clip -> Ptr BaseEffect -> Ptr (Ptr GError) -> IO CInt
ges_clip_remove_top_effect Ptr Clip
clip' Ptr BaseEffect
effect'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
effect
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ClipRemoveTopEffectMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) => O.OverloadedMethod ClipRemoveTopEffectMethodInfo a signature where
    overloadedMethod = clipRemoveTopEffect

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


#endif

-- method Clip::set_supported_formats
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "supportedformats"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TrackType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESTrackType-s supported by @clip"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_clip_set_supported_formats" ges_clip_set_supported_formats :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    CUInt ->                                -- supportedformats : TInterface (Name {namespace = "GES", name = "TrackType"})
    IO ()

-- | Sets the [Clip:supportedFormats]("GI.GES.Objects.Clip#g:attr:supportedFormats") of the clip. This should normally
-- only be called by subclasses, which should be responsible for updating
-- its value, rather than the user.
clipSetSupportedFormats ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> [GES.Flags.TrackType]
    -- ^ /@supportedformats@/: The t'GI.GES.Flags.TrackType'-s supported by /@clip@/
    -> m ()
clipSetSupportedFormats :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClip a) =>
a -> [TrackType] -> m ()
clipSetSupportedFormats a
clip [TrackType]
supportedformats = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    let supportedformats' :: CUInt
supportedformats' = [TrackType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TrackType]
supportedformats
    Ptr Clip -> CUInt -> IO ()
ges_clip_set_supported_formats Ptr Clip
clip' CUInt
supportedformats'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Clip::set_top_effect_index
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "BaseEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An effect within @clip to move"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "newindex"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The index for @effect in @clip"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_clip_set_top_effect_index" ges_clip_set_top_effect_index :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.BaseEffect.BaseEffect ->        -- effect : TInterface (Name {namespace = "GES", name = "BaseEffect"})
    Word32 ->                               -- newindex : TBasicType TUInt
    IO CInt

-- | See 'GI.GES.Objects.Clip.clipSetTopEffectIndexFull', which also gives an error.
clipSetTopEffectIndex ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> b
    -- ^ /@effect@/: An effect within /@clip@/ to move
    -> Word32
    -- ^ /@newindex@/: The index for /@effect@/ in /@clip@/
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@effect@/ was successfully moved to /@newindex@/.
clipSetTopEffectIndex :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsBaseEffect b) =>
a -> b -> Word32 -> m Bool
clipSetTopEffectIndex a
clip b
effect Word32
newindex = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr BaseEffect
effect' <- b -> IO (Ptr BaseEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
effect
    CInt
result <- Ptr Clip -> Ptr BaseEffect -> Word32 -> IO CInt
ges_clip_set_top_effect_index Ptr Clip
clip' Ptr BaseEffect
effect' Word32
newindex
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
effect
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ClipSetTopEffectIndexMethodInfo
instance (signature ~ (b -> Word32 -> m Bool), MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) => O.OverloadedMethod ClipSetTopEffectIndexMethodInfo a signature where
    overloadedMethod = clipSetTopEffectIndex

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


#endif

-- method Clip::set_top_effect_index_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "BaseEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An effect within @clip to move"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "newindex"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The index for @effect in @clip"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ges_clip_set_top_effect_index_full" ges_clip_set_top_effect_index_full :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.BaseEffect.BaseEffect ->        -- effect : TInterface (Name {namespace = "GES", name = "BaseEffect"})
    Word32 ->                               -- newindex : TBasicType TUInt
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Set the index of an effect within the clip. See
-- 'GI.GES.Objects.Clip.clipGetTopEffectIndex'. The new index must be an existing
-- index of the clip. The effect is moved to the new index, and the other
-- effects may be shifted in index accordingly to otherwise maintain the
-- ordering.
-- 
-- /Since: 1.18/
clipSetTopEffectIndexFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) =>
    a
    -- ^ /@clip@/: A t'GI.GES.Objects.Clip.Clip'
    -> b
    -- ^ /@effect@/: An effect within /@clip@/ to move
    -> Word32
    -- ^ /@newindex@/: The index for /@effect@/ in /@clip@/
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
clipSetTopEffectIndexFull :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsBaseEffect b) =>
a -> b -> Word32 -> m ()
clipSetTopEffectIndexFull a
clip b
effect Word32
newindex = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr BaseEffect
effect' <- b -> IO (Ptr BaseEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
effect
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Clip -> Ptr BaseEffect -> Word32 -> Ptr (Ptr GError) -> IO CInt
ges_clip_set_top_effect_index_full Ptr Clip
clip' Ptr BaseEffect
effect' Word32
newindex
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
effect
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ClipSetTopEffectIndexFullMethodInfo
instance (signature ~ (b -> Word32 -> m ()), MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) => O.OverloadedMethod ClipSetTopEffectIndexFullMethodInfo a signature where
    overloadedMethod = clipSetTopEffectIndexFull

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


#endif

-- method Clip::set_top_effect_priority
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "effect"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "BaseEffect" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "newpriority"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_clip_set_top_effect_priority" ges_clip_set_top_effect_priority :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Ptr GES.BaseEffect.BaseEffect ->        -- effect : TInterface (Name {namespace = "GES", name = "BaseEffect"})
    Word32 ->                               -- newpriority : TBasicType TUInt
    IO CInt

-- | /No description available in the introspection data./
clipSetTopEffectPriority ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) =>
    a
    -> b
    -> Word32
    -> m Bool
clipSetTopEffectPriority :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsClip a, IsBaseEffect b) =>
a -> b -> Word32 -> m Bool
clipSetTopEffectPriority a
clip b
effect Word32
newpriority = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr BaseEffect
effect' <- b -> IO (Ptr BaseEffect)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
effect
    CInt
result <- Ptr Clip -> Ptr BaseEffect -> Word32 -> IO CInt
ges_clip_set_top_effect_priority Ptr Clip
clip' Ptr BaseEffect
effect' Word32
newpriority
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
effect
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ClipSetTopEffectPriorityMethodInfo
instance (signature ~ (b -> Word32 -> m Bool), MonadIO m, IsClip a, GES.BaseEffect.IsBaseEffect b) => O.OverloadedMethod ClipSetTopEffectPriorityMethodInfo a signature where
    overloadedMethod = clipSetTopEffectPriority

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


#endif

-- method Clip::split
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESClip to split"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The timeline position at which to perform the split"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GES" , name = "Clip" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_clip_split" ges_clip_split :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Word64 ->                               -- position : TBasicType TUInt64
    IO (Ptr Clip)

-- | See 'GI.GES.Objects.Clip.clipSplitFull', which also gives an error.
clipSplit ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a) =>
    a
    -- ^ /@clip@/: The t'GI.GES.Objects.Clip.Clip' to split
    -> Word64
    -- ^ /@position@/: The timeline position at which to perform the split
    -> m (Maybe Clip)
    -- ^ __Returns:__ The newly created clip resulting
    -- from the splitting /@clip@/, or 'P.Nothing' if /@clip@/ can\'t be split.
clipSplit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClip a) =>
a -> Word64 -> m (Maybe Clip)
clipSplit a
clip Word64
position = IO (Maybe Clip) -> m (Maybe Clip)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Clip) -> m (Maybe Clip))
-> IO (Maybe Clip) -> m (Maybe Clip)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    Ptr Clip
result <- Ptr Clip -> Word64 -> IO (Ptr Clip)
ges_clip_split Ptr Clip
clip' Word64
position
    Maybe Clip
maybeResult <- Ptr Clip -> (Ptr Clip -> IO Clip) -> IO (Maybe Clip)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Clip
result ((Ptr Clip -> IO Clip) -> IO (Maybe Clip))
-> (Ptr Clip -> IO Clip) -> IO (Maybe Clip)
forall a b. (a -> b) -> a -> b
$ \Ptr Clip
result' -> do
        Clip
result'' <- ((ManagedPtr Clip -> Clip) -> Ptr Clip -> IO Clip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Clip -> Clip
Clip) Ptr Clip
result'
        Clip -> IO Clip
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Clip
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
    Maybe Clip -> IO (Maybe Clip)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Clip
maybeResult

#if defined(ENABLE_OVERLOADING)
data ClipSplitMethodInfo
instance (signature ~ (Word64 -> m (Maybe Clip)), MonadIO m, IsClip a) => O.OverloadedMethod ClipSplitMethodInfo a signature where
    overloadedMethod = clipSplit

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


#endif

-- method Clip::split_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "clip"
--           , argType = TInterface Name { namespace = "GES" , name = "Clip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESClip to split"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The timeline position at which to perform the split, between\nthe start and end of the clip"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GES" , name = "Clip" })
-- throws : True
-- Skip return : False

foreign import ccall "ges_clip_split_full" ges_clip_split_full :: 
    Ptr Clip ->                             -- clip : TInterface (Name {namespace = "GES", name = "Clip"})
    Word64 ->                               -- position : TBasicType TUInt64
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Clip)

-- | Splits a clip at the given timeline position into two clips. The clip
-- must already have a [Clip:layer]("GI.GES.Objects.Clip#g:attr:layer").
-- 
-- The original clip\'s [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") is reduced such that
-- its end point matches the split position. Then a new clip is created in
-- the same layer, whose [TimelineElement:start]("GI.GES.Objects.TimelineElement#g:attr:start") matches the split
-- position and [TimelineElement:duration]("GI.GES.Objects.TimelineElement#g:attr:duration") will be set such that its end
-- point matches the old end point of the original clip. Thus, the two
-- clips together will occupy the same positions in the timeline as the
-- original clip did.
-- 
-- The children of the new clip will be new copies of the original clip\'s
-- children, so it will share the same sources and use the same
-- operations.
-- 
-- The new clip will also have its [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint") set so
-- that any internal data will appear in the timeline at the same time.
-- Thus, when the timeline is played, the playback of data should
-- appear the same. This may be complicated by any additional
-- t'GI.GES.Objects.Effect.Effect'-s that have been placed on the original clip that depend on
-- the playback time or change the data consumption rate of sources. This
-- method will attempt to translate these effects such that the playback
-- appears the same. In such complex situations, you may get a better
-- result if you place the clip in a separate sub t'GI.GES.Objects.Project.Project', which only
-- contains this clip (and its effects), and in the original layer
-- create two neighbouring t'GI.GES.Objects.UriClip.UriClip'-s that reference this sub-project,
-- but at a different [TimelineElement:inPoint]("GI.GES.Objects.TimelineElement#g:attr:inPoint").
-- 
-- /Since: 1.18/
clipSplitFull ::
    (B.CallStack.HasCallStack, MonadIO m, IsClip a) =>
    a
    -- ^ /@clip@/: The t'GI.GES.Objects.Clip.Clip' to split
    -> Word64
    -- ^ /@position@/: The timeline position at which to perform the split, between
    -- the start and end of the clip
    -> m (Maybe Clip)
    -- ^ __Returns:__ The newly created clip resulting
    -- from the splitting /@clip@/, or 'P.Nothing' if /@clip@/ can\'t be split. /(Can throw 'Data.GI.Base.GError.GError')/
clipSplitFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsClip a) =>
a -> Word64 -> m (Maybe Clip)
clipSplitFull a
clip Word64
position = IO (Maybe Clip) -> m (Maybe Clip)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Clip) -> m (Maybe Clip))
-> IO (Maybe Clip) -> m (Maybe Clip)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Clip
clip' <- a -> IO (Ptr Clip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
clip
    IO (Maybe Clip) -> IO () -> IO (Maybe Clip)
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Clip
result <- (Ptr (Ptr GError) -> IO (Ptr Clip)) -> IO (Ptr Clip)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Clip)) -> IO (Ptr Clip))
-> (Ptr (Ptr GError) -> IO (Ptr Clip)) -> IO (Ptr Clip)
forall a b. (a -> b) -> a -> b
$ Ptr Clip -> Word64 -> Ptr (Ptr GError) -> IO (Ptr Clip)
ges_clip_split_full Ptr Clip
clip' Word64
position
        Maybe Clip
maybeResult <- Ptr Clip -> (Ptr Clip -> IO Clip) -> IO (Maybe Clip)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Clip
result ((Ptr Clip -> IO Clip) -> IO (Maybe Clip))
-> (Ptr Clip -> IO Clip) -> IO (Maybe Clip)
forall a b. (a -> b) -> a -> b
$ \Ptr Clip
result' -> do
            Clip
result'' <- ((ManagedPtr Clip -> Clip) -> Ptr Clip -> IO Clip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Clip -> Clip
Clip) Ptr Clip
result'
            Clip -> IO Clip
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Clip
result''
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
clip
        Maybe Clip -> IO (Maybe Clip)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Clip
maybeResult
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ClipSplitFullMethodInfo
instance (signature ~ (Word64 -> m (Maybe Clip)), MonadIO m, IsClip a) => O.OverloadedMethod ClipSplitFullMethodInfo a signature where
    overloadedMethod = clipSplitFull

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


#endif