An optional Filter attached to this view. Filters allow to render this view to a texture, and to control how to render that texture (using shaders, repeating the texture, etc.). You add multiple filters by creating a composite filter ComposedFilter.

filterScale

var View.filterScale: Double

Usually a value between 0.0, 1.0

focusable

var View.focusable: UIFocusable?

frameHeight

override val frameHeight: Float

frameOffsetX

open val frameOffsetX: Float

frameOffsetY

open val frameOffsetY: Float

frameWidth

override val frameWidth: Float

gamepad

val View.gamepad: GamePadEvents

gestures

val View.gestures: GestureEvents

globalBounds

val globalBounds: Rectangle

Returns the global bounds of this object. Note this incurs in allocations. Use getGlobalBounds (out) to avoid it

globalMatrix

var globalMatrix: Matrix

Global transform Matrix. Matrix that concatenates all the affine transforms of this view and its ancestors.

globalMatrixInv

val globalMatrixInv: Matrix

The inverted version of the globalMatrix

globalPos

var globalPos: Point

globalSpeed

val globalSpeed: Double

Computed speed combining all the speeds from ancestors

height

var height: Double

Changes the height of this view. Generically, this means adjusting the scaleY of the view to match that size using the current bounds, but some views might override this to adjust its internal width or height (like SolidRect or UIView for example).

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?

ignoreStrokesForBounds

var ignoreStrokesForBounds: Boolean

index

var index: Int

The index the child has in its parent

isContainer

val isContainer: Boolean

Indicates if this class is a container or not. This is only overridden by Container. This check is performed like this, to avoid type checks. That might be an expensive operation in some targets.

keys

val View.keys: KeysEvents

localMatrix

var localMatrix: Matrix

Local transform MMatrix. If you plan to change its components manually instead of setting it directly, you should call the View.invalidate method.

mask

var View.mask: View?

maskFiltering

var View.maskFiltering: Boolean

mouse

val View.mouse: MouseEvents

mouseChildren

open var mouseChildren: Boolean

mouseEnabled

open var mouseEnabled: Boolean

Determines if mouse events will be handled for this view and its children

name

var name: String?

Optional name of this view

nextSibling

val View.nextSibling: View?

parent

var parent: Container?

Parent Container of this View if any, or null

pos

var pos: Point

preciseAutoScaling

var preciseAutoScaling: Boolean

prevSibling

val View.prevSibling: View?

program

var program: Program?

propagateEvents

var propagateEvents: Boolean

Indicates if this view is going to propagate the events that reach this node to its children

realImageScaleX

var realImageScaleX: Double

realImageScaleY

var realImageScaleY: Double

renderAlpha

val renderAlpha: Float

The concatenated/global version of the local alpha

renderAlphaD

val renderAlphaD: Double

The concatenated/global version of the local alpha

renderBlendMode

val renderBlendMode: BlendMode

The actual blendMode of the view after computing the ancestors and reaching a view with a non BlendMode.INHERIT.

renderColorMul

val renderColorMul: RGBA

The concatenated/global version of the local colorMul

renderPhases

val renderPhases: List<ViewRenderPhase>

root

val root: View

The ancestor view without parents. When attached (visible or invisible), this is the Stage. When no parents, it is this

rotation

var rotation: Angle

Local rotation of this view

sBottom

val sBottom: Float

scale

var scale: Double

scaleAvg

var ~~scaleAvg~~: Double

scaledHeight

var scaledHeight: Double

scaledSize

var scaledSize: Size

scaledWidth

var scaledWidth: Double

scaleX

var scaleX: Double

Local scaling in the X axis of this view

scaleXY

var scaleXY: Scale

scaleY

var scaleY: Double

Local scaling in the Y axis of this view

simpleAnimator

val View.simpleAnimator: Animator

size

var size: Size

skewX

var skewX: Angle

Local skewing in the X axis of this view

skewY

var skewY: Angle

Local skewing in the Y axis of this view

smoothing

var smoothing: Boolean

speed

var speed: Double

