Low-level animation for values T that can be converted to numeric values using a AnimationDataConverter. This type is used by higher-level APIs like animation and can be created using tween for tween animations that leverage EasingFunctions.

RepetitionType

enum RepetitionType : Enum<RepetitionType>

Defines the kind of repetition an animation can have

SingleDataConverter

interface SingleDataConverter<T> : AnimationDataConverter<T, Double>

AnimationDataConverter that maps values T to Double.

Velocity

class Velocity<T>(val change: T, val over: Measure<Time>)

Defines how quickly T is changing over a period of time

Properties

animationConverter

val <T : Units> T.animationConverter: SingleDataConverter<Measure<T>>

Animation converter for a Measure.

val Color.Companion.animationConverter: MultiDataConverter<Color>

Animation converter for Color that allows its red, blue and green components to animate.

val Point.Companion.animationConverter: MultiDataConverter<Point>

Animation converter for Point that allows x and y to animate.

val Rectangle.Companion.animationConverter: MultiDataConverter<Rectangle>

Animation converter for Rectangle that allows x, y, width and height to animate.

val Size.Companion.animationConverter: MultiDataConverter<Size>

Animation converter for Size that allows width and height to animate.

val Double.Companion.animationConverter: SingleDataConverter<Double>

Animation converter for Double.

val Float.Companion.animationConverter: SingleDataConverter<Float>

Animation converter for Float.

val Int.Companion.animationConverter: SingleDataConverter<Int>

Animation converter for Int.

Functions

animatingProperty

fun <V, T> animatingProperty(default: T, animator: Animator, animation: (start: T, end: T) -> AnimationPlan<T>, onChanged: (old: T, new: T) -> Unit = { _,_ -> }): ReadWriteProperty<V, T>

Creates a ReadWriteProperty that will animate to new values.

animation

fun <T, V> animation(start: T, end: T, animationPlan: NumericAnimationPlan<T, V>, initialVelocity: Velocity<T>? = null): AnimationPlan<T>

Creates an animation based on animationPlan that goes from start to end. This allows the animation of any T that can be animated using a NumericAnimationPlan.

invoke

operator fun <V, T, K> Animator.invoke(default: T, using: NumericAnimationPlan<T, K>, onChanged: (old: T, new: T) -> Unit = { _,_ -> }): ReadWriteProperty<V, T>

Defines a property that can be animated using the given animation.

operator fun <T, V> Animator.invoke(range: Pair<T, T>, using: NumericAnimationPlan<T, V>, onChanged: (T) -> Unit): Animation<T>

Starts an animation from range.first to range.second.

keyFrames

@JvmName(name = "keyFramesMulti")

fun <T> keyFrames(converter: MultiDataConverter<T>, duration: Measure<Time>, delay: Measure<Time> = zeroMillis, frames: KeyFrameBlock<T>.() -> Unit): FiniteNumericAnimationPlan<T, Array<Double>>

Creates an animation that manipulates values of type T that are convertable to an array of Double. Each dimension of T will be animated using the definitions within frames.

@JvmName(name = "keyFramesSingle")

fun <T> keyFrames(converter: SingleDataConverter<T>, duration: Measure<Time>, delay: Measure<Time> = zeroMillis, frames: KeyFrameBlock<T>.() -> Unit): FiniteNumericAnimationPlan<T, Double>

Creates an animation that manipulates values of type T that are convertable to a Double.

keyFramesColor

fun keyFramesColor(duration: Measure<Time>, delay: Measure<Time> = zeroMillis, frames: KeyFrameBlock<Color>.() -> Unit): FiniteNumericAnimationPlan<Color, Array<Double>>

keyFramesDouble

fun keyFramesDouble(duration: Measure<Time>, delay: Measure<Time> = zeroMillis, frames: KeyFrameBlock<Double>.() -> Unit): FiniteNumericAnimationPlan<Double, Double>

keyFramesFloat

fun keyFramesFloat(duration: Measure<Time>, delay: Measure<Time> = zeroMillis, frames: KeyFrameBlock<Float>.() -> Unit): FiniteNumericAnimationPlan<Float, Double>

