korge/korlibs.korge.view

Package-level declarations

Types

Anchorable

interface Anchorable

AnimationType

inline class AnimationType(val id: Int)

BaseGraphics

abstract class BaseGraphics(var autoScaling: Boolean = false) : BaseImage

BaseImage

open class BaseImage(bitmap: Resourceable<out BitmapCoords>, anchor: Anchor = Anchor.TOP_LEFT, hitShape: VectorPath? = null, var smoothing: Boolean = true) : RectBase

BaseView

open class BaseView : BaseEventListener

BlendMode

data class BlendMode(val factors: AGBlending, val name: String? = null)

Determines how pixels should be blended. The most common blend modes are: NORMAL (normal mix) and ADD (additive blending) along with MULTIPLY and others.

BlendModeProvider

object BlendModeProvider : ViewPropertyProvider.ItemsImpl<BlendMode>

BoundsProvider

interface BoundsProvider

BView

interface BView

CachedContainer

open class CachedContainer(var cache: Boolean = true, renderQuality: Quality? = null) : Container, InvalidateNotifier

Camera

open class Camera : Container, View.Reference

A Camera is a Container that allows to center its position using setTo and tweenTo methods.

Circle

open class Circle(radius: Double = 16.0, fill: Paint = Colors.WHITE, stroke: Paint = Colors.WHITE, strokeThickness: Double = 0.0, autoScaling: Boolean = true, renderer: GraphicsRenderer = GraphicsRenderer.GPU) : ShapeView

A CpuGraphics class that automatically keeps a circle shape with radius and color. The autoScaling property determines if the underlying texture will be updated when the hierarchy is scaled.

ClipContainer

open class ClipContainer(size: Size = Size(100, 100)) : FixedSizeContainer

Container

open class Container(var cull: Boolean = false) : View

A simple container of Views.

ContainerCollection

class ContainerCollection : MutableCollection<View> , List<View>

Allows to safely interact with the children of a container instance.

CpuGraphics

open class CpuGraphics @JvmOverloads constructor(var autoScaling: Boolean = false) : BaseGraphics

CustomContextRenderizableView

abstract class CustomContextRenderizableView(size: Size) : RectBase

DummyView

open class DummyView : View

A Dummy view that doesn't render anything.

Ellipse

open class Ellipse(radius: Size = Size(16, 16), fill: Paint = Colors.WHITE, stroke: Paint = Colors.WHITE, strokeThickness: Double = 0.0, autoScaling: Boolean = true) : ShapeView

A CpuGraphics class that automatically keeps a ellipse shape with radiusX, radiusY and color. The autoScaling property determines if the underlying texture will be updated when the hierarchy is scaled.

FastEllipse

open class FastEllipse(size: Size = Size(100f, 100f)) : FastRoundRectBase

FastRoundRect

open class FastRoundRect(size: Size = Size(100f, 100f), corners: RectCorners = RectCorners(.1f, .1f, 1f, 1f)) : FastRoundRectBase

FastRoundRectBase

abstract class FastRoundRectBase(size: Size = Size(100f, 100f), cornersRatio: RectCorners = RectCorners(.0f, .0f, .0f, .0f), doScale: Boolean = true) : ShadedView

FilteredContainer

class FilteredContainer : Container, View.Reference

FixedSizeCachedContainer

open class FixedSizeCachedContainer(size: Size = Size(100, 100), var cache: Boolean = true, var clip: Boolean = true) : CachedContainer, View.Reference

FixedSizeContainer

open class FixedSizeContainer(size: Size = Size(100, 100), var clip: Boolean = false) : Container, View.Reference

GameWindowLog

open class GameWindowLog : GameWindow

Graphics

class Graphics(shape: Shape = EmptyShape, renderer: GraphicsRenderer = GraphicsRenderer.GPU) : Container, ViewLeaf, Anchorable

GraphicsRenderer

enum GraphicsRenderer : Enum<GraphicsRenderer>

HorizontalAlignProvider

object HorizontalAlignProvider : ViewPropertyProvider.ItemsImpl<HorizontalAlign>

IHtml

interface IHtml

Image

class Image(bitmap: Resourceable<out BitmapCoords>, anchor: Anchor = Anchor.TOP_LEFT, hitShape: VectorPath? = null, var smoothing: Boolean = true) : BaseImage, ViewFileRef, SmoothedBmpSlice

InvalidateNotifier

interface InvalidateNotifier

IText