Ratio speed of this node, affecting all the View.addUpdater

sRight

val sRight: Float

stage

open val stage: Stage?

When included in the tree, this returns the stage. When not attached yet, this will return null.

styles

val View.styles: ViewStyles

timers

val View.timers: TimerComponents

tint

var tint: RGBA

Alias for colorMul to make this familiar to people coming from other engines.

touch

val View.touch: TouchEvents

treeNode

val View.treeNode: ViewNode

unscaledHeight

var unscaledHeight: Double

unscaledSize

open var unscaledSize: Size

unscaledWidth

var unscaledWidth: Double

updateProgramUniforms

var updateProgramUniforms: (RenderContext) -> Unit?

useNativeRendering

var useNativeRendering: Boolean

visible

open var visible: Boolean

Determines if the view will be displayed or not. It is different to alpha=0, since the render method won't be executed. Usually giving better performance. But also not receiving events.

width

var width: Double

Changes the width of this view. Generically, this means adjusting the scaleX of the view to match that size using the current bounds, but some views might override this to adjust its internal width or height (like SolidRect or UIView for example).

windowBounds

val windowBounds: Rectangle

Returns the global bounds of this object. Note this incurs in allocations. Use getGlobalBounds (out) to avoid it

var x: Double

Local X position of this view

var y: Double

Local Y position of this view

zIndex

var zIndex: Double

Functions

_setTransform

fun ~~_setTransform~~(t: MatrixTransform)

Like setTransform but without invalidation. If used at all, should be used with care and invalidate when required.

addRenderPhase

fun addRenderPhase(phase: ViewRenderPhase)

allDescendants

fun View?.allDescendants(out: ArrayList<View> = arrayListOf()): List<View>

ancestorsUpTo

fun View?.ancestorsUpTo(target: View?): List<View>

Returns a list of all the ancestors including this in order to reach from this view to the target view, or a list of all the ancestors in the case target is not an ancestor.

animate

suspend fun View.animate(defaultTime: TimeSpan = Animator.DEFAULT_TIME, defaultSpeed: Double = Animator.DEFAULT_SPEED, defaultEasing: Easing = Animator.DEFAULT_EASING, parallel: Boolean = false, looped: Boolean = false, completeOnCancel: Boolean = false, startImmediately: Boolean = Animator.DEFAULT_START_IMMEDIATELY, block: Animator.() -> Unit = {}): Animator

animator

fun View.animator(defaultTime: TimeSpan = Animator.DEFAULT_TIME, defaultSpeed: Double = Animator.DEFAULT_SPEED, defaultEasing: Easing = Animator.DEFAULT_EASING, parallel: Boolean = false, looped: Boolean = false, startImmediately: Boolean = Animator.DEFAULT_START_IMMEDIATELY, block: Animator.() -> Unit = {}): Animator

bringToBottom

fun View.bringToBottom()

bringToTop

fun View.bringToTop()

bviewFastForEach

inline fun BView.bviewFastForEach(block: (view: View) -> Unit)

clearEvents

fun clearEvents()

fun <T : BEvent> clearEvents(type: EventType<T>)

clone

open fun clone(): View

Allows to clone this view. This method is inadvisable in normal circumstances. This might not work properly if the View doesn't override the createInstance method.

commonAncestor

fun View?.commonAncestor(ancestor: View?): View?

convertToSpace

fun View.~~convertToSpace~~(srcPoint: Point, dst: View): Point

copyPropsFrom

open fun copyPropsFrom(source: View)

Allows to copy the basic properties (transform localMatrix, visible, colorMul, speed, name...) from source into this

delay

suspend fun View.delay(time: TimeSpan)

delayFrame

suspend fun View.delayFrame()

descendantsOfType

inline fun <T> View?.descendantsOfType(): List<T>

descendantsWith

fun View?.descendantsWith(out: ArrayList<View> = arrayListOf(), check: (View) -> Boolean): List<View>

Returns a list of descendants including this that matches the check method. Allows to provide an out array to reduce allocations.

