Enum gstreamer_editing_services::EditMode

#[non_exhaustive]
pub enum EditMode {
    Normal,
    Ripple,
    Roll,
    Trim,
    Slide,
    // some variants omitted
}

When a single timeline element is edited within its timeline at some position, using crate::prelude::TimelineElementExt::edit(), depending on the edit mode, its [crate::TimelineElement:start], [crate::TimelineElement:duration] or [crate::TimelineElement:in-point] will be adjusted accordingly. In addition, any clips may change [crate::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 crate::Clip:

• MOVE: This will set the [crate::TimelineElement:start] of the clip to the edit position.
• START-TRIM: This will set the [crate::TimelineElement:start] of the clip to the edit position. To keep the end time the same, the [crate::TimelineElement:duration] of the clip will be adjusted in the opposite direction. In addition, the [crate::TimelineElement: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 [crate::TimelineElement:duration] of the clip such that its end time will match the edit position.

When editing a crate::Group:

• MOVE: This will set the [crate::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 crate::TrackElement, if it has a crate::Clip parent, this will be edited instead. Otherwise it is edited in the same way as a crate::Clip.

The layer priority of a crate::Group is the lowest layer priority of any crate::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 crate::Timeline has a [crate::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 [crate::Source] under the element may be snapped.
• START-TRIM: The start edge of a [crate::Source] whose start edge touches the start edge of the element may snap.
• END-TRIM: The end edge of a [crate::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 [crate::Source] in the timeline that is not also being moved by the element, including those in different layers, if they are within the [crate::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 Self::Ripple acting on crate::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)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Normal

The element is edited the normal way (default). If acting on the element as a whole (crate::Edge::None), this will MOVE the element by MOVING its toplevel. When acting on the start of the element (crate::Edge::Start), this will only MOVE the element, but not its toplevel parent. This can allow you to move a crate::Clip or crate::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 (crate::Edge::End), this will END-TRIM the element, leaving its toplevel unchanged.

Ripple

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 Self::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.

Roll

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 Self::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 [crate::Source] at its end/start edge that shares a track with a [crate::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 (crate::Edge::None) is not defined. The element can not shift layers under this mode.

Trim

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 (crate::Edge::None) is not defined.

Slide

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 Self::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 (crate::Edge::Start and crate::Edge::End) is not defined. The element can not shift layers under this mode.

Implementations

impl EditMode

pub fn name<'a>(self) -> &'a str

This is supported on crate feature v1_18 only.

Trait Implementations

impl Clone for EditMode

fn clone(&self) -> EditMode

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EditMode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for EditMode

This is supported on crate feature v1_18 only.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> FromValue<'a> for EditMode

type Checker = GenericValueTypeChecker<Self>

Value type checker.

unsafe fn from_value(value: &'a Value) -> Self

Get the contained value from a Value.

impl Hash for EditMode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Ord for EditMode

fn cmp(&self, other: &EditMode) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<EditMode> for EditMode

fn eq(&self, other: &EditMode) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &EditMode) -> bool

This method tests for !=.

impl PartialOrd<EditMode> for EditMode

fn partial_cmp(&self, other: &EditMode) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for EditMode

fn static_type() -> Type

Returns the type identifier of Self.

impl ToValue for EditMode

fn to_value(&self) -> Value

Convert a value to a Value.

fn value_type(&self) -> Type

Returns the type identifer of self.

impl ValueType for EditMode

type Type = Self

Type to get the Type from.

impl Copy for EditMode

impl Eq for EditMode

impl StructuralEq for EditMode

impl StructuralPartialEq for EditMode