interface IText

KorgeFileLoader

data class KorgeFileLoader<T>(val name: String, val loader: suspend VfsFile.(FastByteArrayInputStream, Views) -> T)

KorgeFileLoaderTester

data class KorgeFileLoaderTester<T>(val name: String, val tester: suspend (s: FastByteArrayInputStream, injector: Injector) -> KorgeFileLoader<T>?)

Line

class Line(p1: Point, var p2: Point, color: RGBA = Colors.WHITE) : View

Mesh

open class Mesh(var texture: BmpSlice? = null, var vertices: Float32Buffer = Float32Buffer(0), var uvs: Float32Buffer = Float32Buffer(0), var indices: Uint16Buffer = Uint16Buffer(0), var drawMode: Mesh.DrawModes = DrawModes.Triangles) : View

NinePatch

class NinePatch(ninePatch: NinePatchBmpSlice?, size: Size = Size(ninePatch?.width?.toFloat() ?: 16f, ninePatch?.height?.toFloat() ?: 16f)) : View, ViewFileRef

NinePatchShapeView

class NinePatchShapeView(shape: NinePatchShape, renderer: GraphicsRenderer) : UIView, Anchorable

Outline

class Outline(vectorPath: VectorPath, x: Double = 0.0, y: Double = 0.0, color: RGBA = Colors.WHITE) : View

PixelAnchorable

interface PixelAnchorable

QualityProvider

object QualityProvider : ViewPropertyProvider.ItemsImpl<Quality>

QView

class QView(val views: List<View>) : List<View> , BView

RectBase

open class RectBase(anchor: Anchor = Anchor.TOP_LEFT, hitShape: VectorPath? = null, var smoothing: Boolean = true) : View, Anchorable

RectBase is an abstract Container that represents something with a Rect-like shape: like a SolidRect or an Image. It supports anchoring anchor for this rectangle, and handles pre-computing of vertices for performance.

Renderable

interface Renderable

Represents something that can be rendered. Usually a View.

RenderableView

class RenderableView(size: Size, var viewRenderer: ViewRenderer) : CustomContextRenderizableView

RoundRect

class RoundRect(size: Size, radius: RectCorners, fill: Paint = Colors.WHITE, stroke: Paint = Colors.WHITE, strokeThickness: Double = 0.0, autoScaling: Boolean = true) : ShapeView

A Rect View with rounded corners of size widthD and heightD with the initial color.

ScaleModeProvider

object ScaleModeProvider : ViewPropertyProvider.ItemsImpl<ScaleMode>

ScaleView

class ScaleView(size: Size, scaleAvg: Double = 2.0, var filtering: Boolean = false) : SContainer, View.Reference

ScalingOption

sealed class ScalingOption

SContainer

open class SContainer(size: Size = Size(100, 100), var clip: Boolean = false) : FixedSizeContainer

ShadedView

open class ShadedView(program: Program, size: Size = Size(100f, 100f), coordsType: ShadedView.CoordsType = CoordsType.D_0_1) : RectBase

ShapeView

open class ShapeView(shape: VectorPath? = null, fill: Paint = Colors.WHITE, stroke: Paint = Colors.WHITE, strokeThickness: Double = 1.0, autoScaling: Boolean = true, renderer: GraphicsRenderer = GraphicsRenderer.GPU) : Container, Anchorable, ViewLeaf

SmoothedBmpSlice

interface SmoothedBmpSlice

SolidRect

class SolidRect(size: Size, color: RGBA = Colors.WHITE) : RectBase

A Rect RectBase of size widthD and heightD with the initial color, color.

SolidTriangle

class SolidTriangle(p1: Point, p2: Point, p3: Point, color: RGBA = Colors.WHITE) : Mesh

Sprite

open class Sprite(bitmap: BmpSlice = Bitmaps.white, anchor: Anchor = Anchor.TOP_LEFT, hitShape: VectorPath? = null, var smoothing: Boolean = true) : BaseImage

A Sprite is basically an Image with added abilities to display a SpriteAnimation The regular usage is to initialize the Sprite with one SpriteAnimation. The first displayed bitmap will be the first element of the SpriteAnimations spriteStack.

SpriteAnimation

class SpriteAnimation(val sprites: List<BmpSlice>, val defaultTimePerFrame: TimeSpan = TimeSpan.NIL) : Collection<BmpSlice>

Stage

