fun <T : Component> forEachComponentOfTypeRecursive(type: ComponentType<T>, temp: FastArrayList<Component>, results: EventResult?, block: (T) -> Unit)

get

operator fun get(index: Int): View

getBounds

fun getBounds(target: View?, out: Rectangle, doAnchoring: Boolean, inclusive: Boolean, includeFilters: Boolean): Rectangle

getBoundsNoAnchoring

fun getBoundsNoAnchoring(target: View?, out: Rectangle, inclusive: Boolean, includeFilters: Boolean): Rectangle

getChildAt

fun getChildAt(index: Int): View

getChildAtOrNull

fun getChildAtOrNull(index: Int): View?

getChildByName

fun getChildByName(name: String): View?

getChildIndex

fun getChildIndex(view: View): Int

getClippingAreaInternal

fun getClippingAreaInternal(): Rectangle?

getClippingBounds

fun getClippingBounds(ctx: RenderContext, out: Rectangle): Rectangle

getComponentCountInDescendants

fun getComponentCountInDescendants(clazz: ComponentType<out Component>): Int

getComponentOfTypeRecursive

fun <T : Component> getComponentOfTypeRecursive(type: ComponentType<T>, out: FastArrayList<T>, results: EventResult?)

getComponentsOfType

fun <T : Component> getComponentsOfType(type: ComponentType<T>): FastArrayList<T>?

getConcatMatrix

fun getConcatMatrix(target: View, out: Matrix, inclusive: Boolean): Matrix

getConcatMatrixAccurateSlow

fun getConcatMatrixAccurateSlow(target: View, out: Matrix, inclusive: Boolean): Matrix

getFirstComponentOfType

fun <T : TypedComponent<T>> getFirstComponentOfType(type: ComponentType<T>): T?

getGlobalBounds

fun getGlobalBounds(out: Rectangle): Rectangle

getGlobalMatrixWithAnchor

fun getGlobalMatrixWithAnchor(out: Matrix): Matrix

getLocalBounds

fun ~~getLocalBounds~~(doAnchoring: Boolean, includeFilters: Boolean): Rectangle

fun getLocalBounds(out: Rectangle, doAnchoring: Boolean, includeFilters: Boolean): Rectangle

getLocalBoundsInternal

open override fun getLocalBoundsInternal(out: Rectangle)

getLocalBoundsOptimized

fun getLocalBoundsOptimized(includeFilters: Boolean): Rectangle

getLocalBoundsOptimizedAnchored

fun getLocalBoundsOptimizedAnchored(includeFilters: Boolean): Rectangle

getOrCreateAndAddRenderPhase

inline fun <T : ViewRenderPhase> getOrCreateAndAddRenderPhase(create: () -> T): T

getOrCreateComponent

inline fun <T : TypedComponent<T>> getOrCreateComponent(type: ComponentType<T>, gen: (BaseView) -> T): T

getOrCreateComponentEvent

inline fun <T : EventComponent> getOrCreateComponentEvent(gen: (BaseView) -> T): T

getOrCreateComponentGamepad

inline fun <T : GamepadComponent> getOrCreateComponentGamepad(gen: (BaseView) -> T): T

getOrCreateComponentKey

inline fun <T : KeyComponent> getOrCreateComponentKey(gen: (BaseView) -> T): T

getOrCreateComponentMouse

inline fun <T : MouseComponent> getOrCreateComponentMouse(gen: (BaseView) -> T): T

getOrCreateComponentResize

inline fun <T : ResizeComponent> getOrCreateComponentResize(gen: (BaseView) -> T): T

getOrCreateComponentTouch

inline fun <T : TouchComponent> getOrCreateComponentTouch(gen: (BaseView) -> T): T

getOrCreateComponentTyped

inline fun <T : TypedComponent<T>, TR : T> getOrCreateComponentTyped(type: ComponentType<T>, gen: (BaseView) -> TR): TR

getOrCreateComponentUpdate

inline fun <T : UpdateComponent> getOrCreateComponentUpdate(gen: (BaseView) -> T): T

getOrCreateComponentUpdateWithViews

inline fun <T : UpdateComponentWithViews> getOrCreateComponentUpdateWithViews(gen: (BaseView) -> T): T

getPosition

fun getPosition(out: Point): Point

getProp

inline fun <T : Any> getProp(key: String): T

getPropDouble

fun getPropDouble(key: String, default: Double): Double

getPropInt

fun getPropInt(key: String, default: Int): Int

getPropOrNull

inline fun <T : Any> getPropOrNull(key: String): T?

getPropString

fun getPropString(key: String, default: String): String

getRenderPhaseOfTypeOrNull

inline fun <T : ViewRenderPhase> getRenderPhaseOfTypeOrNull(): T?

getRenderTargetBounds

fun getRenderTargetBounds(ctx: RenderContext, out: Rectangle): Rectangle

getWindowBounds

fun ~~getWindowBounds~~(out: Rectangle): Rectangle

fun getWindowBounds(bp: BoundsProvider, out: Rectangle): Rectangle

getWindowBoundsOrNull

fun getWindowBoundsOrNull(out: Rectangle): Rectangle?

