GESTimeline

GES.Timeline

GObject.Object
    ╰──GObject.InitiallyUnowned
        ╰──Gst.Object
            ╰──Gst.Element
                ╰──Gst.Bin
                    ╰──GES.Timeline

GES.Timeline.prototype.new

function GES.Timeline.prototype.new(): {
    // javascript wrapper for 'ges_timeline_new'
}

Creates a new empty timeline.

GES.Timeline.prototype.new_audio_video

function GES.Timeline.prototype.new_audio_video(): {
    // javascript wrapper for 'ges_timeline_new_audio_video'
}

Creates a new timeline containing a single GES.AudioTrack and a single GES.VideoTrack.

GES.Timeline.prototype.new_from_uri

function GES.Timeline.prototype.new_from_uri(uri: String): {
    // javascript wrapper for 'ges_timeline_new_from_uri'
}

Creates a timeline from the given URI.

GES.Timeline.prototype.add_layer

function GES.Timeline.prototype.add_layer(layer: GES.Layer): {
    // javascript wrapper for 'ges_timeline_add_layer'
}

Add a layer to the timeline.

If the layer contains GES.Clip-s, then this may trigger the creation of their core track element children for the timeline's tracks, and the placement of the clip's children in the tracks of the timeline using select-tracks-for-object. Some errors may occur if this would break one of the configuration rules of the timeline in one of its tracks. In such cases, some track elements would fail to be added to their tracks, but this method would still return true. As such, it is advised that you only add clips to layers that already part of a timeline. In such situations, GES.Layer.prototype.add_clip is able to fail if adding the clip would cause such an error.

deprecated : 1.18: This method requires you to ensure the layer's #GESLayer:priority will be unique to the timeline. Use ges_timeline_append_layer() and ges_timeline_move_layer() instead.

GES.Timeline.prototype.add_track

function GES.Timeline.prototype.add_track(track: GES.Track): {
    // javascript wrapper for 'ges_timeline_add_track'
}

Add a track to the timeline.

If the timeline already contains clips, then this may trigger the creation of their core track element children for the track, and the placement of the clip's children in the track of the timeline using select-tracks-for-object. Some errors may occur if this would break one of the configuration rules for the timeline in the track. In such cases, some track elements would fail to be added to the track, but this method would still return true. As such, it is advised that you avoid adding tracks to timelines that already contain clips.

GES.Timeline.prototype.append_layer

function GES.Timeline.prototype.append_layer(): {
    // javascript wrapper for 'ges_timeline_append_layer'
}

Append a newly created layer to the timeline. The layer will be added at the lowest priority (numerically, the highest).

GES.Timeline.prototype.commit

function GES.Timeline.prototype.commit(): {
    // javascript wrapper for 'ges_timeline_commit'
}

Commit all the pending changes of the clips contained in the timeline.

When changes happen in a timeline, they are not immediately executed internally, in a way that effects the output data of the timeline. You should call this method when you are done with a set of changes and you want them to be executed.

Any pending changes will be executed in the backend. The commited signal will be emitted once this has completed. You should not try to change the state of the timeline, seek it or add tracks to it before receiving this signal. You can use GES.Timeline.prototype.commit_sync if you do not want to perform other tasks in the mean time.

Note that all the pending changes will automatically be executed when the timeline goes from Gst.State.READY to Gst.State.PAUSED, which is usually triggered by a corresponding state changes in a containing GES.Pipeline.

GES.Timeline.prototype.commit_sync

function GES.Timeline.prototype.commit_sync(): {
    // javascript wrapper for 'ges_timeline_commit_sync'
}

Commit all the pending changes of the clips contained in the timeline and wait for the changes to complete.

See GES.Timeline.prototype.commit.

GES.Timeline.prototype.disable_edit_apis

function GES.Timeline.prototype.disable_edit_apis(disable_edit_apis: Number): {
    // javascript wrapper for 'ges_timeline_disable_edit_apis'
}

WARNING: When using that mode, GES won't guarantee the coherence of the timeline. You need to ensure that the rules described in the Overlaps and auto transitions section are respected any time the timeline is commited (otherwise playback will most probably fail in different ways).

When disabling editing APIs, GES won't be able to enforce the rules that makes the timeline overall state to be valid but some feature won't be usable:

• snapping-distance
• auto-transition

Since : 1.22

GES.Timeline.prototype.freeze_commit

function GES.Timeline.prototype.freeze_commit(): {
    // javascript wrapper for 'ges_timeline_freeze_commit'
}

Freezes the timeline from being committed. This is usually needed while the timeline is being rendered to ensure that not change to the timeline are taken into account during that moment. Once the rendering is done, you should call GES.Timeline.prototype.thaw_commit so that committing becomes possible again and any call to commit() that happened during the rendering is actually taken into account.

