Trait IntoAnimate

pub trait IntoAnimate:
    Sized
    + Send
    + Sync {
    type Animate: Animate;

    // Required method
    fn into_animate(self) -> Self::Animate;

    // Provided methods
    fn to_animate(&self) -> Self::Animate
       where Self: Clone { ... }
    fn and_then<Other: IntoAnimate>(self, other: Other) -> Chain<Self, Other> { ... }
    fn cycle(self) -> Cycle<Self>
       where Self: Clone { ... }
    fn repeat(self, times: usize) -> Cycle<Self>
       where Self: Clone { ... }
    fn on_complete<F>(self, on_complete: F) -> OnCompleteAnimation<Self>
       where F: FnOnce() + Send + Sync + 'static { ... }
}

A type that can be converted into an animation.

Required Associated Types

type Animate: Animate

The running animation type.

Required Methods

fn into_animate(self) -> Self::Animate

Return this change as a running animation.

Provided Methods

fn to_animate(&self) -> Self::Animate

where Self: Clone,

Returns a clone of this change as a running animation.

fn and_then<Other: IntoAnimate>(self, other: Other) -> Chain<Self, Other>

Returns an combined animation that performs self and other in sequence.

fn cycle(self) -> Cycle<Self>

where Self: Clone,

Returns an animation that repeats self indefinitely.

fn repeat(self, times: usize) -> Cycle<Self>

where Self: Clone,

Returns an animation that repeats a number of times before completing.

fn on_complete<F>(self, on_complete: F) -> OnCompleteAnimation<Self>

where F: FnOnce() + Send + Sync + 'static,

Invokes on_complete after this animation finishes.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl IntoAnimate for Duration

type Animate = Duration

fn into_animate(self) -> Self::Animate

impl<T0> IntoAnimate for (T0,)

where T0: IntoAnimate,

type Animate = (<T0 as IntoAnimate>::Animate,)

fn into_animate(self) -> Self::Animate

impl<T0, T1> IntoAnimate for (T0, T1)

where T0: IntoAnimate, T1: IntoAnimate,

type Animate = (<T0 as IntoAnimate>::Animate, <T1 as IntoAnimate>::Animate)

fn into_animate(self) -> Self::Animate

impl<T0, T1, T2> IntoAnimate for (T0, T1, T2)

where T0: IntoAnimate, T1: IntoAnimate, T2: IntoAnimate,

type Animate = (<T0 as IntoAnimate>::Animate, <T1 as IntoAnimate>::Animate, <T2 as IntoAnimate>::Animate)

fn into_animate(self) -> Self::Animate

impl<T0, T1, T2, T3> IntoAnimate for (T0, T1, T2, T3)

where T0: IntoAnimate, T1: IntoAnimate, T2: IntoAnimate, T3: IntoAnimate,

type Animate = (<T0 as IntoAnimate>::Animate, <T1 as IntoAnimate>::Animate, <T2 as IntoAnimate>::Animate, <T3 as IntoAnimate>::Animate)

fn into_animate(self) -> Self::Animate

impl<T0, T1, T2, T3, T4> IntoAnimate for (T0, T1, T2, T3, T4)

where T0: IntoAnimate, T1: IntoAnimate, T2: IntoAnimate, T3: IntoAnimate, T4: IntoAnimate,

type Animate = (<T0 as IntoAnimate>::Animate, <T1 as IntoAnimate>::Animate, <T2 as IntoAnimate>::Animate, <T3 as IntoAnimate>::Animate, <T4 as IntoAnimate>::Animate)

fn into_animate(self) -> Self::Animate

impl<T0, T1, T2, T3, T4, T5> IntoAnimate for (T0, T1, T2, T3, T4, T5)

where T0: IntoAnimate, T1: IntoAnimate, T2: IntoAnimate, T3: IntoAnimate, T4: IntoAnimate, T5: IntoAnimate,

type Animate = (<T0 as IntoAnimate>::Animate, <T1 as IntoAnimate>::Animate, <T2 as IntoAnimate>::Animate, <T3 as IntoAnimate>::Animate, <T4 as IntoAnimate>::Animate, <T5 as IntoAnimate>::Animate)

fn into_animate(self) -> Self::Animate

Implementors

impl IntoAnimate for SharedCallback

type Animate = SharedCallback

impl IntoAnimate for SharedCallback<Duration, ControlFlow<Duration>>

type Animate = SharedCallback<Duration, ControlFlow<Duration>>

impl<A> IntoAnimate for Cycle<A>

where A: IntoAnimate + Clone,

type Animate = Cycle<A>

impl<A> IntoAnimate for OnCompleteAnimation<A>

where A: IntoAnimate,

type Animate = OnCompleteAnimation<<A as IntoAnimate>::Animate>

impl<A, B> IntoAnimate for Chain<A, B>

where A: IntoAnimate, B: IntoAnimate,

type Animate = RunningChain<A, B>

impl<F> IntoAnimate for F

where F: FnMut(Duration) -> ControlFlow<Duration> + Send + Sync + 'static,

type Animate = F

impl<T, Easing> IntoAnimate for Animation<T, Easing>

where T: AnimationTarget, Easing: Easing,

type Animate = RunningAnimation<<T as AnimationTarget>::Running, Easing>