Trait cushy::animation::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.

Object Safety

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>