kyrie / com.github.alexjlockwood.kyrie / RenderNode / Builder

Builder

abstract class Builder<B : RenderNode.Builder<B>> : TransformNode.Builder<B>

Inherited Properties

pivotX

val pivotX: MutableList<Animation<*, Float>>

pivotY

val pivotY: MutableList<Animation<*, Float>>

rotation

val rotation: MutableList<Animation<*, Float>>

scaleX

val scaleX: MutableList<Animation<*, Float>>

scaleY

val scaleY: MutableList<Animation<*, Float>>

translateX

val translateX: MutableList<Animation<*, Float>>

translateY

val translateY: MutableList<Animation<*, Float>>

Functions

fillAlpha

fun fillAlpha(initialFillAlpha: Float): B
fun fillAlpha(vararg animations: Animation<*, Float>): B
fun fillAlpha(animations: List<Animation<*, Float>>): B

fillColor

fun fillColor(initialFillColor: Int): B
fun fillColor(vararg animations: Animation<*, Int>): B
fun fillColor(animations: List<Animation<*, Int>>): B
fun fillColor(colorStateList: ColorStateList?): B
fun fillColor(linearGradient: LinearGradient?): B
fun fillColor(radialGradient: RadialGradient?): B
fun fillColor(sweepGradient: SweepGradient?): B

fillType

fun fillType(fillType: FillType): B

scalingStroke

fun scalingStroke(isScalingStroke: Boolean): B

strokeAlpha

fun strokeAlpha(initialStrokeAlpha: Float): B
fun strokeAlpha(vararg animations: Animation<*, Float>): B
fun strokeAlpha(animations: List<Animation<*, Float>>): B

strokeColor

fun strokeColor(initialStrokeColor: Int): B
fun strokeColor(vararg animations: Animation<*, Int>): B
fun strokeColor(animations: List<Animation<*, Int>>): B
fun strokeColor(colorStateList: ColorStateList?): B
fun strokeColor(linearGradient: LinearGradient?): B
fun strokeColor(radialGradient: RadialGradient?): B
fun strokeColor(sweepGradient: SweepGradient?): B

strokeDashArray

fun strokeDashArray(initialStrokeDashArray: FloatArray?): B
fun strokeDashArray(vararg animations: Animation<*, FloatArray>): B
fun strokeDashArray(animations: List<Animation<*, FloatArray>>): B

strokeDashOffset

fun strokeDashOffset(initialStrokeDashOffset: Float): B
fun strokeDashOffset(vararg animations: Animation<*, Float>): B
fun strokeDashOffset(animations: List<Animation<*, Float>>): B

strokeLineCap

fun strokeLineCap(strokeLineCap: StrokeLineCap): B

strokeLineJoin

fun strokeLineJoin(strokeLineJoin: StrokeLineJoin): B

strokeMiterLimit

fun strokeMiterLimit(initialStrokeMiterLimit: Float): B
fun strokeMiterLimit(vararg animations: Animation<*, Float>): B
fun strokeMiterLimit(animations: List<Animation<*, Float>>): B

strokeWidth

fun strokeWidth(initialStrokeWidth: Float): B
fun strokeWidth(vararg animations: Animation<*, Float>): B
fun strokeWidth(animations: List<Animation<*, Float>>): B

trimPathEnd

fun trimPathEnd(initialTrimPathEnd: Float): B
fun trimPathEnd(vararg animations: Animation<*, Float>): B
fun trimPathEnd(animations: List<Animation<*, Float>>): B

trimPathOffset

fun trimPathOffset(initialTrimPathOffset: Float): B
fun trimPathOffset(vararg animations: Animation<*, Float>): B
fun trimPathOffset(animations: List<Animation<*, Float>>): B

trimPathStart

fun trimPathStart(initialTrimPathStart: Float): B
fun trimPathStart(vararg animations: Animation<*, Float>): B
fun trimPathStart(animations: List<Animation<*, Float>>): B

Inherited Functions

pivotX

fun pivotX(initialPivotX: Float): B
fun pivotX(vararg animations: Animation<*, Float>): B
fun pivotX(animations: List<Animation<*, Float>>): B

pivotY

fun pivotY(initialPivotY: Float): B
fun pivotY(vararg animations: Animation<*, Float>): B
fun pivotY(animations: List<Animation<*, Float>>): B

rotation

fun rotation(initialRotation: Float): B
fun rotation(vararg animations: Animation<*, Float>): B
fun rotation(animations: List<Animation<*, Float>>): B

scaleX

fun scaleX(initialScaleX: Float): B
fun scaleX(vararg animations: Animation<*, Float>): B
fun scaleX(animations: List<Animation<*, Float>>): B

scaleY

fun scaleY(initialScaleY: Float): B
fun scaleY(vararg animations: Animation<*, Float>): B
fun scaleY(animations: List<Animation<*, Float>>): B

translateX

fun translateX(initialTranslateX: Float): B
fun translateX(vararg animations: Animation<*, Float>): B
fun translateX(animations: List<Animation<*, Float>>): B

translateY

fun translateY(initialTranslateY: Float): B
fun translateY(vararg animations: Animation<*, Float>): B
fun translateY(animations: List<Animation<*, Float>>): B

Inheritors

Builder

class Builder : RenderNode.Builder<CircleNode.Builder>

Builder class used to create CircleNodes.

Builder

class Builder : RenderNode.Builder<EllipseNode.Builder>

Builder class used to create EllipseNodes.

Builder

class Builder : RenderNode.Builder<LineNode.Builder>

Builder class used to create LineNodes.

Builder

class Builder : RenderNode.Builder<PathNode.Builder>

Builder class used to create PathNodes.

Builder

class Builder : RenderNode.Builder<RectangleNode.Builder>

Builder class used to create RectangleNodes.