inline fun <S> KWidget<S>.buttonGroup(minCheckedCount: Int, maxCheckedCount: Int, skin: Skin = Scene2DSkin.defaultSkin, init: KButtonTable.(S) -> Unit = {}): KButtonTable

center

open fun center(): HorizontalGroup

checkBox

inline fun <S> KWidget<S>.checkBox(text: String, style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: KCheckBox.(S) -> Unit = {}): KCheckBox

clear

open override fun clear()

open fun clear(p0: Boolean)

clearActions

open fun clearActions()

clearChildren

open fun clearChildren()

open fun clearChildren(p0: Boolean)

clearListeners

open fun clearListeners()

clipBegin

open fun clipBegin(): Boolean

open fun clipBegin(p0: Float, p1: Float, p2: Float, p3: Float): Boolean

clipEnd

open fun clipEnd()

container

inline fun <S> KWidget<S>.container(init: KContainer<Actor>.(S) -> Unit = {}): KContainer<Actor>

inline fun <S, A : Actor> KWidget<S>.container(actor: A, init: KContainer<A>.(S) -> Unit = {}): KContainer<A>

Use this container method variant for customly built actors that you want to keep in a Container.

debug

open fun debug(): Actor

debugAll

open fun debugAll(): Group

draw

open override fun draw(p0: Batch, p1: Float)

drawDebug

open override fun drawDebug(p0: ShapeRenderer)

expand

open fun expand(): HorizontalGroup

open fun expand(p0: Boolean): HorizontalGroup

fill

open fun fill(): HorizontalGroup

open fun fill(p0: Float): HorizontalGroup

findActor

@Null

open fun <T : Actor> findActor(p0: String): T

fire

open fun fire(p0: Event): Boolean

firstAscendant

@Null

open fun <T : Actor> firstAscendant(p0: Class<T>): T

getChild

open fun getChild(p0: Int): Actor

getMaxHeight

open override fun getMaxHeight(): Float

getMaxWidth

open override fun getMaxWidth(): Float

getMinHeight

open override fun getMinHeight(): Float

getMinWidth

open override fun getMinWidth(): Float

getRight

open fun getRight(): Float

getRows

open fun getRows(): Int

getTop

open fun getTop(): Float

getX

open fun getX(p0: Int): Float

getY

open fun getY(p0: Int): Float

getZIndex

open fun getZIndex(): Int

grow

open fun grow(): HorizontalGroup

hasActions

open fun hasActions(): Boolean

hasChildren

open fun hasChildren(): Boolean

hasKeyboardFocus

open fun hasKeyboardFocus(): Boolean

hasParent

open fun hasParent(): Boolean

hasScrollFocus

open fun hasScrollFocus(): Boolean

hit

open override fun hit(p0: Float, p1: Float, p2: Boolean): Actor

horizontalGroup

inline fun <S> KWidget<S>.horizontalGroup(init: KHorizontalGroup.(S) -> Unit = {}): KHorizontalGroup

image

inline fun <S> KWidget<S>.image(texture: Texture, init: Image.(S) -> Unit = {}): Image

inline fun <S> KWidget<S>.image(ninePatch: NinePatch, init: Image.(S) -> Unit = {}): Image

inline fun <S> KWidget<S>.image(textureRegion: TextureRegion, init: Image.(S) -> Unit = {}): Image

inline fun <S> KWidget<S>.image(drawable: Drawable, init: Image.(S) -> Unit = {}): Image

inline fun <S> KWidget<S>.image(drawableName: String, skin: Skin = Scene2DSkin.defaultSkin, init: Image.(S) -> Unit = {}): Image

imageButton

inline fun <S> KWidget<S>.imageButton(style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: KImageButton.(S) -> Unit = {}): KImageButton

imageTextButton

inline fun <S> KWidget<S>.imageTextButton(text: String, style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: KImageTextButton.(S) -> Unit = {}): KImageTextButton

invalidate

open override fun invalidate()

invalidateHierarchy

open override fun invalidateHierarchy()

isAscendantOf

open fun isAscendantOf(p0: Actor): Boolean

isDescendantOf

open fun isDescendantOf(p0: Actor): Boolean

isTouchable

open fun isTouchable(): Boolean

isTouchFocusListener

open fun isTouchFocusListener(): Boolean

isTouchFocusTarget

