commonMain.io.nacular.doodle.animation.Animator.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of animation-js Show documentation
A pure Kotlin, UI framework for the Web
There is a newer version: 0.10.4
package io.nacular.doodle.animation

import io.nacular.doodle.animation.transition.FixedSpeedLinear
import io.nacular.doodle.animation.transition.FixedTimeLinear
import io.nacular.doodle.animation.transition.NoChange
import io.nacular.doodle.animation.transition.SpeedUpSlowDown
import io.nacular.doodle.animation.transition.Transition
import io.nacular.doodle.utils.Completable
import io.nacular.doodle.utils.Pool
import io.nacular.measured.units.InverseUnits
import io.nacular.measured.units.Measure
import io.nacular.measured.units.Time
import io.nacular.measured.units.Units
import io.nacular.measured.units.UnitsRatio
import io.nacular.measured.units.times
import kotlin.jvm.JvmName

/**
 * Created by Nicholas Eddy on 3/29/18.
 */
public class NoneUnit: Units("")

public val noneUnits: NoneUnit = NoneUnit()

@JvmName("fixedSpeedLinearNumber")
public fun  fixedSpeedLinear(speed: Measure>): (T, T) -> Transition = { _,end -> FixedSpeedLinear(1 * noneUnits * speed, end * noneUnits) }

@JvmName("fixedSpeedLinearUnit")
public fun  fixedSpeedLinear(speed: Measure>): (Measure, Measure) -> Transition = { _,end -> FixedSpeedLinear(speed, end) }

public fun  fixedTimeLinear(time: Measure): (T, T) -> Transition = { _,end -> FixedTimeLinear(time, end * noneUnits) }

public fun  fixedTimeLinearM(time: Measure): (Measure, Measure) -> Transition = { _,end -> FixedTimeLinear(time, end) }

public fun  speedUpSlowDown(time: Measure, accelerationFraction: Float = 0.5f): (T, T) -> Transition = { _,end -> SpeedUpSlowDown(time, end * noneUnits, accelerationFraction) }

public fun  speedUpSlowDownM(time: Measure, accelerationFraction: Float = 0.5f): (Measure, Measure) -> Transition = { _,end -> SpeedUpSlowDown(time, end, accelerationFraction) }

public fun  noChange (time: Measure): (T) -> Transition = { NoChange(time) }
public fun   noChangeM(time: Measure): (Measure) -> Transition = { NoChange(time) }


public interface Animation: Completable

public interface Animator {
    public interface Listener {
        public fun changed  (animator: Animator, animations: Set) {}
        public fun canceled (animator: Animator, animations: Set) {}
        public fun completed(animator: Animator, animations: Set) {}
    }

    public interface TransitionBuilder {
        public infix fun then(transition: Transition): TransitionBuilder

        public operator fun invoke(block: (T) -> Unit): Animation
    }

    public interface MeasureTransitionBuilder {
        public infix fun then(transition: Transition): MeasureTransitionBuilder

        public operator fun invoke(block: (Measure) -> Unit): Animation
    }

    public interface NumberRangeUsing {
        public infix fun using(transition: (start: T, end: T) -> Transition): TransitionBuilder
    }

    public interface NumberUsing {
        public infix fun using(transition: (start: T) -> Transition): TransitionBuilder
    }

    public interface MeasureRangeUsing {
        public infix fun using(transition: (start: Measure, end: Measure) -> Transition): MeasureTransitionBuilder
    }

    public interface MeasureUsing {
        public infix fun using(transition: (start: Measure) -> Transition): MeasureTransitionBuilder
    }

    public operator fun  invoke(range: Pair): NumberRangeUsing = object: NumberRangeUsing {
        override fun using(transition: (start: T, end: T) -> Transition) = range using transition
    }

    public operator fun  invoke(value: T): NumberUsing = object: NumberUsing {
        override fun using(transition: (start: T) -> Transition) = value using transition
    }

    public operator fun  invoke(range: Pair, Measure>): MeasureRangeUsing = object: MeasureRangeUsing {
        override fun using(transition: (start: Measure, end: Measure) -> Transition) = range using transition
    }

    public operator fun  invoke(value: Measure): MeasureUsing = object: MeasureUsing {
        override fun using(transition: (start: Measure) -> Transition) = value using transition
    }

    public infix fun  Pair.using(transition: (start: T, end: T) -> Transition): TransitionBuilder
    public infix fun  T.using(transition: (start: T) -> Transition): TransitionBuilder
    public infix fun   Pair, Measure>.using(transition: (start: Measure, end: Measure) -> Transition): MeasureTransitionBuilder
    public infix fun   Measure.using(transition: (start: Measure) -> Transition): MeasureTransitionBuilder

    public operator fun invoke(block: Animator.() -> Unit): Completable

    public val listeners: Pool
}