globalLocalBoundsPointRatio

fun globalLocalBoundsPointRatio(anchor: Anchor, out: Point): Point

fun globalLocalBoundsPointRatio(ratioX: Double, ratioY: Double, out: Point): Point

globalToLocal

fun globalToLocal(p: IPoint, out: Point): Point

globalToLocalDX

fun globalToLocalDX(x0: Double, y0: Double, x1: Double, y1: Double): Double

globalToLocalDXY

fun globalToLocalDXY(p0: IPoint, p1: IPoint, out: Point): Point

fun globalToLocalDXY(x0: Double, y0: Double, x1: Double, y1: Double, out: Point): Point

globalToLocalDY

fun globalToLocalDY(x0: Double, y0: Double, x1: Double, y1: Double): Double

globalToLocalX

fun globalToLocalX(x: Double, y: Double): Double

globalToLocalXY

fun globalToLocalXY(x: Double, y: Double, out: Point): Point

globalToLocalY

fun globalToLocalY(x: Double, y: Double): Double

globalXY

fun globalXY(out: Point): Point

hasProp

fun hasProp(key: String): Boolean

hitTest

open fun hitTest(x: Double, y: Double, direction: HitTestDirection): View?

fun hitTest(x: Float, y: Float, direction: HitTestDirection): View?

fun hitTest(x: Int, y: Int, direction: HitTestDirection): View?

hitTestAny

fun hitTestAny(x: Double, y: Double): Boolean

open override fun hitTestAny(x: Double, y: Double, direction: HitTestDirection): Boolean

hitTestLocal

fun hitTestLocal(x: Double, y: Double, direction: HitTestDirection): View?

fun hitTestLocal(x: Float, y: Float, direction: HitTestDirection): View?

fun hitTestLocal(x: Int, y: Int, direction: HitTestDirection): View?

hitTestShape

fun hitTestShape(shape: Shape2d, matrix: Matrix, direction: HitTestDirection): View?

hitTestView

fun hitTestView(view: View, direction: HitTestDirection): View?

fun hitTestView(views: List<View>, direction: HitTestDirection): View?

invalidate

open override fun invalidate()

invalidateColorTransform

open override fun invalidateColorTransform()

invalidateMatrix

fun invalidateMatrix()

invalidateRender

open override fun invalidateRender()

localMouseX

fun localMouseX(views: Views): Double

localMouseXY

fun localMouseXY(views: Views, target: Point): Point

localMouseY

fun localMouseY(views: Views): Double

localToGlobal

fun localToGlobal(p: IPoint, out: Point): Point

localToGlobalX

fun localToGlobalX(x: Double, y: Double): Double

localToGlobalXY

fun localToGlobalXY(x: Double, y: Double, out: Point): Point

localToGlobalY

fun localToGlobalY(x: Double, y: Double): Double

localToRender

fun ~~localToRender~~(p: IPoint, out: Point): Point

localToRenderX

fun ~~localToRenderX~~(x: Double, y: Double): Double

localToRenderXY

fun ~~localToRenderXY~~(x: Double, y: Double, out: Point): Point

localToRenderY

fun ~~localToRenderY~~(x: Double, y: Double): Double

localToWindow

fun localToWindow(views: Views, p: IPoint, out: Point): Point

localToWindowX

fun localToWindowX(views: Views, x: Double, y: Double): Double

localToWindowXY

fun localToWindowXY(views: Views, x: Double, y: Double, out: Point): Point

localToWindowY

fun localToWindowY(views: Views, x: Double, y: Double): Double

localXY

fun localXY(out: Point): Point

minusAssign

operator fun minusAssign(view: View)

mouseHitTest

fun mouseHitTest(x: Double, y: Double): View?

fun mouseHitTest(x: Float, y: Float): View?

fun mouseHitTest(x: Int, y: Int): View?

move

open override fun move(direction: Direction)

moveChildrenAt

fun moveChildrenAt(from: Int, to: Int, count: Int)

moveChildTo

fun moveChildTo(view: View, index: Int)

movementUpdateCycle

fun movementUpdateCycle()

onParentChanged

open fun onParentChanged()

plusAssign

operator fun plusAssign(view: View)

removeAllComponents

fun removeAllComponents()

removeAllComponentsOfType

fun removeAllComponentsOfType(type: ComponentType<*>)

removeChild

fun removeChild(view: View?): Boolean

removeChildAt

fun removeChildAt(index: Int): Boolean

fun removeChildAt(index: Int, count: Int)

removeChildren

fun removeChildren()

removeChildrenIf

inline fun removeChildrenIf(cond: (index: Int, child: View) -> Boolean): Boolean

removeComponent

fun removeComponent(component: Component)

removeFromParent

fun removeFromParent()

removeRenderPhaseOfType

inline fun <T : ViewRenderPhase> removeRenderPhaseOfType()

render

override fun render(ctx: RenderContext)

renderChildrenInternal

open fun renderChildrenInternal(ctx: RenderContext)

renderDebug

open override fun renderDebug(ctx: RenderContext)

renderFirstPhase

fun renderFirstPhase(ctx: RenderContext)

renderNextPhase