open class Stage : FixedSizeContainer, View.Reference, CoroutineScope, ViewsContainer, ResourcesContainer, BoundsProvider, InvalidateNotifier

Singleton root View and Container that contains a reference to the Views singleton and doesn't have any parent.

Text

open class Text(text: String, textSize: Double = DEFAULT_TEXT_SIZE, color: RGBA = Colors.WHITE, font: Resourceable<out Font> = DefaultTtfFontAsBitmap, alignment: TextAlignment = TextAlignment.TOP_LEFT, renderer: TextRenderer<String> = DefaultStringTextRenderer, autoScaling: Boolean = DEFAULT_AUTO_SCALING, fill: Paint? = null, stroke: Stroke? = null) : Container, IText, ViewLeaf

TextAlignmentProvider

object TextAlignmentProvider : ViewPropertyProvider.ItemsImpl<TextAlignment>

TextBlock

class TextBlock(text: RichTextData = RichTextData("", textSize = 16.0, font = DefaultTtfFontAsBitmap), align: TextAlignment = TextAlignment.TOP_LEFT, size: Size = Size(100, 100)) : UIView, ViewLeaf

UpdateEvent

class UpdateEvent(var deltaTime: TimeSpan = TimeSpan.ZERO) : Event, TEvent<UpdateEvent>

VectorImage

class VectorImage(shape: SizedDrawable, var autoScaling: Boolean = true) : BaseGraphics, ViewFileRef

VerticalAlignProvider

object VerticalAlignProvider : ViewPropertyProvider.ItemsImpl<VerticalAlign>

View

abstract class View : BaseView, Renderable, BView, HitTestable, WithHitShape2D

KorGE includes a DOM-based tree of views that makes a chain of affine transforms starting with the Stage, that is the root node.

ViewDslMarker

typealias ViewDslMarker = korlibs.math.annotations.ViewDslMarker

ViewFactory

data class ViewFactory(val name: String, val build: () -> View)

ViewFileRef

interface ViewFileRef

ViewLeaf

interface ViewLeaf

ViewRenderer

fun interface ViewRenderer

ViewRenderPhase

interface ViewRenderPhase

Views

class Views(val coroutineContext: CoroutineContext, val ag: AG, val injector: Injector = Injector(), val input: Input = Input(), val timeProvider: TimeProvider = TimeProvider, val stats: Stats = Stats(), val gameWindow: GameWindow, val gameId: String = "korgegame", val settingsFolder: String? = null, val batchMaxQuads: Int = BatchBuilder2D.DEFAULT_BATCH_QUADS, val bp: BoundsProvider = BoundsProvider.Base(), val stageBuilder: (Views) -> Stage = { Stage(it) }) : BaseEventListener, Extra, CoroutineScope, ViewsContainer, BoundsProvider, DialogInterfaceProvider, Closeable, ResourcesContainer, InvalidateNotifier, DeviceDimensionsProvider

Heavyweight singleton object within the application that contains information about the Views. It contains information about the coroutineContext, the gameWindow, the injector, the input and contains a reference to the root view.

ViewsContainer

interface ViewsContainer

ViewsLog

class ViewsLog(val coroutineContext: CoroutineContext, val injector: Injector = Injector(), val ag: AG = AGLog(), val input: Input = Input(), val timeProvider: TimeProvider = TimeProvider, val stats: Stats = Stats(), val gameWindow: GameWindow = GameWindowLog()) : CoroutineScope

ViewsResizedEvent

class ViewsResizedEvent(val views: Views, var size: SizeInt = SizeInt(0, 0)) : Event, TEvent<ViewsResizedEvent>

ViewsUpdateEvent

class ViewsUpdateEvent(val views: Views, var delta: TimeSpan = TimeSpan.ZERO) : Event, TEvent<ViewsUpdateEvent>

Properties

val ViewsContainer.ag: AG

agProgram

val BitmapFont.agProgram: Program?

allDescendantNames

val View?.allDescendantNames: List<String>

Returns a list of all the non-null View.name values of this and the descendants

ancestorCount

val View?.ancestorCount: Int

Returns the number of ancestors of this view. Views without parents return 0.

ancestors

val View?.ancestors: List<View>

Returns a list of all the ancestors (including this) to reach the root node (usually the stage).

aroundPath

var <T : Text> T.aroundPath: VectorPath?

centered

val <T : Anchorable> T.centered: T

fps

val Double.fps: Frequency

val Int.fps: Frequency

lastTreeView