dispatch

override fun <T : BEvent> dispatch(event: T): Boolean

override fun <T : BEvent> dispatch(type: EventType<T>, event: T, result: EventResult?): Boolean

open override fun <T : BEvent> dispatch(type: EventType<T>, event: T, result: EventResult?, up: Boolean, down: Boolean): Boolean

Dispatched a event of type that will execute all the handlers registered with onEvents in this object and its children.

dispatchChildren

open fun <T : BEvent> dispatchChildren(type: EventType<T>, event: T, result: EventResult?)

dispatchDown

open fun <T : BEvent> dispatchDown(type: EventType<T>, event: T, result: EventResult? = null): Boolean

dispatchDown

fun <T : BEvent> EventListener.dispatchDown(event: T): Boolean

dispatchParent

open override fun <T : BEvent> dispatchParent(type: EventType<T>, event: T, result: EventResult?)

dispatchUp

open fun <T : BEvent> dispatchUp(type: EventType<T>, event: T, result: EventResult? = null): Boolean

dispatchUp

fun <T : BEvent> EventListener.dispatchUp(event: T): Boolean

dispatchWithResult

override fun <T : BEvent> dispatchWithResult(event: T, out: EventResult): EventResult

dump

fun View?.dump(indent: String = "", emit: (String) -> Unit = ::println)

Dumps a view and its children for debugging purposes. The emit block parameter allows to define how to print those results.

dumpToString

fun View?.dumpToString(): String

Dumps a view and its children for debugging purposes into a String.

findFirstAscendant

fun View?.findFirstAscendant(cond: (view: View) -> Boolean): View?

findLastAscendant

fun View?.findLastAscendant(cond: (view: View) -> Boolean): View?

findViewByName

open fun findViewByName(name: String): View?

Allows to find a descendant view whose View.name property is name. Returns null if can't find any.

firstAncestor

fun View?.firstAncestor(includeThis: Boolean = true, condition: (View) -> Boolean): View?

firstAncestorOfType

inline fun <T : View> View?.firstAncestorOfType(includeThis: Boolean = true): T?

firstDescendantWith

fun View?.firstDescendantWith(check: (View) -> Boolean): View?

Tries to find a view matching the check method or null if none is found

forEachAscendant

inline fun View?.forEachAscendant(includeThis: Boolean = false, handler: (View) -> Unit)

forEachChild

inline fun forEachChild(callback: (child: View) -> Unit): Unit?

Iterates all the children of this container in normal order of rendering.

forEachChildren

inline fun ~~forEachChildren~~(callback: (child: View) -> Unit): Unit?

Iterates all the children of this container in normal order of rendering.

forEachChildrenReversed

inline fun ~~forEachChildrenReversed~~(callback: (child: View) -> Unit): Unit?

Iterates all the children of this container in reverse order of rendering.

forEachChildrenWithIndex

inline fun ~~forEachChildrenWithIndex~~(callback: (index: Int, child: View) -> Unit): Unit?

Iterates all the children of this container in normal order of rendering. Providing an index in addition to the child to the callback.

forEachChildReversed

inline fun forEachChildReversed(callback: (child: View) -> Unit): Unit?

Iterates all the children of this container in reverse order of rendering.

forEachChildWithIndex

inline fun forEachChildWithIndex(callback: (index: Int, child: View) -> Unit): Unit?

Iterates all the children of this container in normal order of rendering. Providing an index in addition to the child to the callback.

foreachDescendant

fun View?.foreachDescendant(handler: (View) -> Unit)

Iterates all the descendant Views including this calling the handler. Iteration happens in Pre-order (NLR).

gamepad

inline fun <T> View.gamepad(callback: GamePadEvents.() -> T): T

gestures

inline fun <T> View.gestures(callback: GestureEvents.() -> T): T

get

operator fun View?.get(name: String): QView

Indexer that allows to get a descendant marked with the name name.

getBounds

fun getBounds(target: View? = this, doAnchoring: Boolean = true, inclusive: Boolean = false, includeFilters: Boolean = false): Rectangle