keyFramesInt

fun keyFramesInt(duration: Measure<Time>, delay: Measure<Time> = zeroMillis, frames: KeyFrameBlock<Int>.() -> Unit): FiniteNumericAnimationPlan<Int, Double>

keyFramesPoint

fun keyFramesPoint(duration: Measure<Time>, delay: Measure<Time> = zeroMillis, frames: KeyFrameBlock<Point>.() -> Unit): FiniteNumericAnimationPlan<Point, Array<Double>>

keyFramesRect

fun keyFramesRect(duration: Measure<Time>, delay: Measure<Time> = zeroMillis, frames: KeyFrameBlock<Rectangle>.() -> Unit): FiniteNumericAnimationPlan<Rectangle, Array<Double>>

keyFramesSize

fun keyFramesSize(duration: Measure<Time>, delay: Measure<Time> = zeroMillis, frames: KeyFrameBlock<Size>.() -> Unit): FiniteNumericAnimationPlan<Size, Array<Double>>

loop

@JvmName(name = "loopMulti")

fun <T> loop(animationPlan: FiniteNumericAnimationPlan<T, Array<Double>>, type: RepetitionType = Restart, delay: Measure<Time> = zeroMillis): NumericAnimationPlan<T, Array<Double>>

@JvmName(name = "loopSingle")

fun <T> loop(animationPlan: FiniteNumericAnimationPlan<T, Double>, type: RepetitionType = Restart, delay: Measure<Time> = zeroMillis): NumericAnimationPlan<T, Double>

Loops the given animationPlan indefinitely.

repeat

@JvmName(name = "repeatMulti")

fun <T> repeat(animationPlan: FiniteNumericAnimationPlan<T, Array<Double>>, times: Int = 1, type: RepetitionType = Restart, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<T, Array<Double>>

@JvmName(name = "repeatSingle")

fun <T> repeat(animationPlan: FiniteNumericAnimationPlan<T, Double>, times: Int = 1, type: RepetitionType = Restart, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<T, Double>

Repeats the given animationPlan for the specified number of times.

tween

fun <T> tween(converter: MultiDataConverter<T>, easings: (dimension: Int) -> Easing, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<T, Array<Double>>

Creates an animation that manipulates values of type T that are convertable to an array of Double. Each dimension of T will be animated using a Easing returned by the easings function.

fun <T : Units> tween(units: T, easing: EasingFunction, duration: Measure<Time>, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Measure<T>, Double>

fun <T> tween(converter: SingleDataConverter<T>, easing: EasingFunction, duration: Measure<Time>, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<T, Double>

Creates an animation that manipulates values of type T that are convertable to Double.

tweenColor

fun tweenColor(easings: (dimension: Int) -> Easing, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Color, Array<Double>>

fun tweenColor(easing: EasingFunction, duration: Measure<Time>, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Color, Array<Double>>

tweenDouble

fun tweenDouble(easing: EasingFunction, duration: Measure<Time>, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Double, Double>

tweenFloat

fun tweenFloat(easing: EasingFunction, duration: Measure<Time>, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Float, Double>

tweenInt

fun tweenInt(easing: EasingFunction, duration: Measure<Time>, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Int, Double>

tweenPoint

fun tweenPoint(easings: (dimension: Int) -> Easing, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Point, Array<Double>>

fun tweenPoint(easing: EasingFunction, duration: Measure<Time>, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Point, Array<Double>>

tweenRect

fun tweenRect(easings: (dimension: Int) -> Easing, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Rectangle, Array<Double>>

fun tweenRect(easing: EasingFunction, duration: Measure<Time>, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Rectangle, Array<Double>>

tweenSize

fun tweenSize(easings: (dimension: Int) -> Easing, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Size, Array<Double>>

fun tweenSize(easing: EasingFunction, duration: Measure<Time>, delay: Measure<Time> = zeroMillis): FiniteNumericAnimationPlan<Size, Array<Double>>