open fun isTouchFocusTarget(): Boolean

label

inline fun <S> KWidget<S>.label(text: CharSequence, style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: Label.(S) -> Unit = {}): Label

layout

open override fun layout()

left

open fun left(): HorizontalGroup

listWidget

inline fun KWidget<*>.listWidget(style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: KListWidget.() -> Unit = {}): KListWidget

listWidgetOf

fun KWidget<*>.listWidgetOf(items: Array? = null, style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin): KListWidget

localToActorCoordinates

open fun localToActorCoordinates(p0: Actor, p1: Vector2): Vector2

localToAscendantCoordinates

open fun localToAscendantCoordinates(@Null p0: Actor, p1: Vector2): Vector2

localToDescendantCoordinates

open fun localToDescendantCoordinates(p0: Actor, p1: Vector2): Vector2

localToParentCoordinates

open fun localToParentCoordinates(p0: Vector2): Vector2

localToScreenCoordinates

open fun localToScreenCoordinates(p0: Vector2): Vector2

localToStageCoordinates

open fun localToStageCoordinates(p0: Vector2): Vector2

moveBy

open fun moveBy(p0: Float, p1: Float)

needsLayout

open fun needsLayout(): Boolean

notify

open fun notify(p0: Event, p1: Boolean): Boolean

pack

open override fun pack()

pad

open fun pad(p0: Float): HorizontalGroup

open fun pad(p0: Float, p1: Float, p2: Float, p3: Float): HorizontalGroup

padBottom

open fun padBottom(p0: Float): HorizontalGroup

padLeft

open fun padLeft(p0: Float): HorizontalGroup

padRight

open fun padRight(p0: Float): HorizontalGroup

padTop

open fun padTop(p0: Float): HorizontalGroup

parentToLocalCoordinates

open fun parentToLocalCoordinates(p0: Vector2): Vector2

particleEffect

inline fun <S> KWidget<S>.particleEffect(particleEffect: ParticleEffect, resetOnStart: Boolean = true, init: ParticleEffectActor.(S) -> Unit = {}): ParticleEffectActor

progressBar

inline fun <S> KWidget<S>.progressBar(min: Float = 0.0f, max: Float = 1.0f, step: Float = 0.01f, vertical: Boolean = false, style: String = if (vertical) defaultVerticalStyle else defaultHorizontalStyle, skin: Skin = Scene2DSkin.defaultSkin, init: ProgressBar.(S) -> Unit = {}): ProgressBar

remove

open fun remove(): Boolean

removeAction

open fun removeAction(@Null p0: Action)

removeActor

open fun removeActor(p0: Actor): Boolean

open fun removeActor(p0: Actor, p1: Boolean): Boolean

removeActorAt

open fun removeActorAt(p0: Int, p1: Boolean): Actor

removeCaptureListener

open fun removeCaptureListener(p0: EventListener): Boolean

removeListener

open fun removeListener(p0: EventListener): Boolean

reverse

open fun reverse(): HorizontalGroup

open fun reverse(p0: Boolean): HorizontalGroup

right

open fun right(): HorizontalGroup

rotateBy

open fun rotateBy(p0: Float)

rowAlign

open fun rowAlign(p0: Int): HorizontalGroup

rowBottom

open fun rowBottom(): HorizontalGroup

rowCenter

open fun rowCenter(): HorizontalGroup

rowLeft

open fun rowLeft(): HorizontalGroup

rowRight

open fun rowRight(): HorizontalGroup

rowTop

open fun rowTop(): HorizontalGroup

scaleBy

open fun scaleBy(p0: Float)

open fun scaleBy(p0: Float, p1: Float)

screenToLocalCoordinates

open fun screenToLocalCoordinates(p0: Vector2): Vector2

scrollPane

inline fun <S> KWidget<S>.scrollPane(style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: KScrollPane.(S) -> Unit = {}): KScrollPane

selectBox

inline fun KWidget<*>.selectBox(style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: KSelectBox.() -> Unit = {}): KSelectBox

selectBoxOf

fun KWidget<*>.selectBoxOf(items: Array? = null, style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin): KSelectBox

setBounds

open fun setBounds(p0: Float, p1: Float, p2: Float, p3: Float)

setColor

open fun setColor(p0: Float, p1: Float, p2: Float, p3: Float)

setDebug

open fun setDebug(p0: Boolean, p1: Boolean)

