SignalRun LastcommitedSignalRun Firstgroup-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 GES.Project::loaded signal if you want to know which groups were created for the timeline.
SignalRun Firstgroup-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.
SignalRun Firstlayer-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 GES.Project::loaded signal if you want to know which layers were created for the timeline.
SignalRun Firstlayer-Will be emitted after the layer is removed from the timeline.
SignalRun Lastselect-Simplified version of GES.Timeline.SignalSignatures.select_tracks_for_object | GES.Timeline::select-tracks-for-object which only
allows track_element to be added to a single GES.Track.
SignalRun Lastselect-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
GES.Track.track_type includes the track_element's
GES.TrackElement.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_uri_source_asset_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_add_child_to_track().
Note that the returned GLib.PtrArray should own a new reference to each of its contained GES.Track. The timeline will set the GLib.DestroyNotify free function on the GLib.PtrArray to dereference the elements.
SignalRun Lastsnapping-Will be emitted whenever a snapping event ends. After a snap event has started (see GES.Timeline.SignalSignatures.snapping_started | GES.Timeline::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.
SignalRun Lastsnapping-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 GES.Timeline.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.
SignalRun Firsttrack-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 GES.Project::loaded signal if you want to know which tracks were created for the timeline.
SignalRun Firsttrack-Will be emitted after the track is removed from the timeline.
SignalRun Firstdeep-Will be emitted after the element was added to sub_bin.
SignalRun Firstdeep-Will be emitted after the element was removed from sub_bin.
SignalDetailedRun Firstdeep-The deep notify signal is used to be notified of property changes. It is typically attached to the toplevel bin to receive notifications from all the elements contained in that bin.
SignalDetailedRun Firstdeep-The deep notify signal is used to be notified of property changes. It is typically attached to the toplevel bin to receive notifications from all the elements contained in that bin.
SignalDetailedRun Firstdeep-The deep notify signal is used to be notified of property changes. It is typically attached to the toplevel bin to receive notifications from all the elements contained in that bin.
SignalRun Lastdo-Will be emitted when the bin needs to perform latency calculations. This signal is only emitted for toplevel bins or when Gst.Bin.async_handling is enabled.
Only one signal handler is invoked. If no signals are connected, the default handler is invoked, which will query and distribute the lowest possible latency to all sinks.
Connect to this signal if the default latency calculations are not sufficient, like when you need different latencies for different sinks in the same pipeline.
SignalRun Firstelement-Will be emitted after the element was added to the bin.
SignalRun Firstelement-Will be emitted after the element was removed from the bin.
SignalRun Lastno-This signals that the element will not generate more dynamic pads. Note that this signal will usually be emitted from the context of the streaming thread.
SignalDetailedActionRun FirstnotifyThe notify signal is emitted on an object when one of its properties has
its value set through g_object_set_property(), g_object_set(), et al.
Note that getting this signal doesn’t itself guarantee that the value of
the property has actually changed. When it is emitted is determined by the
derived GObject class. If the implementor did not create the property with
GObject.ParamFlags.EXPLICIT_NOTIFY, then any call to g_object_set_property() results
in ::notify being emitted, even if the new value is the same as the old.
If they did pass GObject.ParamFlags.EXPLICIT_NOTIFY, then this signal is emitted only
when they explicitly call g_object_notify() or g_object_notify_by_pspec(),
and common practice is to do that only when the value has actually changed.
This signal is typically used to obtain change notification for a
single property, by specifying the property name as a detail in the
g_signal_connect() call, like this:
g_signal_connect (text_view->buffer, "notify::paste-target-list",
G_CALLBACK (gtk_text_view_target_list_notify),
text_view)
It is important to note that you must use [canonical parameter names][class@GObject.ParamSpec#parameter-names] as detail strings for the notify signal.
SignalRun Lastpad-a new Gst.Pad has been added to the element. Note that this signal will
usually be emitted from the context of the streaming thread. Also keep in
mind that if you add new elements to the pipeline in the signal handler
you will need to set them to the desired target state with
gst_element_set_state() or gst_element_sync_state_with_parent().
SignalRun Lastpad-a Gst.Pad has been removed from the element
This signal will be emitted once the changes initiated by
ges_timeline_commit()have been executed in the backend. Useges_timeline_commit_sync()if you do not want to have to connect to this signal.