KSplitPane

class KSplitPane(vertical: Boolean, skin: Skin, style: String) : SplitPane, KGroup

Extends SplitPane API with type-safe widget builders. Note that this widget may store only two children. It is advised to use the inlined extension factory methods added by KGroup rather than set its widgets directly with setFirstWidget or setSecondWidget.

Constructors

KSplitPane

constructor(vertical: Boolean, skin: Skin, style: String)

Properties

actions

val actions: Array<Action>

captureListeners

val captureListeners: DelayedRemovalArray<EventListener>

children

val children: SnapshotArray<Actor>

color

var color: Color

cullingArea

@Null

@get:Null

var cullingArea: Rectangle

cursorOverHandle

val cursorOverHandle: Boolean

debug

var debug: Boolean

height

var height: Float

listeners

val listeners: DelayedRemovalArray<EventListener>

name

@Null

@get:Null

var name: String

originX

var originX: Float

originY

var originY: Float

parent

@Null

@get:Null

var parent: Group

var rotation: Float

var scaleX: Float

var scaleY: Float

var splitAmount: Float

stage

@Null

@get:Null

var stage: Stage

style

var style: SplitPane.SplitPaneStyle

touchable

var touchable: Touchable

transform

var transform: Boolean

userObject

@Null

@get:Null

var userObject: Any

vertical

var vertical: Boolean

visible

var visible: Boolean

width

var width: Float

var x: Float

var y: Float

Functions

act

open override fun act(p0: Float)

actor

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

Utility function for adding existing actors to the group with a type-safe builder init block. Mostly for internal use.

addAction

open fun addAction(p0: Action)

addActor

open override fun addActor(actor: Actor?)

Matches Group.addActor API.

addActorAfter

open fun addActorAfter(p0: Actor, p1: Actor)

addActorAt

open override fun addActorAt(p0: Int, p1: Actor)

addActorBefore

open override fun addActorBefore(p0: Actor, p1: Actor)

addCaptureListener

open fun addCaptureListener(p0: EventListener): Boolean

addListener

open fun addListener(p0: EventListener): Boolean

ancestorsVisible

open fun ~~ancestorsVisible~~(): Boolean

ascendantsVisible

open fun ascendantsVisible(): Boolean

button

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

buttonGroup

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

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)

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

getMaxSplitAmount

open fun getMaxSplitAmount(): Float

getMaxWidth

open override fun getMaxWidth(): Float

getMinHeight

open override fun getMinHeight(): Float

getMinSplitAmount

open fun getMinSplitAmount(): Float

getMinWidth

open override fun getMinWidth(): Float

getPrefHeight

open override fun getPrefHeight(): Float

getPrefWidth

open override fun getPrefWidth(): Float

getRight

open fun getRight(): Float

getTop

open fun getTop(): Float

getX

open fun getX(p0: Int): Float

getY

open fun getY(p0: Int): Float

getZIndex

open fun getZIndex(): Int

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? = null, 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()

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()

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 override fun removeActor(p0: Actor): Boolean

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

removeActorAt

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

removeCaptureListener

open fun removeCaptureListener(p0: EventListener): Boolean

removeListener

open fun removeListener(p0: EventListener): Boolean

rotateBy

open fun rotateBy(p0: Float)

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)

setFirstWidget

open fun setFirstWidget(@Null p0: Actor)

setLayoutEnabled

open override fun setLayoutEnabled(p0: Boolean)

setMaxSplitAmount

open fun setMaxSplitAmount(p0: Float)

setMinSplitAmount

open fun setMinSplitAmount(p0: Float)

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)

setScale

open fun setScale(p0: Float)

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

setSecondWidget

open fun setSecondWidget(@Null p0: Actor)

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

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.

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