val Stage.lastTreeView: View

nextSibling

val View.nextSibling: View?

ordinal

val BlendMode.ordinal: Int

prevSibling

val View.prevSibling: View?

Functions

addFixedUpdater

fun <T : View> T.addFixedUpdater(timesPerSecond: Frequency, initial: Boolean = true, limitCallsPerFrame: Int = 16, updatable: T.() -> Unit): Cancellable

fun <T : View> T.addFixedUpdater(time: TimeSpan, first: Boolean = true, limitCallsPerFrame: Int = 16, updatable: T.() -> Unit): CloseableCancellable

Adds an updatable block that will be executed every time time, the calls will be discretized on each frame and will handle accumulations. The first properly allows to adjust if the updatable will be called immediately after calling this function. To avoid executing too many blocks, when there is a long pause, limitCallsPerFrame limits the number of times the block can be executed in a single frame.

addOptFixedUpdater

fun <T : View> T.addOptFixedUpdater(time: TimeSpan = TimeSpan.NIL, updatable: T.(TimeSpan) -> Unit): CloseableCancellable

addTo

fun <T : View> T.addTo(parent: Container): T

Alias for parent += this. Refer to Container.plusAssign.

inline fun <T : View> T.addTo(instance: Container, callback: T.() -> Unit = {}): T

addUpdater

fun <T : View> T.addUpdater(updatable: T.(TimeSpan) -> Unit): CloseableCancellable

fun <T : View> T.addUpdater(referenceFps: Frequency, first: Boolean = true, updatable: T.(scale: Float) -> Unit): Cancellable

fun <T : View> T.addUpdater(first: Boolean = true, firstTime: TimeSpan = TimeSpan.ZERO, updatable: T.(TimeSpan) -> Unit): CloseableCancellable

Adds a block that will be executed per frame to this view. As parameter the block will receive a TimeSpan with the time elapsed since the previous frame.

addUpdaterWithViews

fun <T : View> T.addUpdaterWithViews(updatable: T.(views: Views, TimeSpan) -> Unit): CloseableCancellable

allDescendants

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

alpha

fun <T : View> T.alpha(alpha: Float): T

Chainable method returning this that sets View.alphaF

inline fun <T : View> T.alpha(alpha: Number): T

fun QView.alpha(value: Double)

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.

anchor

fun <T : Anchorable> T.anchor(anchor: Anchor): T

inline fun <T : Anchorable> T.anchor(ax: Number, ay: Number): T

anchorPixel

fun <T : PixelAnchorable> T.anchorPixel(point: Point): T

append

inline fun <T : View> Container.append(view: T): T

inline fun <T : View> Container.append(view: T, block: T.() -> Unit): T

aroundPath

fun <T : Text> T.aroundPath(path: VectorPath?): T

autoSize

fun <T : Text> T.autoSize(value: Boolean): T

blendMode

inline fun <T : View> T.blendMode(blendMode: BlendMode): T

bounds

fun <T : View> T.bounds(rect: Rectangle): T

fun <T : View> T.bounds(left: Double, top: Double, right: Double, bottom: Double): T

inline fun <T : View> T.bounds(left: Number, top: Number, right: Number, bottom: Number): T

bringToBottom

fun View.bringToBottom()

bringToTop

fun View.bringToTop()

bviewFastForEach

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

cachedContainer

inline fun Container.cachedContainer(cache: Boolean = true, callback: CachedContainer.() -> Unit = {}): CachedContainer

camera

inline fun Container.camera(callback: Camera.() -> Unit = {}): Camera

Creates a new Camera and attaches to this. The callback argument is called with the Camera injected as this to be able to configure the camera.

castTo

inline fun <T : View> QView.castTo(): T?

center

fun <T : Anchorable> T.center(): T

circle

inline fun Container.circle(radius: Number = 16.0, fill: Paint = Colors.WHITE, stroke: Paint = Colors.WHITE, strokeThickness: Number = 0.0, autoScaling: Boolean = true, renderer: GraphicsRenderer = GraphicsRenderer.GPU, callback: Circle.() -> Unit = {}): Circle

Creates a Circle of radius and fill. The autoScaling determines if the underlying texture will be updated when the hierarchy is scaled. The callback allows to configure the Circle instance.

clipContainer

inline fun Container.clipContainer(size: Size, callback: ClipContainer.() -> Unit = {}): ClipContainer

colorMul

fun <T : View> T.colorMul(color: RGBA): T