Since : 1.20

GES.Timeline.prototype.get_auto_transition

function GES.Timeline.prototype.get_auto_transition(): {
    // javascript wrapper for 'ges_timeline_get_auto_transition'
}

Gets auto-transition for the timeline.

GES.Timeline.prototype.get_duration

function GES.Timeline.prototype.get_duration(): {
    // javascript wrapper for 'ges_timeline_get_duration'
}

Get the current duration of the timeline

GES.Timeline.prototype.get_edit_apis_disabled

function GES.Timeline.prototype.get_edit_apis_disabled(): {
    // javascript wrapper for 'ges_timeline_get_edit_apis_disabled'
}

Since : 1.22

GES.Timeline.prototype.get_element

function GES.Timeline.prototype.get_element(name: String): {
    // javascript wrapper for 'ges_timeline_get_element'
}

Gets the element contained in the timeline with the given name.

GES.Timeline.prototype.get_frame_at

function GES.Timeline.prototype.get_frame_at(timestamp: Number): {
    // javascript wrapper for 'ges_timeline_get_frame_at'
}

This method allows you to convert a timeline Number into its corresponding Number in the timeline's output.

Since : 1.18

GES.Timeline.prototype.get_frame_time

function GES.Timeline.prototype.get_frame_time(frame_number: Number): {
    // javascript wrapper for 'ges_timeline_get_frame_time'
}

This method allows you to convert a timeline output frame number into a timeline Number. For example, this time could be used to seek to a particular frame in the timeline's output, or as the edit position for an element within the timeline.

Since : 1.18

GES.Timeline.prototype.get_groups

function GES.Timeline.prototype.get_groups(): {
    // javascript wrapper for 'ges_timeline_get_groups'
}

Get the list of GES.Group-s present in the timeline.

GES.Timeline.prototype.get_layer

function GES.Timeline.prototype.get_layer(priority: Number): {
    // javascript wrapper for 'ges_timeline_get_layer'
}

Retrieve the layer whose index in the timeline matches the given priority.

GES.Timeline.prototype.get_layers

function GES.Timeline.prototype.get_layers(): {
    // javascript wrapper for 'ges_timeline_get_layers'
}

Get the list of GES.Layer-s present in the timeline.

GES.Timeline.prototype.get_pad_for_track

function GES.Timeline.prototype.get_pad_for_track(track: GES.Track): {
    // javascript wrapper for 'ges_timeline_get_pad_for_track'
}

Search for the Gst.Pad corresponding to the given timeline's track. You can link to this pad to receive the output data of the given track.

GES.Timeline.prototype.get_snapping_distance

function GES.Timeline.prototype.get_snapping_distance(): {
    // javascript wrapper for 'ges_timeline_get_snapping_distance'
}

Gets the snapping-distance for the timeline.

GES.Timeline.prototype.get_track_for_pad

function GES.Timeline.prototype.get_track_for_pad(pad: Gst.Pad): {
    // javascript wrapper for 'ges_timeline_get_track_for_pad'
}

Search for the GES.Track corresponding to the given timeline's pad.

GES.Timeline.prototype.get_tracks

function GES.Timeline.prototype.get_tracks(): {
    // javascript wrapper for 'ges_timeline_get_tracks'
}

Get the list of GES.Track-s used by the timeline.

GES.Timeline.prototype.is_empty

function GES.Timeline.prototype.is_empty(): {
    // javascript wrapper for 'ges_timeline_is_empty'
}

Check whether the timeline is empty or not.

GES.Timeline.prototype.load_from_uri

function GES.Timeline.prototype.load_from_uri(uri: String): {
    // javascript wrapper for 'ges_timeline_load_from_uri'
}

Loads the contents of URI into the timeline.

GES.Timeline.prototype.move_layer

function GES.Timeline.prototype.move_layer(layer: GES.Layer, new_layer_priority: Number): {
    // javascript wrapper for 'ges_timeline_move_layer'
}

Moves a layer within the timeline to the index given by new_layer_priority. An index of 0 corresponds to the layer with the highest priority in a timeline. If new_layer_priority is greater than the number of layers present in the timeline, it will become the lowest priority layer.

Since : 1.16

GES.Timeline.prototype.paste_element

function GES.Timeline.prototype.paste_element(element: GES.TimelineElement, position: Number, layer_priority: Number): {
    // javascript wrapper for 'ges_timeline_paste_element'
}

Paste an element inside the timeline. element **must** be the return of GES.TimelineElement.prototype.copy with deep=TRUE, and it should not be changed before pasting. element itself is not placed in the timeline, instead a new element is created, alike to the originally copied element. Note that the originally copied element must also lie within timeline, at both the point of copying and pasting.

Pasting may fail if it would place the timeline in an unsupported configuration.

