love.yinlin.compose.core/love.yinlin.compose.extension

Package-level declarations

Types

GoogleCreativeConsistencyAPI

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.FUNCTION])

annotation class GoogleCreativeConsistencyAPI

google的API大概就是这么保持一致的吧 ❤️

LazyStateReference

class LazyStateReference<T : Any> : BaseLazyReference<T>

MutableBiasAlignmentState

@Stable

interface MutableBiasAlignmentState : MutableState<BiasAlignment>

MutableColorState

@Stable

interface MutableColorState : MutableState<Color>

MutableDpOffsetState

@Stable

interface MutableDpOffsetState : MutableState<DpOffset>

MutableDpSizeState

@Stable

interface MutableDpSizeState : MutableState<DpSize>

MutableDpState

@Stable

interface MutableDpState : MutableState<Dp>

MutableIntOffsetState

@Stable

interface MutableIntOffsetState : MutableState<IntOffset>

MutableIntSizeState

@Stable

interface MutableIntSizeState : MutableState<IntSize>

MutableOffsetState

@Stable

interface MutableOffsetState : MutableState<Offset>

MutableSizeState

@Stable

interface MutableSizeState : MutableState<Size>

Functions

cramerCenter

fun Offset.Companion.cramerCenter(pos1: Offset, pos2: Offset, pos3: Offset, pos4: Offset): Offset

distance

fun Offset.distance(other: Offset): Float

flipX

fun DrawTransform.flipX(pivot: Offset = center)

flipY

fun DrawTransform.flipY(pivot: Offset = center)

localComposition

inline fun <T> localComposition(): ProvidableCompositionLocal<T>

fun <T> localComposition(default: () -> T): ProvidableCompositionLocal<T>

localRefComposition

inline fun <T> localRefComposition(): ProvidableCompositionLocal<T>

fun <T> localRefComposition(default: () -> T): ProvidableCompositionLocal<T>

movableComposable

@JvmName(name = "movableComposable0")

fun <R> R.movableComposable(content: @Composable R.() -> Unit): @Composable R.() -> Unit

@JvmName(name = "movableComposable1")

fun <R, T1> R.movableComposable(content: @Composable R.(T1) -> Unit): @Composable R.(T1) -> Unit

@JvmName(name = "movableComposable2")

fun <R, T1, T2> R.movableComposable(content: @Composable R.(T1, T2) -> Unit): @Composable R.(T1, T2) -> Unit

@JvmName(name = "movableComposable3")

fun <R, T1, T2, T3> R.movableComposable(content: @Composable R.(T1, T2, T3) -> Unit): @Composable R.(T1, T2, T3) -> Unit

mutableBiasAlignmentStateOf

@StateFactoryMarker

fun mutableBiasAlignmentStateOf(value: BiasAlignment): MutableBiasAlignmentState

mutableColorStateOf

@StateFactoryMarker

fun mutableColorStateOf(value: Color): MutableColorState

mutableDpOffsetStateOf

@StateFactoryMarker

fun mutableDpOffsetStateOf(value: DpOffset): MutableDpOffsetState

mutableDpSizeStateOf

@StateFactoryMarker

@GoogleCreativeConsistencyAPI

fun mutableDpSizeStateOf(value: DpSize): MutableDpSizeState

mutableDpStateOf

@StateFactoryMarker

fun mutableDpStateOf(value: Dp): MutableDpState

mutableIntOffsetStateOf

@StateFactoryMarker

fun mutableIntOffsetStateOf(value: IntOffset): MutableIntOffsetState

mutableIntSizeStateOf

@StateFactoryMarker

@GoogleCreativeConsistencyAPI

fun mutableIntSizeStateOf(value: IntSize): MutableIntSizeState

mutableOffsetStateOf

@StateFactoryMarker

fun mutableOffsetStateOf(value: Offset): MutableOffsetState

mutableRefStateOf