Chainable method returning this that sets View.colorMul

commonAncestor

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

container

inline fun Container.container(cull: Boolean = false, callback: Container.() -> Unit = {}): Container

Creates a new Container, allowing to configure with callback, and attaches the newly created container to the receiver this Container

convertToSpace

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

convertViewSpace

fun View.Companion.convertViewSpace(src: View, srcPoint: Point, dst: View?): Point

CpuGraphics

fun CpuGraphics(shape: Shape, antialiased: Boolean = true): CpuGraphics

cpuGraphics

inline fun Container.cpuGraphics(autoScaling: Boolean = false, callback: ShapeBuilder.(CpuGraphics) -> Unit = {}): CpuGraphics

inline fun Container.cpuGraphics(shape: Shape, antialiased: Boolean = true, callback: CpuGraphics.() -> Unit = {}): CpuGraphics

inline fun Container.cpuGraphics(build: ShapeBuilder.() -> Unit, antialiased: Boolean = true, callback: CpuGraphics.() -> Unit = {}): CpuGraphics

deferWithViews

fun <T : View> T.deferWithViews(views: Views? = null, tryImmediate: Boolean = true, block: (views: Views) -> Unit): T

Registers a block that will be executed once in the next frame that this View is displayed with the Views singleton

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.

dummyView

fun Container.dummyView(): DummyView

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.

ellipse

inline fun Container.ellipse(radius: Size = Size(16, 16), fill: Paint = Colors.WHITE, stroke: Paint = Colors.WHITE, strokeThickness: Double = 0.0, autoScaling: Boolean = true, callback: Ellipse.() -> Unit = {}): Ellipse

Creates a Ellipse of radiusX, radiusY and fill. The autoScaling determines if the underlying texture will be updated when the hierarchy is scaled. The callback allows to configure the Circle instance.

extraViewProp

inline fun <T2 : View, T> extraViewProp(name: String? = null, noinline default: T2.() -> T): Extra.PropertyThis<T2, T>

fastEllipse

inline fun Container.fastEllipse(size: Size, color: RGBA = Colors.WHITE, callback: FastEllipse.() -> Unit = {}): FastEllipse

fastRoundRect

inline fun Container.fastRoundRect(size: Size, corners: RectCorners = RectCorners(.1f, .1f, 1f, 1f), color: RGBA = Colors.WHITE, callback: FastRoundRect.() -> Unit = {}): FastRoundRect

findFirstAscendant

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

findLastAscendant

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

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

fixedSizeCachedContainer

inline fun Container.fixedSizeCachedContainer(size: Size, cache: Boolean = true, clip: Boolean = true, callback: CachedContainer.() -> Unit = {}): FixedSizeCachedContainer

inline fun Container.fixedSizeCachedContainer(width: Double, height: Double, cache: Boolean = true, clip: Boolean = true, callback: CachedContainer.() -> Unit = {}): FixedSizeCachedContainer

fixedSizeContainer

inline fun Container.fixedSizeContainer(size: Size, clip: Boolean = false, callback: FixedSizeContainer.() -> Unit = {}): FixedSizeContainer

forEachAscendant

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

foreachDescendant

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

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

get

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

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

getAllDescendantViews

fun getAllDescendantViews(view: View, out: FastArrayList<View> = FastArrayList(), reversed: Boolean = true): FastArrayList<View>

getDescendantsOfType

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

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

getNextClippingView

fun View.getNextClippingView(): View

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

getSpriteAnimation

fun Atlas.getSpriteAnimation(prefix: String = "", defaultTimePerFrame: TimeSpan = TimeSpan.NIL): SpriteAnimation

fun Atlas.getSpriteAnimation(regex: Regex, defaultTimePerFrame: TimeSpan = TimeSpan.NIL): SpriteAnimation

getVisibleGlobalArea

fun View.getVisibleGlobalArea(): Rectangle

getVisibleLocalArea

fun View.getVisibleLocalArea(): Rectangle

getVisibleWindowArea

fun View.getVisibleWindowArea(): Rectangle

globalPos

fun <T : View> T.globalPos(p: Point): T

graphics

inline fun Container.graphics(renderer: GraphicsRenderer = GraphicsRenderer.SYSTEM, callback: ShapeBuilder.(Graphics) -> Unit = {}): Graphics

inline fun Container.graphics(shape: Shape, renderer: GraphicsRenderer = GraphicsRenderer.SYSTEM, callback: Graphics.() -> Unit = {}): Graphics

