Struct DirectTransition 

pub struct DirectTransition<T: StylePropValue> {
    pub current_value: T,
    /* private fields */
}

Direct transition controller using TransitionState without the Style system.

This allows you to animate any value that implements StylePropValue by managing the transition state directly. You control when transitions start, how they’re configured, and when to step them forward.

Example

use std::time::{Duration, Instant};
use floem::style::{DirectTransition, Transition};

// Create a transition for animating opacity
let mut opacity = DirectTransition::new(1., None);

// Configure transition timing and easing
opacity.set_transition(Some(
    Transition::ease_in_out(Duration::from_millis(300))
));

// Start transition to new value
opacity.transition_to(0.0);

// Animation loop - call this every frame
let start_time = Instant::now();
loop {
    let now = Instant::now();

    // Step the transition forward
    let changed = opacity.step(&now);

    // Get current interpolated value
    let current_opacity = opacity.get();

    // Only update rendering if value changed
    if changed {
        println!("Current opacity: {:.3}", current_opacity);
        // render_with_opacity(current_opacity);
    }

    // Exit when transition completes
    if !opacity.is_active() {
        println!("Transition complete!");
        break;
    }

    // Wait for next frame (~60fps)
    std::thread::sleep(Duration::from_millis(16));

    // Safety timeout
    if now.duration_since(start_time) > Duration::from_secs(2) {
        break;
    }
}

// Chain multiple transitions
opacity.transition_to(0.5); // Start new transition from current position
// ... repeat animation loop

// Or jump immediately without animation
opacity.set_immediate(1.0);

Fields

current_value: T

Implementations

impl<T: StylePropValue> DirectTransition<T>

pub fn new(initial_value: T, transition: Option<Transition>) -> Self

Create a new transition starting at the given value

pub fn set_transition(&mut self, transition: Option<Transition>)

Configure the transition timing and easing function

Pass None to disable transitions (values will change immediately)

pub fn transition_to(&mut self, target: T) -> bool

Start transitioning to a new target value

Returns true if a transition was started, false if no transition is configured or the target equals the current value

pub fn step(&mut self, now: &Instant) -> bool

Step the transition forward in time

Call this every frame with the current time. Returns true if the interpolated value changed this frame, false otherwise.

You can use the return value to optimize rendering - only update when something actually changed.

pub fn get(&self) -> T

Get the current interpolated value

During a transition, this returns the smoothly interpolated value. When no transition is active, returns the target value.

pub fn is_active(&self) -> bool

Check if a transition is currently active

pub fn target(&self) -> &T

Get the target value (final destination of current/last transition)

pub fn set_immediate(&mut self, value: T)

Set value immediately without any transition

This cancels any active transition and jumps directly to the new value

pub fn progress(&self, now: &Instant) -> Option<f64>

Get the progress of the current transition as a value from 0.0 to 1.0

Returns None if no transition is active or configured

Trait Implementations

impl<T: Clone + StylePropValue> Clone for DirectTransition<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + StylePropValue> Debug for DirectTransition<T>

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

Formats the value using the given formatter.