Struct Sequence 

pub struct Sequence<T> { /* private fields */ }

A chain of value transitions, each starting when the previous one ends.

A sequence begins at from on the frame it is first sampled and runs its steps in order. A step ends at an absolute instant — its start plus its delay and duration — and the next step starts at that same instant, so a frame that lands past a boundary samples the next step where it would have been rather than starting it late. Steps of zero duration complete within the frame that reaches them.

State is keyed by id exactly as super::transition keys its own, and the sequence plays once per key. Re-rendering with the same ID continues it; to replay, include an application-owned generation in the ID, for example ("toast-enter", generation).

A step’s target and transition are captured when the step starts. Handing the step being played a different target restarts the sequence: it begins again at its first step from the value sampled at that instant, as a retargeted transition continues from its current value. Steps other than the one being played are read when the sequence reaches them and are not compared, so a change to an earlier step has no effect on its own. A sequence does not reverse; play a second sequence back to the start under its own key when that is wanted.

Under reduced motion the sequence adopts its last target at once, reports Finished, and requests no frame.

Implementations

impl<T> Sequence<T>

where T: Interpolate + PartialEq + 'static,

pub fn new(id: impl Into<TransitionId>, from: T) -> Self

Starts a sequence at from, with no steps yet.

pub fn with_step(self, target: T, transition: Transition) -> Self

Appends a step that transitions to target once the previous step ends.

pub fn with_steps( self, steps: impl IntoIterator<Item = SequenceStep<T>>, ) -> Self

Appends steps built elsewhere, in order.

pub fn from(&self) -> &T

pub fn steps(&self) -> &[SequenceStep<T>]

pub fn sample(self, window: &mut Window, cx: &mut App) -> SequenceSample<T>

Samples the sequence and requests a frame while a step is active.

Trait Implementations

impl<T: Clone> Clone for Sequence<T>

fn clone(&self) -> Sequence<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.