inline fun Container.graphics(build: ShapeBuilder.() -> Unit, renderer: GraphicsRenderer = GraphicsRenderer.SYSTEM, callback: Graphics.() -> Unit = {}): Graphics

hasAncestor

fun View.hasAncestor(ancestor: View): Boolean

Checks if this view has the specified ancestor.

hitShape

inline fun <T : View> T.hitShape(crossinline block: VectorBuilder.() -> Unit): T

image

inline fun Container.image(texture: Bitmap, anchor: Anchor = Anchor.TOP_LEFT, callback: Image.() -> Unit = {}): Image

inline fun Container.image(texture: Resourceable<out BaseBmpSlice>, anchor: Anchor = Anchor.TOP_LEFT, callback: Image.() -> Unit = {}): Image

inline fun Container.image(texture: BitmapCoords, anchor: Anchor = Anchor.TOP_LEFT, callback: Image.() -> Unit = {}): Image

isDescendantOf

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

line

inline fun Container.line(a: Point, b: Point, color: RGBA = Colors.WHITE, callback: Line.() -> Unit = {}): Line

inline fun Container.line(x0: Double, y0: Double, x1: Double, y1: Double, color: RGBA = Colors.WHITE, callback: Line.() -> Unit = {}): Line

name

inline fun <T : View> T.name(name: String?): T

nextView

fun View.nextView(): View?

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

nextViewOfType

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

ninePatch

inline fun Container.ninePatch(ninePatch: NinePatchBmpSlice?, size: Size = Size(ninePatch?.widthF ?: 16f, ninePatch?.heightF ?: 16f), callback: NinePatch.() -> Unit = {}): NinePatch

inline fun Container.ninePatch(tex: BmpSlice, size: Size, left: Float, top: Float, right: Float, bottom: Float, callback: NinePatch.() -> Unit = {}): NinePatch

ninePatchShapeView

inline fun Container.ninePatchShapeView(shape: NinePatchShape, renderer: GraphicsRenderer = GraphicsRenderer.SYSTEM, callback: NinePatchShapeView.() -> Unit = {}): NinePatchShapeView

onClick

fun QView.onClick(handler: suspend (MouseEvents) -> Unit)

onFrame

inline fun <T : View> T.~~onFrame~~(noinline updatable: T.(TimeSpan) -> Unit): Cancellable

onNextFrame

fun <T : View> T.onNextFrame(block: T.(views: Views) -> Unit): CloseableCancellable

onStageResized

fun <T : View> T.onStageResized(firstTrigger: Boolean = true, block: Views.(width: Int, height: Int) -> Unit): T

outline

inline fun Container.outline(vectorPath: VectorPath, x: Double = 0.0, y: Double = 0.0, color: RGBA = Colors.WHITE, callback: Outline.() -> Unit = {}): Outline

pivot

fun <T : Mesh> T.pivot(x: Double, y: Double): T

plusAssign

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

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

position

fun <T : View> T.position(p: Point): T

Chainable method returning this that sets View.x and View.y

fun <T : View> T.position(x: Double, y: Double): T

inline fun <T : View> T.position(x: Number, y: Number): T

positionX

fun <T : View> T.positionX(x: Double): T

inline fun <T : View> T.positionX(x: Number): T

positionY

fun <T : View> T.positionY(y: Double): T

inline fun <T : View> T.positionY(y: Number): T

prevView

fun View.prevView(): View?

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

prevViewOfType

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

renderableView

inline fun Container.renderableView(size: Size = Size(128, 24), viewRenderer: ViewRenderer): RenderableView

inline fun Container.renderableView(size: Size = Size(128, 24), noinline viewRenderer: RenderableView.() -> Unit): RenderableView

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.

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.

rotation

fun <T : View> T.rotation(rot: Angle): T

Chainable method returning this that sets View.rotation

roundRect

inline fun Container.roundRect(size: Size, radius: RectCorners, fill: Paint = Colors.WHITE, stroke: Paint = Colors.WHITE, strokeThickness: Double = 0.0, autoScaling: Boolean = true, callback: RoundRect.() -> Unit = {}): RoundRect

Creates a new RoundRect of size widthxheight and color and allows you to configure it via callback. Once created, it is added to this receiver Container.

scale

fun <T : View> T.scale(sx: Double, sy: Double = sx): T

Chainable method returning this that sets View.scaleXD and View.scaleYD

