Struct AnimationController 

pub struct AnimationController { /* private fields */ }

The shared animation layer — physics, curves, driver — see frus_core::animation. Re-exported here so applications can reach it through frus_widgets without depending on frus-core directly. Drives a value bounded to [lower, upper] through a pluggable simulation.

Implementations

impl AnimationController

pub fn new(lower: f32, upper: f32) -> AnimationController

A controller bounding its value to [lower, upper], starting at lower.

pub fn unit() -> AnimationController

The standard controller over [0, 1].

pub fn bounds(&self) -> (f32, f32)

The controller’s [lower, upper] bounds.

pub fn value(&self) -> f32

The current value.

pub fn velocity(&self) -> f32

The current velocity, in units per second.

pub fn status(&self) -> Status

The current status.

pub fn is_animating(&self) -> bool

true while a simulation is running, meaning a frame is needed.

pub fn set_value(&mut self, value: f32)

Sets the value immediately, with no animation, and updates the status.

pub fn reset(&mut self)

Puts the value back to the lower bound, unanimated (set_value(lower)).

pub fn stop(&mut self)

Stops any animation, a AnimationController::repeat loop included, and freezes the current value.

pub fn forward(&mut self, duration: f32, curve: Curve)

Animates to the upper bound over duration seconds, along curve.

pub fn reverse(&mut self, duration: f32, curve: Curve)

Animates to the lower bound over duration seconds, along curve.

pub fn animate_to(&mut self, target: f32, duration: f32, curve: Curve)

Animates the current value towards target over duration seconds. This cancels any repeat loop, making it a one-shot animation.

pub fn repeat(&mut self, period: f32, reverse: bool, curve: Curve)

Repeats the animation in a loop, each cycle lasting period seconds and shaped by curve. With reverse it goes there and back (0→1→0…); otherwise each cycle restarts from the bottom (0→1, 0→1…). It only ends at stop, or set_value / animate_to. This is the idiom for continuous driven animations: a pulse, a busy indicator, a halo.

pub fn fling(&mut self, velocity: f32)

Launches a physical fling: a critical spring started by velocity, settling on the position, bounded to [lower, upper].

pub fn spring_to( &mut self, target: f32, spring: SpringDescription, velocity: f32, )

Animates the current value towards target with a spring described by spring, started at velocity (units/s). This is the path taken by interruptible, gesture-driven transitions — a drag release, a back gesture carried by the finger’s momentum: the spring starts from the current position and the current velocity.

pub fn drive(&mut self, simulation: Box<dyn Simulation>, heading_up: bool)

Drives an arbitrary simulation — scroll momentum, a bespoke curve.

pub fn tick(&mut self, dt: f32) -> bool

Advances the animation by dt seconds, updating value, velocity and status. Returns true while the animation continues, meaning another frame is due.

Trait Implementations

impl Default for AnimationController

fn default() -> AnimationController

A standard controller over [0, 1], at rest at 0.