Struct PropertyTransition 

pub struct PropertyTransition<K: TransitionValueKind>
where
    K::Inner: Copy + PartialEq,
{ /* private fields */ }

Tracks one visual property and starts a transition when its target value changes.

The first observed value becomes the stable target baseline and does not start an animation. Later different values register a two-keyframe animation from the previous visual result to the new target value.

use aura_anim_iced::{
    AnimationRuntime, AnimationTargetId, Duration, OPACITY, PropertyTransition,
    PropertyValue, Timing,
};

let mut runtime = AnimationRuntime::testing();
let target = AnimationTargetId::new();
let mut opacity = PropertyTransition::new(target, OPACITY)
    .with_timing(Timing::new(100.0));

opacity.transition_to(&mut runtime, 0.0);
let first = opacity.transition_to(&mut runtime, 1.0).unwrap();

runtime.clock_mut().set_now(Duration::from_millis(40.0));
runtime.tick();

// Retargeting starts from the active animation's sampled visual value.
let retargeted = opacity.retarget_to(&mut runtime, 0.25).unwrap();
assert_eq!(retargeted.replaced(), Some(first.handle()));

let start = retargeted.registration().properties().unwrap();
let entry = start.find_property(&OPACITY.raw()).unwrap();
assert!(matches!(entry.value(), PropertyValue::Scalar(value) if (*value - 0.4).abs() < 0.001));

Implementations

impl<K> PropertyTransition<K>

where K: TransitionValueKind, K::Inner: Copy + PartialEq,

pub fn new(target: AnimationTargetId, property: PropertySpec<K>) -> Self

Creates a property transition tracker with default timing.

pub const fn from_rule( target: AnimationTargetId, rule: &BehaviorRule<K>, ) -> Self

Creates a property transition tracker from a reusable behavior rule.

pub const fn with_timing(self, timing: Timing) -> Self

Replaces the timing used for newly registered transitions.

pub const fn target(&self) -> AnimationTargetId

Returns the target that receives transition animations.

pub const fn property(&self) -> PropertySpec<K>

Returns the tracked property.

pub const fn timing(&self) -> Timing

Returns the timing used for newly registered transitions.

pub const fn current_value(&self) -> Option<K::Inner>

Returns the last target value observed by this tracker.

pub const fn active_handle(&self) -> Option<AnimationHandle>

Returns the active runtime handle created by this tracker, if any.

pub fn is_active<C: AnimationClock>( &self, runtime: &AnimationRuntime<C>, ) -> bool

Returns whether this tracker currently owns a runtime animation handle.

pub fn handle_completion<C: AnimationClock>( &mut self, runtime: &AnimationRuntime<C>, ) -> bool

Clears this tracker’s active handle when it appears in completed output.

Returns true when this transition handled its own completion.

pub const fn active_transition(&self) -> Option<&ActivePropertyTransition<K>>

Returns metadata for the active property transition, if any.

pub fn active_progress_at( &self, timestamp: Duration, ) -> Option<PropertyTransitionProgress<K>>

Returns sampled progress for the active transition at timestamp.

pub fn transition_to<C: AnimationClock>( &mut self, runtime: &mut AnimationRuntime<C>, value: K::Inner, ) -> Option<PropertyTransitionRegistration>

Observes a new target value and registers an animation when it changed.

Returns None when the value only seeded the baseline or did not change. If a previous transition is still running, the replacement starts from that transition’s last sampled visual value.

pub fn transition_from_visual<C: AnimationClock>( &mut self, runtime: &mut AnimationRuntime<C>, visual: K::Inner, value: K::Inner, ) -> Option<PropertyTransitionRegistration>

Observes a new target value with an explicit current visual value.

This is useful when application code already stores the rendered value from the latest tick. The registered animation starts from visual even if the previous target or runtime handle no longer represents what is currently on screen.

pub fn retarget_to<C: AnimationClock>( &mut self, runtime: &mut AnimationRuntime<C>, value: K::Inner, ) -> Option<PropertyTransitionRegistration>

Retargets a currently running transition to a new destination.

Returns None when there is no active runtime animation, the active handle is stale, or the new destination is already the current target. The replacement animation starts from the active animation’s last sampled visual value.

pub fn interrupt_from_visual<C: AnimationClock>( &mut self, runtime: &mut AnimationRuntime<C>, visual: K::Inner, value: K::Inner, ) -> Option<PropertyTransitionRegistration>

Interrupts the current transition and continues from an explicit visual value.

Unlike transition_from_visual, this method can replace an active animation even when value is already the current target. This is useful when an external interaction interrupts playback and application code wants the replacement animation to start from the exact value currently rendered on screen.

Trait Implementations

impl<K: Clone + TransitionValueKind> Clone for PropertyTransition<K>

where K::Inner: Copy + PartialEq + Clone,

fn clone(&self) -> PropertyTransition<K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug + TransitionValueKind> Debug for PropertyTransition<K>

where K::Inner: Copy + PartialEq + Debug,

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

Formats the value using the given formatter.

impl<K: PartialEq + TransitionValueKind> PartialEq for PropertyTransition<K>

where K::Inner: Copy + PartialEq + PartialEq,

fn eq(&self, other: &PropertyTransition<K>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K: TransitionValueKind> StructuralPartialEq for PropertyTransition<K>

where K::Inner: Copy + PartialEq,