After calling this function element should not be used. In particular, element can not be pasted again. Instead, you can copy the returned element and paste that copy (although, this is only possible if the paste was successful).

See also GES.TimelineElement.prototype.paste.

GES.Timeline.prototype.remove_layer

function GES.Timeline.prototype.remove_layer(layer: GES.Layer): {
    // javascript wrapper for 'ges_timeline_remove_layer'
}

Removes a layer from the timeline.

GES.Timeline.prototype.remove_track

function GES.Timeline.prototype.remove_track(track: GES.Track): {
    // javascript wrapper for 'ges_timeline_remove_track'
}

Remove a track from the timeline.

GES.Timeline.prototype.save_to_uri

function GES.Timeline.prototype.save_to_uri(uri: String, formatter_asset: GES.Asset, overwrite: Number): {
    // javascript wrapper for 'ges_timeline_save_to_uri'
}

Saves the timeline to the given location. If formatter_asset is null, the method will attempt to save in the same format the timeline was loaded from, before defaulting to the formatter with highest rank.

GES.Timeline.prototype.set_auto_transition

function GES.Timeline.prototype.set_auto_transition(auto_transition: Number): {
    // javascript wrapper for 'ges_timeline_set_auto_transition'
}

Sets auto-transition for the timeline. This will also set the corresponding auto-transition for all of the timeline's layers to the same value. See GES.Layer.prototype.set_auto_transition if you wish to set the layer's auto-transition individually.

GES.Timeline.prototype.set_snapping_distance

function GES.Timeline.prototype.set_snapping_distance(snapping_distance: Number): {
    // javascript wrapper for 'ges_timeline_set_snapping_distance'
}

Sets snapping-distance for the timeline. This new value will only effect future snappings and will not be used to snap the current element positions within the timeline.

GES.Timeline.prototype.thaw_commit

function GES.Timeline.prototype.thaw_commit(): {
    // javascript wrapper for 'ges_timeline_thaw_commit'
}

Thaw the timeline so that comiting becomes possible again and any call to commit() that happened during the rendering is actually taken into account.

Since : 1.20

commited

function commited_callback(self: GES.Timeline, user_data: Object): {
    // javascript callback for the 'commited' signal
}

This signal will be emitted once the changes initiated by GES.Timeline.prototype.commit have been executed in the backend. Use GES.Timeline.prototype.commit_sync if you do not want to have to connect to this signal.

Flags: Run Last

group-added

function group_added_callback(self: GES.Timeline, group: GES.Group, user_data: Object): {
    // javascript callback for the 'group-added' signal
}

Will be emitted after the group is added to to the timeline. This can happen when grouping with ges_container_group, or by adding containers to a newly created group.

Note that this should not be emitted whilst a timeline is being loaded from its GES.Project asset. You should connect to the project's loaded signal if you want to know which groups were created for the timeline.

Flags: Run First

group-removed

function group_removed_callback(self: GES.Timeline, group: GES.Group, children: [ GES.Container ], user_data: Object): {
    // javascript callback for the 'group-removed' signal
}

Will be emitted after the group is removed from the timeline through ges_container_ungroup. Note that group will no longer contain its former children, these are held in children.

Note that if a group is emptied, then it will no longer belong to the timeline, but this signal will not be emitted in such a case.

Flags: Run First

layer-added

function layer_added_callback(self: GES.Timeline, layer: GES.Layer, user_data: Object): {
    // javascript callback for the 'layer-added' signal
}

Will be emitted after the layer is added to the timeline.

Note that this should not be emitted whilst a timeline is being loaded from its GES.Project asset. You should connect to the project's loaded signal if you want to know which layers were created for the timeline.

Flags: Run First

layer-removed

function layer_removed_callback(self: GES.Timeline, layer: GES.Layer, user_data: Object): {
    // javascript callback for the 'layer-removed' signal
}

Will be emitted after the layer is removed from the timeline.

Flags: Run First

select-element-track

function select_element_track_callback(self: GES.Timeline, clip: GES.Clip, track_element: GES.TrackElement, user_data: Object): {
    // javascript callback for the 'select-element-track' signal
}

Simplified version of select-tracks-for-object which only allows track_element to be added to a single GES.Track.

Flags: Run Last

Since : 1.18

select-tracks-for-object

function select_tracks_for_object_callback(self: GES.Timeline, clip: GES.Clip, track_element: GES.TrackElement, user_data: Object): {
    // javascript callback for the 'select-tracks-for-object' signal
}

This will be emitted whenever the timeline needs to determine which tracks a clip's children should be added to. The track element will be added to each of the tracks given in the return. If a track element is selected to go into multiple tracks, it will be copied into the additional tracks, under the same clip. Note that the copy will not keep its properties or state in sync with the original.