inline fun <T : View> T.scale(sx: Number, sy: Number = sx): T

scaleView

inline fun Container.scaleView(size: Size, scaleAvg: Double = 2.0, filtering: Boolean = false, callback: Container.() -> Unit = {}): ScaleView

scaleWhileMaintainingAspect

fun <T : View> T.scaleWhileMaintainingAspect(scalingOption: ScalingOption): T

scrollParentsToMakeVisible

fun View.scrollParentsToMakeVisible()

Scroll ancestors to make this view is visible

setBoundsInfo

fun BoundsProvider.setBoundsInfo(reqVirtualSize: Size, actualSize: Size, scaleMode: ScaleMode = ScaleMode.FILL, anchor: Anchor = Anchor.CENTER, virtualSize: Ref<SizeInt> = Ref(), targetSize: Ref<SizeInt> = Ref())

setHtml

fun QView.setHtml(html: String)

fun View?.setHtml(html: String)

setPositionRelativeTo

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

setText

fun QView.setText(text: String)

fun View?.setText(text: String)

shapeView

inline fun Container.shapeView(shape: VectorPath? = null, fill: Paint = Colors.WHITE, stroke: Paint = Colors.WHITE, strokeThickness: Double = 1.0, autoScaling: Boolean = true, renderer: GraphicsRenderer = GraphicsRenderer.GPU, callback: ShapeView.() -> Unit = {}): ShapeView

size

fun <T : View> T.size(size: Size): T

fun <T : View> T.size(width: Double, height: Double): T

inline fun <T : View> T.size(width: Number, height: Number): T

sizeScaled

fun <T : View> T.sizeScaled(size: Size): T

skew

fun <T : View> T.skew(sx: Angle, sy: Angle): T

Chainable method returning this that sets View.skewX and View.skewY

solidRect

inline fun Container.solidRect(size: Size, color: RGBA = Colors.WHITE, callback: SolidRect.() -> Unit = {}): SolidRect

Creates a new SolidRect of size and color color and allows you to configure it via callback. Once created, it is added to this receiver Container.

inline fun Container.solidRect(width: Double, height: Double, color: RGBA = Colors.WHITE, callback: SolidRect.() -> Unit = {}): SolidRect

inline fun Container.solidRect(width: Float, height: Float, color: RGBA = Colors.WHITE, callback: SolidRect.() -> Unit = {}): SolidRect

inline fun Container.solidRect(width: Int, height: Int, color: RGBA = Colors.WHITE, callback: SolidRect.() -> Unit = {}): SolidRect

Creates a new SolidRect of size widthxheight and color color and allows you to configure it via callback. Once created, it is added to this receiver Container.

solidTriangle

inline fun Container.solidTriangle(p1: Point, p2: Point, p3: Point, color: RGBA = Colors.WHITE, callback: Mesh.() -> Unit = {}): SolidTriangle

Creates a new SolidTriangle with points [p1, p1, p3] and color color and allows you to configure it via callback. Once created, it is added to this receiver Container.

sprite

inline fun Container.sprite(texture: Bitmap, anchor: Anchor = Anchor.TOP_LEFT, callback: Sprite.() -> Unit = {}): Sprite

inline fun Container.sprite(initialAnimation: SpriteAnimation, anchor: Anchor = Anchor.TOP_LEFT, callback: Sprite.() -> Unit = {}): Sprite

inline fun Container.sprite(texture: BmpSlice = Bitmaps.white, anchor: Anchor = Anchor.TOP_LEFT, callback: Sprite.() -> Unit = {}): Sprite

text

inline fun Container.text(text: String, textSize: Number = Text.DEFAULT_TEXT_SIZE, color: RGBA = Colors.WHITE, font: Resourceable<out Font> = DefaultTtfFontAsBitmap, alignment: TextAlignment = TextAlignment.TOP_LEFT, renderer: TextRenderer<String> = DefaultStringTextRenderer, autoScaling: Boolean = Text.DEFAULT_AUTO_SCALING, fill: Paint? = null, stroke: Stroke? = null, block: Text.() -> Unit = {}): Text

textBlock

inline fun Container.textBlock(text: RichTextData = RichTextData("", textSize = 16.0, font = DefaultTtfFontAsBitmap), align: TextAlignment = TextAlignment.TOP_LEFT, size: Size = Size(100, 100), block: TextBlock.() -> Unit = {}): TextBlock

textSpacing