fun <T> mutableRefStateOf(value: T): MutableState<T>

mutableSizeStateOf

@StateFactoryMarker

fun mutableSizeStateOf(value: Size): MutableSizeState

onCenter

fun Offset.onCenter(other: Offset): Offset

onLine

fun Offset.onLine(other: Offset, ratio: Float): Offset

Path

fun Path(positions: Array<Offset>): Path

rememberBiasAlignmentState

@Composable

inline fun rememberBiasAlignmentState(vararg keys: Any?, crossinline init: () -> BiasAlignment): MutableBiasAlignmentState

rememberColorState

@Composable

inline fun rememberColorState(vararg keys: Any?, crossinline init: () -> Color): MutableColorState

rememberDerivedState

@Composable

fun <T> rememberDerivedState(calculation: () -> T): State<T>

@Composable

fun <T> rememberDerivedState(key1: Any?, calculation: () -> T): State<T>

@Composable

fun <T> rememberDerivedState(vararg keys: Any?, calculation: () -> T): State<T>

@Composable

fun <T> rememberDerivedState(key1: Any?, key2: Any?, calculation: () -> T): State<T>

@Composable

fun <T> rememberDerivedState(key1: Any?, key2: Any?, key3: Any?, calculation: () -> T): State<T>

rememberDoubleState

@Composable

inline fun rememberDoubleState(vararg keys: Any?, crossinline init: () -> Double): MutableDoubleState

rememberDpOffsetState

@Composable

inline fun rememberDpOffsetState(vararg keys: Any?, crossinline init: () -> DpOffset): MutableDpOffsetState

rememberDpSizeState

@Composable

inline fun rememberDpSizeState(vararg keys: Any?, crossinline init: () -> DpSize): MutableDpSizeState

rememberDpState

@Composable

inline fun rememberDpState(vararg keys: Any?, crossinline init: () -> Dp): MutableDpState

rememberFalse

@Composable

fun rememberFalse(vararg keys: Any?): MutableState<Boolean>

rememberFloatState

@Composable

inline fun rememberFloatState(vararg keys: Any?, crossinline init: () -> Float): MutableFloatState

rememberIntOffsetState

@Composable

inline fun rememberIntOffsetState(vararg keys: Any?, crossinline init: () -> IntOffset): MutableIntOffsetState

rememberIntSizeState

@Composable

inline fun rememberIntSizeState(vararg keys: Any?, crossinline init: () -> IntSize): MutableIntSizeState

rememberIntState

@Composable

inline fun rememberIntState(vararg keys: Any?, crossinline init: () -> Int): MutableIntState

rememberLongState

@Composable

inline fun rememberLongState(vararg keys: Any?, crossinline init: () -> Long): MutableLongState

rememberMovableContent

@Composable

@JvmName(name = "rememberMovableContent0")

fun rememberMovableContent(content: @Composable () -> Unit): @Composable () -> Unit

@Composable

@JvmName(name = "rememberMovableContent1")

fun <T1> rememberMovableContent(content: @Composable (T1) -> Unit): @Composable (T1) -> Unit

@Composable

@JvmName(name = "rememberMovableContent2")

fun <T1, T2> rememberMovableContent(content: @Composable (T1, T2) -> Unit): @Composable (T1, T2) -> Unit

@Composable

@JvmName(name = "rememberMovableContent3")

fun <T1, T2, T3> rememberMovableContent(content: @Composable (T1, T2, T3) -> Unit): @Composable (T1, T2, T3) -> Unit

@Composable

@JvmName(name = "rememberMovableContent4")

fun <T1, T2, T3, T4> rememberMovableContent(content: @Composable (T1, T2, T3, T4) -> Unit): @Composable (T1, T2, T3, T4) -> Unit

rememberNull

@Composable

inline fun <T> rememberNull(vararg keys: Any?): MutableState<T?>

rememberOffsetState

@Composable