getBoundsInSpace

fun getBoundsInSpace(viewSpace: View?, doAnchoring: Boolean = true, includeFilters: Boolean = false): Rectangle

Get the bounds of the current this view in another view viewSpace.

getBoundsNoAnchoring

fun getBoundsNoAnchoring(target: View? = this, inclusive: Boolean = false, includeFilters: Boolean = false): Rectangle

Get the bounds of this view, using the target view as coordinate system. Not providing a target will return the local bounds. Allows to specify out to prevent allocations.

getClippingAreaInternal

fun getClippingAreaInternal(): Rectangle

getClippingBounds

fun getClippingBounds(ctx: RenderContext): Rectangle

getConcatMatrix

fun getConcatMatrix(target: View, inclusive: Boolean = false): Matrix

Gets the concatenated MMatrix of this View up to the target view. If inclusive is true, the concatenated matrix will include the target view too. Allows to define an out matrix that will hold the result to prevent allocations.

getConcatMatrixAccurateSlow

fun getConcatMatrixAccurateSlow(target: View, inclusive: Boolean = false): Matrix

getDescendantsOfType

inline fun <T : View> View.getDescendantsOfType(): List<View>

Returns a list of descendants views that are of type T.

getGlobalBounds

fun getGlobalBounds(includeFilters: Boolean = false): Rectangle

Returns the global bounds of this object.

getGlobalMatrixWithAnchor

fun getGlobalMatrixWithAnchor(): Matrix

getLocalBounds

fun getLocalBounds(doAnchoring: Boolean = true, includeFilters: Boolean = false): Rectangle

Get local bounds of the view.

getLocalBoundsInternal

open override fun getLocalBoundsInternal(): Rectangle

getLocalBoundsInternalNoAnchor

fun getLocalBoundsInternalNoAnchor(includeStrokes: Boolean): Rectangle

getNextClippingView

fun View.getNextClippingView(): View

getOrCreateAndAddRenderPhase

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

getPointRelativeTo

fun View.getPointRelativeTo(pos: Point, view: View): Point

getPointRelativeToInv

fun View.getPointRelativeToInv(pos: Point, view: View): Point

getPositionRelativeTo

fun View.getPositionRelativeTo(view: View): Point

getRenderPhaseOfTypeOrNull

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

getRenderTargetBounds

fun getRenderTargetBounds(ctx: RenderContext): Rectangle

getSelfEventCount

fun getSelfEventCount(type: EventType<*>): Int

getVisibleGlobalArea

fun View.getVisibleGlobalArea(): Rectangle

getVisibleLocalArea

fun View.getVisibleLocalArea(): Rectangle

getVisibleWindowArea

fun View.getVisibleWindowArea(): Rectangle

getWindowBounds

fun getWindowBounds(bp: BoundsProvider): Rectangle

getWindowBoundsOrNull

fun getWindowBoundsOrNull(): Rectangle?

globalLocalBoundsPointRatio

fun globalLocalBoundsPointRatio(anchor: Anchor): Point

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

globalToLocal

fun globalToLocal(p: Point): Point

Converts the global point p (using root/stage as reference) into the local coordinate system. Allows to define out to avoid allocation.

globalToLocalDelta

fun globalToLocalDelta(p0: Point, p1: Point): Point

hasAncestor

fun View.hasAncestor(ancestor: View): Boolean

Checks if this view has the specified ancestor.

hitTest

open fun hitTest(globalPos: Point, direction: HitTestDirection = HitTestDirection.ANY): View?

Determines the view at the global point defined by xD and yD if any, or null

hitTestAny

fun hitTestAny(p: Point): Boolean

open override fun hitTestAny(p: Point, direction: HitTestDirection): Boolean

hitTestLocal

fun hitTestLocal(p: Point, direction: HitTestDirection = HitTestDirection.ANY): View?

hitTestShape

fun hitTestShape(shape: Shape2D, matrix: Matrix, direction: HitTestDirection = HitTestDirection.ANY): View?

