core/com.nxoim.caif.core.base

Package-level declarations

Types

AbstractMutableAnimatedValue

abstract class AbstractMutableAnimatedValue<Value, Vector : AnimationVector>(converter: TwoWayConverter<Value, Vector>, zeroVelocity: Value, initialValue: Value, label: String = "AnimatedValue") : MutableAnimatedValue<Value>

Exists to mitigate Animatable's limitations regarding animating and snapping. The mitigations are based on manual management of publicly exposed state.

class AnimatedColor(initialValue: Color = Color.Transparent, colorSpace: ColorSpace = ColorSpaces.Srgb, label: String = "AnimatedColor") : AbstractMutableAnimatedValue<Color, AnimationVector4D>

class AnimatedDp(initialValue: Dp = 0.dp, label: String = "AnimatedDp") : AbstractMutableAnimatedValue<Dp, AnimationVector1D>

AnimatedDpOffset

class AnimatedDpOffset(initialValue: DpOffset = DpOffset.Zero, label: String = "AnimatedDpOffset") : AbstractMutableAnimatedValue<DpOffset, AnimationVector2D>

class AnimatedDpSize(initialValue: DpSize = DpSize.Zero, label: String = "AnimatedDpSize") : AbstractMutableAnimatedValue<DpSize, AnimationVector2D>

class AnimatedFloat(initialValue: Float = 0.0f, label: String = "AnimatedFloat") : AbstractMutableAnimatedValue<Float, AnimationVector1D>

class AnimatedInt(initialValue: Int = 0, label: String = "AnimatedInt") : AbstractMutableAnimatedValue<Int, AnimationVector1D>

AnimatedIntOffset

class AnimatedIntOffset(initialValue: IntOffset = IntOffset.Zero, label: String = "AnimatedIntOffset") : AbstractMutableAnimatedValue<IntOffset, AnimationVector2D>

AnimatedIntSize

class AnimatedIntSize(initialValue: IntSize = IntSize.Zero, label: String = "AnimatedIntSize") : AbstractMutableAnimatedValue<IntSize, AnimationVector2D>

class AnimatedOffset(initialValue: Offset = Offset.Zero, label: String = "AnimatedOffset") : AbstractMutableAnimatedValue<Offset, AnimationVector2D>

class AnimatedSize(initialValue: Size = Size.Zero, label: String = "AnimatedSize") : AbstractMutableAnimatedValue<Size, AnimationVector2D>

interface AnimatedValue<Value>

interface ColorState : State<Color>

interface DpOffsetState : State<DpOffset>

interface DpSizeState : State<DpSize>

interface DpState : State<Dp>

GenericMutableAnimatedValue

class GenericMutableAnimatedValue<Value, Vector : AnimationVector>(converter: TwoWayConverter<Value, Vector>, zeroVelocity: Value, initialValue: () -> Value, label: String = "AnimatedValue") : AbstractMutableAnimatedValue<Value, Vector>

interface IntOffsetState : State<IntOffset>

interface IntSizeState : State<IntSize>

MutableAnimatedValue

interface MutableAnimatedValue<Value> : AnimatedValue<Value>

MutableColorState

interface MutableColorState : ColorState, MutableState<Color>

MutableDpOffsetState

interface MutableDpOffsetState : DpOffsetState, MutableState<DpOffset>

MutableDpSizeState

interface MutableDpSizeState : DpSizeState, MutableState<DpSize>

interface MutableDpState : DpState, MutableState<Dp>

MutableIntOffsetState

interface MutableIntOffsetState : IntOffsetState, MutableState<IntOffset>

MutableIntSizeState

interface MutableIntSizeState : IntSizeState, MutableState<IntSize>

MutableOffsetState

interface MutableOffsetState : OffsetState, MutableState<Offset>

MutableSizeState

interface MutableSizeState : SizeState, MutableState<Size>

MutableVelocityState

interface MutableVelocityState : VelocityState, MutableState<Velocity>

interface OffsetState : State<Offset>

interface SizeState : State<Size>

TargetableMutableAnimatedValue

interface TargetableMutableAnimatedValue<Value, Context> : AnimatedValue<Value>

interface VelocityState : State<Velocity>

Functions

inline operator fun IntSizeState.getValue(thisObj: Any?, property: KProperty<*>): IntSize

mutableColorStateOf

fun mutableColorStateOf(value: Color): MutableColorState

@JvmName(name = "mutableColorStateOfLong")

fun mutableColorStateOf(value: Long): MutableColorState

@JvmName(name = "mutableColorStateOfRgba")

fun mutableColorStateOf(red: Int, green: Int, blue: Int, alpha: Int = 255): MutableColorState

mutableDpOffsetStateOf

fun mutableDpOffsetStateOf(value: DpOffset): MutableDpOffsetState

@JvmName(name = "mutableDpOffsetStateOfXy")

fun mutableDpOffsetStateOf(x: Dp, y: Dp): MutableDpOffsetState

mutableDpSizeStateOf

fun mutableDpSizeStateOf(value: DpSize): MutableDpSizeState

@JvmName(name = "mutableDpSizeStateOfWh")

fun mutableDpSizeStateOf(width: Dp, height: Dp): MutableDpSizeState

mutableDpStateOf

fun mutableDpStateOf(value: Dp): MutableDpState

mutableIntOffsetStateOf

fun mutableIntOffsetStateOf(value: IntOffset): MutableIntOffsetState

@JvmName(name = "mutableIntOffsetStateOfXy")

fun mutableIntOffsetStateOf(x: Int, y: Int): MutableIntOffsetState

mutableIntSizeStateOf

fun mutableIntSizeStateOf(value: IntSize): MutableIntSizeState

@JvmName(name = "mutableIntSizeStateOfWh")

fun mutableIntSizeStateOf(width: Int, height: Int): MutableIntSizeState

mutableOffsetStateOf

fun mutableOffsetStateOf(value: Offset): MutableOffsetState

@JvmName(name = "mutableOffsetStateOfXy")

fun mutableOffsetStateOf(x: Float, y: Float): MutableOffsetState

mutableSizeStateOf

fun mutableSizeStateOf(value: Size): MutableSizeState

@JvmName(name = "mutableSizeStateOfWh")

fun mutableSizeStateOf(width: Float, height: Float): MutableSizeState

mutableVelocityStateOf

fun mutableVelocityStateOf(value: Velocity): MutableVelocityState

@JvmName(name = "mutableVelocityStateOfXy")

fun mutableVelocityStateOf(x: Float, y: Float): MutableVelocityState

TargetableMutableAnimatedValue

fun <Value, Vector : AnimationVector, Context> TargetableMutableAnimatedValue(base: AbstractMutableAnimatedValue<Value, Vector>, valueMapper: Context.() -> Value, specFactory: Context.() -> AnimationSpec<Value>, stopOnTargetReached: Context.() -> Boolean? = null): TargetableMutableAnimatedValue<Value, Context>

toAnimatedValue

fun <Value> MutableAnimatedValue<Value>.toAnimatedValue(): AnimatedValue<Value>

fun <Value, Context> TargetableMutableAnimatedValue<Value, Context>.toAnimatedValue(): AnimatedValue<Value>