setFillParent

open override fun setFillParent(p0: Boolean)

setLayoutEnabled

open override fun setLayoutEnabled(p0: Boolean)

setOrigin

open fun setOrigin(p0: Int)

open fun setOrigin(p0: Float, p1: Float)

setPosition

open fun setPosition(p0: Float, p1: Float)

open fun setPosition(p0: Float, p1: Float, p2: Int)

setRound

open fun setRound(p0: Boolean)

setScale

open fun setScale(p0: Float)

open fun setScale(p0: Float, p1: Float)

setSize

open fun setSize(p0: Float, p1: Float)

setX

open fun setX(p0: Float, p1: Int)

setY

open fun setY(p0: Float, p1: Int)

setZIndex

open fun setZIndex(p0: Int): Boolean

sizeBy

open fun sizeBy(p0: Float)

open fun sizeBy(p0: Float, p1: Float)

slider

inline fun <S> KWidget<S>.slider(min: Float = 0.0f, max: Float = 1.0f, step: Float = 0.01f, vertical: Boolean = false, style: String = if (vertical) defaultVerticalStyle else defaultHorizontalStyle, skin: Skin = Scene2DSkin.defaultSkin, init: Slider.(S) -> Unit = {}): Slider

space

open fun space(p0: Float): HorizontalGroup

splitPane

inline fun <S> KWidget<S>.splitPane(vertical: Boolean = false, style: String = if (vertical) defaultVerticalStyle else defaultHorizontalStyle, skin: Skin = Scene2DSkin.defaultSkin, init: KSplitPane.(S) -> Unit = {}): KSplitPane

stack

inline fun <S> KWidget<S>.stack(init: KStack.(S) -> Unit = {}): KStack

stageToLocalCoordinates

open fun stageToLocalCoordinates(p0: Vector2): Vector2

storeActor

open override fun <T : Actor> storeActor(actor: T): T

Internal utility method for adding actors to the group. Assumes the actor might be stored in a container.

swapActor

open fun swapActor(p0: Actor, p1: Actor): Boolean

open fun swapActor(p0: Int, p1: Int): Boolean

table

inline fun <S> KWidget<S>.table(skin: Skin = Scene2DSkin.defaultSkin, init: KTableWidget.(S) -> Unit = {}): KTableWidget

textArea

inline fun <S> KWidget<S>.textArea(text: String = "", style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: TextArea.(S) -> Unit = {}): TextArea

textButton

inline fun <S> KWidget<S>.textButton(text: String, style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: KTextButton.(S) -> Unit = {}): KTextButton

textField

inline fun <S> KWidget<S>.textField(text: String = "", style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: TextField.(S) -> Unit = {}): TextField

textTooltip

inline fun Actor.textTooltip(text: String, style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, tooltipManager: TooltipManager = TooltipManager.getInstance(), init: Label.(TextTooltip) -> Unit = {}): TextTooltip

Adds a new TextTooltip to this actor.

toBack

open fun toBack()

toFront

open fun toFront()

tooltip

inline fun Actor.tooltip(background: String? = null, skin: Skin = Scene2DSkin.defaultSkin, tooltipManager: TooltipManager = TooltipManager.getInstance(), init: KTableWidget.(Tooltip<KTableWidget>) -> Unit = {}): Tooltip<KTableWidget>

Adds a new Tooltip to this actor, storing a flexible Table widget.

top

open fun top(): HorizontalGroup

toString

open override fun toString(): String

touchpad

inline fun <S> KWidget<S>.touchpad(deadzone: Float, style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: Touchpad.(S) -> Unit = {}): Touchpad

tree

inline fun <S> KWidget<S>.tree(style: String = defaultStyle, skin: Skin = Scene2DSkin.defaultSkin, init: KTreeWidget.(S) -> Unit = {}): KTreeWidget

validate

open override fun validate()

verticalGroup

inline fun <S> KWidget<S>.verticalGroup(init: KVerticalGroup.(S) -> Unit = {}): KVerticalGroup

wrap

open fun wrap(): HorizontalGroup

open fun wrap(p0: Boolean): HorizontalGroup

wrapReverse

open fun wrapReverse(): HorizontalGroup

open fun wrapReverse(p0: Boolean): HorizontalGroup

wrapSpace

open fun wrapSpace(p0: Float): HorizontalGroup