{-# 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_source (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_source (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.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import qualified GHC.Records as R import {-# SOURCE #-} qualified GI.GES.Flags as GES.Flags import {-# SOURCE #-} qualified GI.GES.Interfaces.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 -- | Memory-managed wrapper type. newtype Clip = Clip (SP.ManagedPtr Clip) deriving (Clip -> Clip -> Bool forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a /= :: Clip -> Clip -> Bool $c/= :: Clip -> Clip -> Bool == :: Clip -> Clip -> Bool $c== :: 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c . forall o o'. (HasCallStack, ManagedPtrNewtype o, TypedObject o, ManagedPtrNewtype o', TypedObject o') => (ManagedPtr o' -> o') -> o -> IO o' B.ManagedPtr.unsafeCastTo ManagedPtr 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 = forall a. GObject a => Ptr GValue -> Ptr a -> IO () B.GValue.set_object Ptr GValue gv (forall a. Ptr a FP.nullPtr :: FP.Ptr Clip) gvalueSet_ Ptr GValue gv (P.Just Clip obj) = forall a c. (HasCallStack, ManagedPtrNewtype a) => a -> (Ptr a -> IO c) -> IO c B.ManagedPtr.withManagedPtr Clip obj (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 <- forall a. GObject a => Ptr GValue -> IO (Ptr a) B.GValue.get_object Ptr GValue gv :: IO (FP.Ptr Clip) if Ptr Clip ptr forall a. Eq a => a -> a -> Bool /= forall a. Ptr a FP.nullPtr then forall a. a -> Maybe a P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> forall a b. (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a B.ManagedPtr.newObject ManagedPtr Clip -> Clip Clip Ptr Clip ptr else forall (m :: * -> *) a. Monad m => a -> m a return forall a. Maybe a P.Nothing #if defined(ENABLE_OVERLOADING) type family ResolveClipMethod (t :: Symbol) (o :: *) :: * 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a MIO.liftIO forall a b. (a -> b) -> a -> b $ forall a. GObject a => a -> String -> IO Word64 B.Properties.getObjectPropertyUInt64 o obj String "duration-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.1/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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a MIO.liftIO forall a b. (a -> b) -> a -> b $ forall a b. (GObject a, GObject b) => a -> String -> (ManagedPtr b -> b) -> IO (Maybe b) B.Properties.getObjectPropertyObject o obj String "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.1/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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a MIO.liftIO forall a b. (a -> b) -> a -> b $ forall a b. (GObject a, IsGFlag b, BoxedFlags b) => a -> String -> IO [b] B.Properties.getObjectPropertyFlags o obj String "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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a MIO.liftIO forall a b. (a -> b) -> a -> b $ do forall a b. (IsGFlag b, BoxedFlags b, GObject a) => a -> String -> [b] -> IO () B.Properties.setObjectPropertyFlags o obj String "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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a MIO.liftIO forall a b. (a -> b) -> a -> b $ do forall (m :: * -> *) a. MonadIO m => IO a -> m a MIO.liftIO forall a b. (a -> b) -> a -> b $ forall a o. (IsGFlag a, BoxedFlags a) => String -> [a] -> IO (GValueConstruct o) B.Properties.constructObjectPropertyFlags String "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.1/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, *)]) #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, *)]) #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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr Asset 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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b) convertIfNonNull Ptr TrackElement result forall a b. (a -> b) -> a -> b $ \Ptr TrackElement result' -> do TrackElement result'' <- (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' forall (m :: * -> *) a. Monad m => a -> m a return TrackElement result'' forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b asset 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.1/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 -- , 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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr TrackElement child' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr b child Ptr Track track' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr c track forall a b. IO a -> IO b -> IO a onException (do Ptr TrackElement result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a propagateGError 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' forall a. HasCallStack => Text -> Ptr a -> IO () checkUnexpectedReturnNULL Text "clipAddChildToTrack" Ptr TrackElement result TrackElement result' <- (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 forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b child forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr c track forall (m :: * -> *) a. Monad m => a -> m a return TrackElement result' ) (do 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.1/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 -- , 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 -- , 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" -- , sinceVersion = Nothing -- } -- , argScope = ScopeTypeInvalid -- , argClosure = -1 -- , argDestroy = -1 -- , argCallerAllocates = False -- , transfer = TransferNothing -- } -- ] -- Lengths: [] -- returnType: Just (TBasicType TBoolean) -- throws : True -- Skip return : False foreign import ccall "ges_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 -> 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr BaseEffect effect' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr b effect forall a b. IO a -> IO b -> IO a onException (do CInt _ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a propagateGError forall a b. (a -> b) -> a -> b $ Ptr Clip -> Ptr BaseEffect -> Int32 -> Ptr (Ptr GError) -> IO CInt ges_clip_add_top_effect Ptr Clip clip' Ptr BaseEffect effect' Int32 index forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b effect forall (m :: * -> *) a. Monad m => a -> m a return () ) (do 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.1/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 -- , 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 -- , 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 -- , 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_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip 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 -> forall (m :: * -> *) a. Monad m => a -> m a return forall a. Ptr a nullPtr Just b jTrack -> do Ptr Track jTrack' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr b jTrack 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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b) convertIfNonNull Ptr TrackElement result forall a b. (a -> b) -> a -> b $ \Ptr TrackElement result' -> do TrackElement result'' <- (forall a b. (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a wrapObject ManagedPtr TrackElement -> TrackElement GES.TrackElement.TrackElement) Ptr TrackElement result' forall (m :: * -> *) a. Monad m => a -> m a return TrackElement result'' forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m () whenJust Maybe b track forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr 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.1/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 -- , 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 -- , 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 -- , 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 -- , 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_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip 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 -> forall (m :: * -> *) a. Monad m => a -> m a return forall a. Ptr a nullPtr Just b jTrack -> do Ptr Track jTrack' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr b jTrack forall (m :: * -> *) a. Monad m => a -> m a return Ptr Track jTrack' let trackType' :: CUInt trackType' = 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' <- forall a. Ptr (GList (Ptr a)) -> IO [Ptr a] unpackGList Ptr (GList (Ptr TrackElement)) result [TrackElement] result'' <- forall (t :: * -> *) (m :: * -> *) a b. (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) mapM (forall a b. (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a wrapObject ManagedPtr TrackElement -> TrackElement GES.TrackElement.TrackElement) [Ptr TrackElement] result' forall a. Ptr (GList a) -> IO () g_list_free Ptr (GList (Ptr TrackElement)) result forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m () whenJust Maybe b track forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr 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.1/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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip 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' forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip 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.1/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 -- , 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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr TrackElement child' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr b child forall a b. IO a -> IO b -> IO a onException (do Word64 result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a propagateGError 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 forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b child forall (m :: * -> *) a. Monad m => a -> m a return Word64 result ) (do 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.1/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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip 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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b) convertIfNonNull Ptr Layer result forall a b. (a -> b) -> a -> b $ \Ptr Layer result' -> do Layer result'' <- (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' forall (m :: * -> *) a. Monad m => a -> m a return Layer result'' forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip 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.1/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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip 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' = forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b] wordToGFlags CUInt result forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip 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.1/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 -- , 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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr TrackElement child' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr b child forall a b. IO a -> IO b -> IO a onException (do Word64 result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a propagateGError 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 forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b child forall (m :: * -> *) a. Monad m => a -> m a return Word64 result ) (do 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.1/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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip forall a b. IO a -> IO b -> IO a onException (do Word64 result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a propagateGError 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 forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall (m :: * -> *) a. Monad m => a -> m a return Word64 result ) (do 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.1/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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr BaseEffect effect' <- 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' forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b effect 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.1/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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr BaseEffect effect' <- 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' forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b effect 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.1/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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip 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' <- forall a. Ptr (GList (Ptr a)) -> IO [Ptr a] unpackGList Ptr (GList (Ptr TrackElement)) result [TrackElement] result'' <- forall (t :: * -> *) (m :: * -> *) a b. (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) mapM (forall a b. (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a wrapObject ManagedPtr TrackElement -> TrackElement GES.TrackElement.TrackElement) [Ptr TrackElement] result' forall a. Ptr (GList a) -> IO () g_list_free Ptr (GList (Ptr TrackElement)) result forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip 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.1/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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr Layer 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' = (forall a. Eq a => a -> a -> Bool /= CInt 0) CInt result forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b layer 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.1/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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr Layer layer' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr b layer forall a b. IO a -> IO b -> IO a onException (do CInt _ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a propagateGError forall a b. (a -> b) -> a -> b $ Ptr Clip -> Ptr Layer -> Ptr (Ptr GError) -> IO CInt ges_clip_move_to_layer_full Ptr Clip clip' Ptr Layer layer' forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b layer forall (m :: * -> *) a. Monad m => a -> m a return () ) (do 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.1/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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr BaseEffect effect' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr b effect forall a b. IO a -> IO b -> IO a onException (do CInt _ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a propagateGError forall a b. (a -> b) -> a -> b $ Ptr Clip -> Ptr BaseEffect -> Ptr (Ptr GError) -> IO CInt ges_clip_remove_top_effect Ptr Clip clip' Ptr BaseEffect effect' forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b effect forall (m :: * -> *) a. Monad m => a -> m a return () ) (do 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.1/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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip let supportedformats' :: CUInt supportedformats' = 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' forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip 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.1/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 -- , 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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr BaseEffect effect' <- 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' = (forall a. Eq a => a -> a -> Bool /= CInt 0) CInt result forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b effect 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.1/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 -- , 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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr BaseEffect effect' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr b effect forall a b. IO a -> IO b -> IO a onException (do CInt _ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a propagateGError forall a b. (a -> b) -> a -> b $ Ptr Clip -> Ptr BaseEffect -> Word32 -> Ptr (Ptr GError) -> IO CInt ges_clip_set_top_effect_index_full Ptr Clip clip' Ptr BaseEffect effect' Word32 newindex forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b effect forall (m :: * -> *) a. Monad m => a -> m a return () ) (do 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.1/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 -- , 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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip Ptr BaseEffect effect' <- 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' = (forall a. Eq a => a -> a -> Bool /= CInt 0) CInt result forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr b effect 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.1/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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip 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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b) convertIfNonNull Ptr Clip result forall a b. (a -> b) -> a -> b $ \Ptr Clip result' -> do Clip result'' <- (forall a b. (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a newObject ManagedPtr Clip -> Clip Clip) Ptr Clip result' forall (m :: * -> *) a. Monad m => a -> m a return Clip result'' forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip 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.1/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 -- , 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 -- , 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 = forall (m :: * -> *) a. MonadIO m => IO a -> m a liftIO forall a b. (a -> b) -> a -> b $ do Ptr Clip clip' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b) unsafeManagedPtrCastPtr a clip forall a b. IO a -> IO b -> IO a onException (do Ptr Clip result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a propagateGError 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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b) convertIfNonNull Ptr Clip result forall a b. (a -> b) -> a -> b $ \Ptr Clip result' -> do Clip result'' <- (forall a b. (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a newObject ManagedPtr Clip -> Clip Clip) Ptr Clip result' forall (m :: * -> *) a. Monad m => a -> m a return Clip result'' forall a. ManagedPtrNewtype a => a -> IO () touchManagedPtr a clip forall (m :: * -> *) a. Monad m => a -> m a return Maybe Clip maybeResult ) (do 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.1/docs/GI-GES-Objects-Clip.html#v:clipSplitFull" }) #endif