Struct Transition 

pub struct Transition<T: Interpolate> { /* private fields */ }

A value that animates toward whatever it is last told to be.

Retargeting starts from the value currently on screen rather than from the previous target, so an interrupted transition does not jump backward.

Implementations

impl<T: Interpolate> Transition<T>

pub fn new(value: T, spec: MotionSpec) -> Self

Starts settled at value, so a first render does not animate in.

pub fn spec(self, spec: MotionSpec) -> Self

pub fn target(&self) -> T

pub fn value(&self) -> T

pub fn is_animating(&self) -> bool

pub fn set(&mut self, target: T)

where T: PartialEq,

Aims at a new target. Setting the current target again is a no-op, so a render that re-declares the same value does not restart the animation.

A retarget hands the motion on rather than restarting it: the speed the value already had is measured, converted into the new distance, and released into the new motion. Without that, a target changed mid-flight stalls the value for the first few frames of the new run.

The speed keeps its direction, so reversing a target throws the value on the way it was already going before it comes back. Turning it round on the spot would be the stall this exists to remove, wearing a different shape.

pub fn release(&mut self, target: T, velocity: f32)

Aims at a new target with a speed the value did not get from an animation, which is what a value let go of by the hand has.

This is inertia. The gesture reports its speed — see VelocityTracker — and the spring is released with it rather than from a standstill, so a flicked thing carries on and settles instead of stopping dead the instant the finger leaves it. It is the same handover a retarget performs, with the speed coming from outside instead of from the motion being interrupted.

velocity is in value units a second and positive toward target. A release always restarts the motion, including at the current target: a value thrown at where it already is has somewhere to go and come back from.

Only a sprung specification can carry it. A curve has no momentum, so a released curve is an ordinary Transition::set.

pub fn snap(&mut self, target: T)

Jumps to target without animating, for state changes the user did not cause, such as a theme switch.

pub fn advance(&mut self, delta: Duration)

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

Advances by the time since the previous frame and schedules the next one while the transition is still running.

Honors reduced motion by finishing immediately, so a caller gets the final value without any intermediate frames.

Trait Implementations

impl<T: Clone + Interpolate> Clone for Transition<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Interpolate> Copy for Transition<T>

impl<T: Debug + Interpolate> Debug for Transition<T>

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

Formats the value using the given formatter.

impl<T: PartialEq + Interpolate> PartialEq for Transition<T>

fn eq(&self, other: &Transition<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq + Interpolate> StructuralPartialEq for Transition<T>