[−][src]Enum gstreamer_editing_services::EditMode
When a single timeline element is edited within its timeline at some
position, using TimelineElementExt::edit
, depending on the edit
mode, its TimelineElement:start
, TimelineElement:duration
or
TimelineElement:in-point
will be adjusted accordingly. In addition,
any clips may change Clip:layer
.
Each edit can be broken down into a combination of three basic edits:
- MOVE: This moves the start of the element to the edit position.
- START-TRIM: This cuts or grows the start of the element, whilst maintaining the time at which its internal content appears in the timeline data output. If the element is made shorter, the data that appeared at the edit position will still appear in the timeline at the same time. If the element is made longer, the data that appeared at the previous start of the element will still appear in the timeline at the same time.
- END-TRIM: Similar to START-TRIM, but the end of the element is cut or grown.
In particular, when editing a Clip
:
- MOVE: This will set the
TimelineElement:start
of the clip to the edit position. - START-TRIM: This will set the
TimelineElement:start
of the clip to the edit position. To keep the end time the same, theTimelineElement:duration
of the clip will be adjusted in the opposite direction. In addition, theTimelineElement:in-point
of the clip will be shifted such that the content that appeared at the new or previous start time, whichever is latest, still appears at the same timeline time. For example, if a frame appeared at the start of the clip, and the start of the clip is reduced, the in-point of the clip will also reduce such that the frame will appear later within the clip, but at the same timeline position. - END-TRIM: This will set the
TimelineElement:duration
of the clip such that its end time will match the edit position.
When editing a Group
:
- MOVE: This will set the
Group:start
of the clip to the edit position by shifting all of its children by the same amount. So each child will maintain their relative positions. - START-TRIM: If the group is made shorter, this will START-TRIM any clips under the group that start after the edit position to the same edit position. If the group is made longer, this will START-TRIM any clip under the group whose start matches the start of the group to the same edit position.
- END-TRIM: If the group is made shorter, this will END-TRIM any clips under the group that end after the edit position to the same edit position. If the group is made longer, this will END-TRIM any clip under the group whose end matches the end of the group to the same edit position.
When editing a TrackElement
, if it has a Clip
parent, this
will be edited instead. Otherwise it is edited in the same way as a
Clip
.
The layer priority of a Group
is the lowest layer priority of any
Clip
underneath it. When a group is edited to a new layer
priority, it will shift all clips underneath it by the same amount,
such that their relative layers stay the same.
If the Timeline
has a Timeline:snapping-distance
, then snapping
may occur for some of the edges of the main edited element:
- MOVE: The start or end edge of any
Source
under the element may be snapped. - START-TRIM: The start edge of a
Source
whose start edge touches the start edge of the element may snap. - END-TRIM: The end edge of a
Source
whose end edge touches the end edge of the element may snap.
These edges may snap with either the start or end edge of any other
Source
in the timeline that is not also being moved by the element,
including those in different layers, if they are within the
Timeline:snapping-distance
. During an edit, only up to one snap can
occur. This will shift the edit position such that the snapped edges
will touch once the edit has completed.
Note that snapping can cause an edit to fail where it would have otherwise succeeded because it may push the edit position such that the edit would result in an unsupported timeline configuration. Similarly, snapping can cause an edit to succeed where it would have otherwise failed.
For example, in EditMode::Ripple
acting on Edge::None
, the
main element is the MOVED toplevel of the edited element. Any source
under the main MOVED toplevel may have its start or end edge snapped.
Note, these sources cannot snap with each other. The edit may also
push other elements, but any sources under these elements cannot snap,
nor can they be snapped with. If a snap does occur, the MOVE of the
toplevel and all other elements pushed by the ripple will be shifted
by the same amount such that the snapped edges will touch.
You can also find more explanation about the behaviour of those modes at: trim, ripple and roll and clip management.
Variants (Non-exhaustive)
The element is edited the normal way (default).
If acting on the element as a whole (Edge::None
), this will MOVE
the element by MOVING its toplevel. When acting on the start of the
element (Edge::Start
), this will only MOVE the element, but not
its toplevel parent. This can allow you to move a Clip
or
Group
to a new start time or layer within its container group,
without effecting other members of the group. When acting on the end
of the element (Edge::End
), this will END-TRIM the element,
leaving its toplevel unchanged.
The element is edited in ripple mode: moving
itself as well as later elements, keeping their relative times. This
edits the element the same as EditMode::Normal
. In addition, if
acting on the element as a whole, or the start of the element, any
toplevel element in the same timeline (including different layers)
whose start time is later than the current start time of the MOVED
element will also be MOVED by the same shift as the edited element.
If acting on the end of the element, any toplevel element whose start
time is later than the current end time of the edited element will
also be MOVED by the same shift as the change in the end of the
edited element. These additional elements will also be shifted by
the same shift in layers as the edited element.
The element is edited in roll mode: swapping its
content for its neighbour's, or vis versa, in the timeline output.
This edits the element the same as EditMode::Trim
. In addition,
any neighbours are also TRIMMED at their opposite edge to the same
timeline position. When acting on the start of the element, a
neighbour is any earlier element in the timeline whose end time
matches the current start time of the edited element. When acting on
the end of the element, a neighbour is any later element in the
timeline whose start time matches the current start time of the
edited element. In addition, a neighbour have a Source
at its
end/start edge that shares a track with a Source
at the start/end
edge of the edited element. Basically, a neighbour is an element that
can be extended, or cut, to have its content replace, or be replaced
by, the content of the edited element. Acting on the element as a
whole (Edge::None
) is not defined. The element can not shift
layers under this mode.
The element is edited in trim mode. When acting
on the start of the element, this will START-TRIM it. When acting on
the end of the element, this will END-TRIM it. Acting on the element
as a whole (Edge::None
) is not defined.
The element is edited in slide mode (not yet
implemented): moving the element replacing or consuming content on
each end. When acting on the element as a whole, this will MOVE the
element, and TRIM any neighbours on either side. A neighbour is
defined in the same way as in EditMode::Roll
, but they may be on
either side of the edited elements. Elements at the end with be
START-TRIMMED to the new end position of the edited element. Elements
at the start will be END-TRIMMED to the new start position of the
edited element. Acting on the start or end of the element
(Edge::Start
and Edge::End
) is not defined. The element can
not shift layers under this mode.
Trait Implementations
impl Clone for EditMode
[src]
impl Copy for EditMode
[src]
impl Debug for EditMode
[src]
impl Eq for EditMode
[src]
impl<'a> FromValue<'a> for EditMode
[src]
unsafe fn from_value(value: &Value) -> Self
[src]
impl<'a> FromValueOptional<'a> for EditMode
[src]
unsafe fn from_value_optional(value: &Value) -> Option<Self>
[src]
impl Hash for EditMode
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl Ord for EditMode
[src]
fn cmp(&self, other: &EditMode) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl PartialEq<EditMode> for EditMode
[src]
impl PartialOrd<EditMode> for EditMode
[src]
fn partial_cmp(&self, other: &EditMode) -> Option<Ordering>
[src]
fn lt(&self, other: &EditMode) -> bool
[src]
fn le(&self, other: &EditMode) -> bool
[src]
fn gt(&self, other: &EditMode) -> bool
[src]
fn ge(&self, other: &EditMode) -> bool
[src]
impl SetValue for EditMode
[src]
impl StaticType for EditMode
[src]
fn static_type() -> Type
[src]
impl StructuralEq for EditMode
[src]
impl StructuralPartialEq for EditMode
[src]
Auto Trait Implementations
impl RefUnwindSafe for EditMode
impl Send for EditMode
impl Sync for EditMode
impl Unpin for EditMode
impl UnwindSafe for EditMode
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T> ToSendValue for T where
T: ToValue + SetValue + Send + ?Sized,
[src]
T: ToValue + SetValue + Send + ?Sized,
fn to_send_value(&self) -> SendValue
[src]
impl<T> ToValue for T where
T: SetValue + ?Sized,
[src]
T: SetValue + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,