Connect to this signal once if you wish to control which element should be added to which track. Doing so will overwrite the default behaviour, which adds track_element to all tracks whose track-type includes the track_element's track-type.

Note that under the default track selection, if a clip would produce multiple core children of the same GES.TrackType, it will choose one of the core children arbitrarily to place in the corresponding tracks, with a warning for the other core children that are not placed in the track. For example, this would happen for a GES.UriClip that points to a file that contains multiple audio streams. If you wish to choose the stream, you could connect to this signal, and use, say, GES.UriSourceAsset.prototype.get_stream_info to choose which core source to add.

When a clip is first added to a timeline, its core elements will be created for the current tracks in the timeline if they have not already been created. Then this will be emitted for each of these core children to select which tracks, if any, they should be added to. It will then be called for any non-core children in the clip.

In addition, if a new track element is ever added to a clip in a timeline (and it is not already part of a track) this will be emitted to select which tracks the element should be added to.

Finally, as a special case, if a track is added to the timeline after it already contains clips, then it will request the creation of the clips' core elements of the corresponding type, if they have not already been created, and this signal will be emitted for each of these newly created elements. In addition, this will also be released for all other track elements in the timeline's clips that have not yet been assigned a track. However, in this final case, the timeline will only check whether the newly added track appears in the track list. If it does appear, the track element will be added to the newly added track. All other tracks in the returned track list are ignored.

In this latter case, track elements that are already part of a track will not be asked if they want to be copied into the new track. If you wish to do this, you can use GES.Clip.prototype.add_child_to_track.

Note that the returned GPtrArray (not introspectable) should own a new reference to each of its contained GES.Track. The timeline will set the GLib.DestroyNotify free function on the GPtrArray (not introspectable) to dereference the elements.

Flags: Run Last

snapping-ended

function snapping_ended_callback(self: GES.Timeline, obj1: GES.TrackElement, obj2: GES.TrackElement, position: Number, user_data: Object): {
    // javascript callback for the 'snapping-ended' signal
}

Will be emitted whenever a snapping event ends. After a snap event has started (see snapping-started), it can later end because either another timeline edit has occurred (which may or may not have created a new snapping event), or because the timeline has been committed.

Flags: Run Last

snapping-started

function snapping_started_callback(self: GES.Timeline, obj1: GES.TrackElement, obj2: GES.TrackElement, position: Number, user_data: Object): {
    // javascript callback for the 'snapping-started' signal
}

Will be emitted whenever an element's movement invokes a snapping event during an edit (usually of one of its ancestors) because its start or end point lies within the snapping-distance of another element's start or end point.

See GES.EditMode to see what can snap during an edit.

Note that only up to one snapping-started signal will be emitted per element edit within a timeline.

Flags: Run Last

track-added

function track_added_callback(self: GES.Timeline, track: GES.Track, user_data: Object): {
    // javascript callback for the 'track-added' signal
}

Will be emitted after the track is added to the timeline.

Note that this should not be emitted whilst a timeline is being loaded from its GES.Project asset. You should connect to the project's loaded signal if you want to know which tracks were created for the timeline.

Flags: Run First

track-removed

function track_removed_callback(self: GES.Timeline, track: GES.Track, user_data: Object): {
    // javascript callback for the 'track-removed' signal
}

Will be emitted after the track is removed from the timeline.

Flags: Run First

auto-transition

“auto-transition” Number

Whether to automatically create a transition whenever two GES.Source-s overlap in a track of the timeline. See auto-transition if you want this to only happen in some layers.

Flags : Read / Write

duration

“duration” Number

The current duration (in nanoseconds) of the timeline. A timeline 'starts' at time 0, so this is the maximum end time of all of its GES.TimelineElement-s.

Flags : Read

snapping-distance

“snapping-distance” Number

The distance (in nanoseconds) at which a GES.TimelineElement being moved within the timeline should snap one of its GES.Source-s with another GES.Source-s edge. See GES.EditMode for which edges can snap during an edit. 0 means no snapping.

Flags : Read / Write

vfunc_group_added

function vfunc_group_added(timeline: GES.Timeline, group: GES.Group): {
    // javascript implementation of the 'group_added' virtual method
}

vfunc_layer_added

function vfunc_layer_added(timeline: GES.Timeline, layer: GES.Layer): {
    // javascript implementation of the 'layer_added' virtual method
}

vfunc_layer_removed

function vfunc_layer_removed(timeline: GES.Timeline, layer: GES.Layer): {
    // javascript implementation of the 'layer_removed' virtual method
}

vfunc_track_added

function vfunc_track_added(timeline: GES.Timeline, track: GES.Track): {
    // javascript implementation of the 'track_added' virtual method
}

vfunc_track_removed

function vfunc_track_removed(timeline: GES.Timeline, track: GES.Track): {
    // javascript implementation of the 'track_removed' virtual method
}