hitTestView

fun hitTestView(view: View, direction: HitTestDirection = HitTestDirection.ANY): View?

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

interval

fun View.interval(time: TimeSpan, callback: () -> Unit): Closeable

intervalAndNow

fun View.intervalAndNow(time: TimeSpan, callback: () -> Unit): Closeable

invalidate

open fun invalidate()

Invalidates the View after changing some of its properties so the geometry can be computed again. If you change the localMatrix directly, you should call invalidateMatrix instead.

invalidateColorTransform

open fun invalidateColorTransform()

invalidateLocalBounds

fun invalidateLocalBounds()

invalidateMatrix

fun invalidateMatrix()

Invalidates the localMatrix, so it gets updated from the decomposed properties: xD, yD, scaleXD, scaleYD, rotation, skewX and skewY.

invalidateRender

open override fun invalidateRender()

isDescendantOf

fun View?.isDescendantOf(other: View, include: Boolean = true): Boolean

keys

inline fun <T> View.keys(callback: KeysEvents.() -> T): T

localMousePos

fun localMousePos(views: Views): Point

Computes the local X and Y coordinates of the mouse using the coords from the Views object

localToGlobal

fun localToGlobal(p: Point): Point

Converts the local point p into a global point (using root/stage as reference). Allows to define out to avoid allocation.

localToWindow

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

Converts the local point p into a point in window coordinates.

makeFocusable

fun View.makeFocusable(tabIndex: Int = 0, onChanged: (value: Boolean) -> Unit = {}): UIFocusable

mouseHitTest

fun mouseHitTest(p: Point): View?

x and y are in global coordinates

newKeys

inline fun View.newKeys(callback: KeysEvents.() -> Unit): KeysEvents

newMouse

inline fun View.newMouse(callback: MouseEvents.() -> Unit): MouseEvents

nextView

fun View.nextView(): View?

inline fun View.nextView(filter: (View) -> Boolean): View?

nextViewOfType

inline fun <T> View.nextViewOfType(): T?

onDropFile

fun View.onDropFile(handler: (DropFileEvent) -> Unit): Closeable

Handles a DropFileEvent. The event happens when a drag&drop file over the window happens.

onEvent

override fun <T : BEvent> onEvent(type: EventType<T>, handler: (T) -> Unit): CloseableCancellable

Registers a handler block to be executed when an event of type is dispatched

onEventCount

override fun onEventCount(type: EventType<*>): Int

onEvents

open fun <T : BEvent> onEvents(vararg etypes: EventType<out T>, handler: (T) -> Unit): Closeable

onEventsCount

override fun onEventsCount(): FastIdentityMap<EventType<*>, Int>?

plusAssign

operator fun View?.plusAssign(view: View?)

Adds the specified view to this view only if this view is a Container.

prevView

fun View.prevView(): View?

inline fun View.prevView(filter: (View) -> Boolean): View?

prevViewOfType

inline fun <T> View.prevViewOfType(): T?

redrawIfRequired

fun redrawIfRequired(): Boolean

removeFilter

fun View.removeFilter(filter: Filter)

removeFromParent

fun removeFromParent()

Removes this view from its parent.

removeRenderPhaseOfType

inline fun <T : ViewRenderPhase> removeRenderPhaseOfType()

render

override fun render(ctx: RenderContext)

The render method that is in charge of rendering. This method receives the ctx that allows to buffer geometry to be drawn in batches.

renderCtx2d

inline fun View.renderCtx2d(ctx: RenderContext, crossinline block: (RenderContext2D) -> Unit)

renderDebug

open fun renderDebug(ctx: RenderContext)

renderFiltered

fun View.renderFiltered(ctx: RenderContext, filter: Filter, first: Boolean = true)

renderFirstPhase

fun renderFirstPhase(ctx: RenderContext)

renderNextPhase

fun renderNextPhase(ctx: RenderContext)

renderToBitmap