inline fun rememberOffsetState(vararg keys: Any?, crossinline init: () -> Offset): MutableOffsetState

rememberRefNull

@Composable

inline fun <T> rememberRefNull(vararg keys: Any?): MutableState<T?>

rememberRefState

@Composable

inline fun <T> rememberRefState(crossinline init: () -> T): MutableState<T>

@Composable

inline fun <T> rememberRefState(key1: Any?, crossinline init: () -> T): MutableState<T>

@Composable

inline fun <T> rememberRefState(vararg keys: Any?, crossinline init: () -> T): MutableState<T>

@Composable

inline fun <T> rememberRefState(key1: Any?, key2: Any?, crossinline init: () -> T): MutableState<T>

@Composable

inline fun <T> rememberRefState(key1: Any?, key2: Any?, key3: Any?, crossinline init: () -> T): MutableState<T>

rememberSizeState

@Composable

inline fun rememberSizeState(vararg keys: Any?, crossinline init: () -> Size): MutableSizeState

rememberState

@Composable

inline fun <T> rememberState(crossinline init: () -> T): MutableState<T>

@Composable

inline fun <T> rememberState(key1: Any?, crossinline init: () -> T): MutableState<T>

@Composable

inline fun <T> rememberState(vararg keys: Any?, crossinline init: () -> T): MutableState<T>

@Composable

inline fun <T> rememberState(key1: Any?, key2: Any?, crossinline init: () -> T): MutableState<T>

@Composable

inline fun <T> rememberState(key1: Any?, key2: Any?, key3: Any?, crossinline init: () -> T): MutableState<T>

rememberTrue

@Composable

fun rememberTrue(vararg keys: Any?): MutableState<Boolean>

rememberValueState

@Composable

fun rememberValueState(value: BiasAlignment, vararg keys: Any?): MutableBiasAlignmentState

@Composable

fun rememberValueState(value: Offset, vararg keys: Any?): MutableOffsetState

@Composable

fun rememberValueState(value: Size, vararg keys: Any?): MutableSizeState

@Composable

fun rememberValueState(value: Color, vararg keys: Any?): MutableColorState

@Composable

fun rememberValueState(value: Dp, vararg keys: Any?): MutableDpState

@Composable

fun rememberValueState(value: DpOffset, vararg keys: Any?): MutableDpOffsetState

@Composable

fun rememberValueState(value: DpSize, vararg keys: Any?): MutableDpSizeState

@Composable

fun rememberValueState(value: IntOffset, vararg keys: Any?): MutableIntOffsetState

@Composable

fun rememberValueState(value: IntSize, vararg keys: Any?): MutableIntSizeState

@Composable

fun rememberValueState(value: Double, vararg keys: Any?): MutableDoubleState

@Composable

fun rememberValueState(value: Float, vararg keys: Any?): MutableFloatState

@Composable

fun rememberValueState(value: Int, vararg keys: Any?): MutableIntState

@Composable

fun rememberValueState(value: Long, vararg keys: Any?): MutableLongState

roundToIntOffset

fun Offset.roundToIntOffset(): IntOffset

scale

fun Offset.scale(dx: Float = 1.0f, dy: Float = 1.0f): Offset

fun Size.scale(dx: Float = 1.0f, dy: Float = 1.0f): Size

fun DrawTransform.scale(ratio: Float, pivot: Offset = center)

slope

fun Offset.slope(other: Offset): Float

staticLocalComposition

inline fun <T> staticLocalComposition(): ProvidableCompositionLocal<T>

fun <T> staticLocalComposition(default: () -> T): ProvidableCompositionLocal<T>

toMutableStateMap

fun <K, V> Map<K, V>.toMutableStateMap(): SnapshotStateMap<K, V>

translate

fun DrawTransform.translate(offset: Offset)

fun Offset.translate(x: Float = 0.0f, y: Float = 0.0f): Offset

fun Size.translate(x: Float = 0.0f, y: Float = 0.0f): Size