fun renderNextPhase(ctx: RenderContext)

renderToLocal

fun renderToLocal(p: IPoint, out: Point): Point

renderToLocalX

fun renderToLocalX(x: Double, y: Double): Double

renderToLocalXY

fun renderToLocalXY(x: Double, y: Double, out: Point): Point

renderToLocalY

fun renderToLocalY(x: Double, y: Double): Double

replaceChild

fun replaceChild(old: View, new: View): Boolean

replaceRenderPhase

inline fun <T : ViewRenderPhase> replaceRenderPhase(create: () -> T)

reset

open fun reset()

sendChildToBack

fun sendChildToBack(view: View)

sendChildToFront

fun sendChildToFront(view: View)

setComputedTransform

fun setComputedTransform(transform: Matrix.Computed)

setGlobalXY

fun setGlobalXY(pos: Point)

fun setGlobalXY(x: Double, y: Double)

setMatrix

fun setMatrix(matrix: Matrix)

setMatrixInterpolated

fun setMatrixInterpolated(ratio: Double, l: Matrix, r: Matrix)

setSize

open fun setSize(width: Double, height: Double)

setSizeScaled

open fun setSizeScaled(width: Double, height: Double)

setTransform

fun setTransform(transform: Matrix.Transform)

sortChildrenBy

fun sortChildrenBy(comparator: Comparator<View>)

swapChildren

fun swapChildren(view1: View, view2: View)

swapChildrenAt

fun swapChildrenAt(indexA: Int, indexB: Int)

fun swapChildrenAt(indexA: Int, indexB: Int, count: Int)

Properties

alpha

var alpha: Double

anchorDispX

open val anchorDispX: Double

anchorDispY

open val anchorDispY: Double

blendMode

var blendMode: BlendMode

bview

open override val bview: View

bviewAll

open override val bviewAll: List<View>

children

val children: ContainerCollection

childrenCollection

val ~~childrenCollection~~: ContainerCollection

collection

val ~~collection~~: ContainerCollection

colorAdd

var ~~colorAdd~~: ColorAdd

colorMul

var colorMul: RGBA

colorTransform

var colorTransform: ColorTransform

containerRoot

val containerRoot: Container

customHitShape

open val customHitShape: Boolean

debugAnnotate

var debugAnnotate: Boolean

extra

open override var extra: ExtraType

extraBuildDebugComponent

var extraBuildDebugComponent: (views: Views, view: View, container: UiContainer) -> Unit?

firstChild

val firstChild: View?

globalBounds

val globalBounds: Rectangle

globalMatrix

var globalMatrix: Matrix

globalMatrixInv

val globalMatrixInv: Matrix

globalSpeed

val globalSpeed: Double

globalX

var globalX: Double

globalY

var globalY: Double

height

open var height: Double

hitShape

open var ~~hitShape~~: VectorPath?

hitShape2d

open override var hitShape2d: Shape2d

hitShapes

open var ~~hitShapes~~: List<VectorPath>?

hitTestEnabled

var hitTestEnabled: Boolean

hitTestUsingShapes

var hitTestUsingShapes: Boolean?

index

var index: Int

isContainer

val isContainer: Boolean

lastChild

val lastChild: View?

localMatrix

var localMatrix: Matrix

mouseChildren

open var mouseChildren: Boolean

mouseEnabled

open var mouseEnabled: Boolean

moving

open override var moving: Boolean = false

name

var name: String?

numChildren

val numChildren: Int

objectCanMove

var objectCanMove: Boolean = false

parent

var parent: Container?

pos

var pos: IPoint

posOpt

var posOpt: Point

preventMove

var preventMove: Boolean = false

propagateEvents

var propagateEvents: Boolean

props

val props: Map<String, Any?>

ratio

open var ratio: Double

referenceParent

val referenceParent: Container?

renderAlpha

val renderAlpha: Double

renderBlendMode

val renderBlendMode: BlendMode

renderColorAdd

val renderColorAdd: ColorAdd

renderColorMul

val renderColorMul: RGBA

renderColorTransform

val renderColorTransform: ColorTransform

renderPhases

val renderPhases: List<ViewRenderPhase>

val root: View

var rotation: Angle

var scale: Double

var scaledHeight: Double

scaledWidth

var scaledWidth: Double

var scaleX: Double

var scaleY: Double

val ~~size~~: Int

var skewX: Angle

var skewY: Angle

var speed: Double

open val stage: Stage?

tint

var tint: RGBA

unscaledHeight

val unscaledHeight: Double

unscaledWidth

val unscaledWidth: Double

visible

open var visible: Boolean

width

open var width: Double

windowBounds

val windowBounds: Rectangle

open override var x: Double

open override var y: Double

zIndex

var zIndex: Double

Extensions

block

inline fun Container.block(mainImage: BitmapSlice<Bitmap>, callback: Block.() -> Unit = {}): Block

player

inline fun Container.player(mainImage: Array<BitmapSlice<Bitmap>>, callback: Player.() -> Unit = {}): Player

Entities.player

wall

inline fun Container.wall(mainImage: BitmapSlice<Bitmap>, callback: Wall.() -> Unit = {}): Wall