suspend fun View.renderToBitmap(views: Views? = this.stage?.views, region: Rectangle? = null, scale: Double = 1.0, outPoint: Ref<Point>? = null, includeBackground: Boolean = false): Bitmap32

Asynchronously renders this View (with the provided views) to a Bitmap32 and returns it. The rendering will happen before the next frame.

renderToLocal

fun ~~renderToLocal~~(p: Point): Point

Converts a point p in the nearest ancestor marked as View.Reference into the local coordinate system. Allows to define out to avoid allocation.

replaceRenderPhase

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

replaceWith

fun View.replaceWith(view: View): Boolean

Replaces this view in its parent with view. Returns true if the replacement was successful. If this view doesn't have a parent or view is the same as this, returns false.

reset

open fun reset()

Resets the View properties to an identity state.

scrollParentsToMakeVisible

fun View.scrollParentsToMakeVisible()

Scroll ancestors to make this view is visible

setGlobalBounds

fun setGlobalBounds(bounds: Rectangle)

Tries to set the global bounds of the object. If there are rotations in the ancestors, this might not work as expected.

setHtml

fun View?.setHtml(html: String)

setMatrix

fun setMatrix(matrix: Matrix)

Sets the local transform matrix that includes xD, yD, scaleXD, scaleYD, rotation, skewX and skewY encoded into a Matrix

setMatrixInterpolated

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

Like setMatrix but directly sets an interpolated version of the l and r matrices with the ratio

setPositionRelativeTo

fun View.setPositionRelativeTo(view: View, pos: Point)

setText

fun View?.setText(text: String)

setTransform

fun setTransform(transform: MatrixTransform)

Sets the MatrixTransform decomposed version of the transformation, that directly includes xD, yD, scaleXD, scaleYD, rotation, skewX and skewY.

singleTouch

fun View.singleTouch(removeTouch: Boolean = false, supportStartAnywhere: Boolean = false, block: SingleTouchHandler.(id: Int) -> Unit)

timeout

fun View.timeout(time: TimeSpan, callback: () -> Unit): Closeable

toString

open override fun toString(): String

touch

fun View.touch(block: TouchEvents.() -> Unit)

trySetSource

fun trySetSource()

tween

suspend fun BaseView?.tween(vararg vs: V2<*>, time: TimeSpan = DEFAULT_TIME, easing: Easing = DEFAULT_EASING, waitTime: TimeSpan = TimeSpan.NIL, timeout: Boolean = false, autoInvalidate: Boolean = true, callback: (Float) -> Unit = { })

Creates a tween that will take a specified time to execute, with an optional easing.

tweenAsync

suspend fun BaseView?.tweenAsync(vararg vs: V2<*>, time: TimeSpan = DEFAULT_TIME, easing: Easing = DEFAULT_EASING, waitTime: TimeSpan = TimeSpan.NIL, callback: (Float) -> Unit = {}): Deferred<Unit>

fun BaseView?.tweenAsync(vararg vs: V2<*>, coroutineContext: CoroutineContext, time: TimeSpan = DEFAULT_TIME, easing: Easing = DEFAULT_EASING, waitTime: TimeSpan = TimeSpan.NIL, callback: (Float) -> Unit = {}): Deferred<Unit>

tweenNoWait

fun BaseView?.tweenNoWait(vararg vs: V2<*>, time: TimeSpan = DEFAULT_TIME, easing: Easing = DEFAULT_EASING, waitTime: TimeSpan = TimeSpan.NIL, callback: (Float) -> Unit = { }): TweenComponent?

unsafeRenderToBitmapSync

fun View.unsafeRenderToBitmapSync(ctx: RenderContext, region: Rectangle? = null, scale: Double = 1.0, outPoint: Ref<Point>? = null, useTexture: Boolean = true, bgcolor: RGBA = Colors.TRANSPARENT): Bitmap32

updateSingleView

fun View.updateSingleView(delta: TimeSpan, tempUpdate: UpdateEvent = UpdateEvent())

updateSingleViewWithViewsAll

fun View.updateSingleViewWithViewsAll(views: Views, delta: TimeSpan)