polyui/org.polyfrost.polyui.component

Package-level declarations

Types

abstract class Component(at: Vec2, size: Vec2, val alignment: Align = AlignDefault)

Component is the base class of everything on the screen in PolyUI.

abstract class Drawable(children: Component? = arrayOf(), at: Vec2 = Vec2.ZERO, val alignment: Align = AlignDefault, size: Vec2 = Vec2.ZERO, visibleSize: Vec2 = Vec2.ZERO, palette: Colors.Palette? = null, val focusable: Boolean = false) : Scrollable, Cloneable

The most basic thing in the PolyUI rendering system.

Inputtable

abstract class Inputtable(at: Vec2, size: Vec2, val alignment: Align, val focusable: Boolean) : Component

Extensions to Component which allow it to send and receive events.

Positioner

fun interface Positioner

Positioning strategies are the methods used in PolyUI to place both components across the screen, and components inside a layout.

Scrollable

abstract class Scrollable(at: Vec2, size: Vec2, visibleSize: Vec2, val alignment: Align, val focusable: Boolean) : Inputtable

Extensions to Component which allow it to listen to scroll events and scroll itself.

Properties

MIN_DRAG

const val MIN_DRAG: Float = 3.0f

Functions

add3dEffect

fun <S : Drawable> S.add3dEffect(xIntensity: Double = 0.05, yIntensity: Double = 0.05): S

Add a 3D hover effect to the specified drawable which slightly skews the object as the mouse moves across it, giving the appearance of it popping off the screen.

addHoverInfo

@JvmName(name = "addHoverInfo")

fun <S : Inputtable> S.addHoverInfo(vararg drawables: Drawable?, size: Vec2 = Vec2.ZERO, align: Align = AlignDefault, position: Point = Point.Above): S

Add some text that is shown when the mouse is left still over this drawable for 1 second or more.

afterInit

fun <S : Inputtable> S.afterInit(function: S.(Event.Lifetime.PostInit) -> Unit): S

afterParentInit

fun <S : Inputtable> S.afterParentInit(depth: Int = 1, handler: S.() -> Unit): S

Add an event handler to this drawable's parent, and (optionally) it's parent's parent (depth).

animateBy

@JvmName(name = "animateBy")

fun Drawable.animateBy(at: Vec2 = Vec2.ZERO, size: Vec2 = Vec2.ZERO, rotation: Double = 0.0, scaleX: Float = 0.0f, scaleY: Float = 0.0f, skewX: Double = 0.0, skewY: Double = 0.0, color: PolyColor? = null, animation: Animation? = null)

Bulk add method for all the builtin drawable operations in PolyUI.

animateTo

@JvmName(name = "animateTo")

fun Drawable.animateTo(at: Vec2 = this.at, size: Vec2 = this.size, rotation: Double = this.rotation, skewX: Double = this.skewX, skewY: Double = this.skewY, scaleX: Float = this.scaleX, scaleY: Float = this.scaleY, color: PolyColor = this.color, animation: Animation? = null)

Bulk add method for all the builtin drawable operations in PolyUI.

countChildren

fun Component.countChildren(): Int

Returns a count of this component's children, including children of children.

disable

fun <S : Inputtable> S.disable(state: Boolean = true): S

dontScroll

fun <S : Scrollable> S.dontScroll(): S

Instruct this component to refuse scrolling even if it needs to be.

draggable

fun <S : Inputtable> S.draggable(withX: Boolean = true, withY: Boolean = true, free: Boolean = false, onStart: S.() -> Unit? = null, onDrag: S.() -> Unit? = null, onDrop: S.() -> Unit? = null): S

Make this component draggable.

ensureLargerThan

@JvmName(name = "ensureLargerThan")

fun <S : Component> S.ensureLargerThan(vec: Vec2)

events

inline fun <S : Inputtable> S.events(dsl: EventDSL<S>.() -> Unit): S

fade

fun <S : Drawable> S.fade(in: Boolean, durationNanos: Long = 0.1.seconds): S

Fade this drawable in or out, with a given duration.

fadeIn

fun <S : Drawable> S.fadeIn(durationNanos: Long = 0.1.seconds): S

Alias for fade.

fadeOut

fun <S : Drawable> S.fadeOut(durationNanos: Long = 0.1.seconds): S

Alias for fade.

fix

fun <S : Component> S.fix(): S

hasChildIn

fun Component.hasChildIn(x: Float, y: Float, width: Float, height: Float): Boolean

hide

fun <S : Component> S.hide(state: Boolean = true): S

ignoreLayout

fun <S : Component> S.ignoreLayout(state: Boolean = true): S

Specify that this component should be ignored during the layout stage.

isChildOf

fun Component.isChildOf(component: Component?): Boolean

Returns true if this component is a child of the specified component.

isRelatedTo

fun Component.isRelatedTo(component: Component?): Boolean

Returns true if this component is a child of the specified component, or if the component is a child of this.

locate

fun <S : Component> Component.locate(id: String): S?

Locate a component by its name.

minimumSize

@JvmName(name = "minimumSize")

fun <S : Scrollable> S.minimumSize(size: Vec2): S

Specify a minimum size for this component. Note that this will also disable scrolling due to optimizations.

named

fun <S : Component> S.named(name: String): S

namedId

fun <S : Component> S.namedId(name: String): S

numeric

fun <S : TextInput> S.numeric(min: Float = 0.0f, max: Float = 100.0f, integral: Boolean = false): S

Make this TextInput only accept numbers between min and max. It will then dispatch a Event.Change.Number event.

onChange

@JvmName(name = "onChangeState")

fun <S : Inputtable> S.onChange(func: S.(Boolean) -> Boolean): S

Add a listener for changes to the given Boolean-type property.

@JvmName(name = "onChangeNumber")

fun <S : Inputtable> S.onChange(func: S.(Float) -> Boolean): S

Add a listener for changes to the given Float-type property.

@JvmName(name = "onChangeIndex")

fun <S : Inputtable> S.onChange(func: S.(Int) -> Boolean): S

Add a listener for changes to the given Int-type property.

@JvmName(name = "onChangeString")

fun <S : Inputtable> S.onChange(func: S.(String) -> Boolean): S

Add a listener for changes to the given String-type property.

onClick

@JvmName(name = "onClickZ")

fun <S : Inputtable> S.onClick(func: S.(Event.Mouse.Clicked) -> Boolean): S

fun <S : Inputtable> S.onClick(func: S.(Event.Mouse.Clicked) -> Unit): S

onDrag

fun <S : Inputtable> S.onDrag(func: S.(Event.Mouse.Dragged) -> Unit): S

onInit

fun <S : Inputtable> S.onInit(function: S.(Event.Lifetime.Init) -> Unit): S

onPress

fun <S : Inputtable> S.onPress(func: S.(Event.Mouse.Pressed) -> Unit): S

onToggle

fun <S : Inputtable> S.onToggle(func: S.(Boolean) -> Unit): S

Use this to add a simple listener for the Event.Change.State event.

padded

fun <S : Component> S.padded(padding: Vec4): S

fun <S : Component> S.padded(xPad: Float, yPad: Float): S

fun <S : Component> S.padded(left: Float, top: Float, right: Float, bottom: Float): S

prioritize

@ApiStatus.Experimental

fun <S : Component> S.prioritize(): S

Prioritize this component, meaning it will, in relation to its siblings:

radii

fun <S : Block> S.radii(radii: FloatArray): S

fun <S : Block> S.radii(topLeftRadius: Float, topRightRadius: Float, bottomLeftRadius: Float, bottomRightRadius: Float): S

radius

fun <S : Block> S.radius(radius: Float): S

relegate

@ApiStatus.Experimental

fun <S : Component> S.relegate(): S

Relegate this component, meaning it will, in relation to its siblings:

secondary

fun <S : Text> S.secondary(): S

setAlpha

fun <S : Drawable> S.setAlpha(alpha: Float): S

setDestructivePalette

fun <S : Drawable> S.setDestructivePalette(): S

setFont

fun <S : Text> S.setFont(font: FontFamily.() -> Font): S

Set the font of this text component during initialization, using the PolyUI fonts instance.

setPalette

fun <S : Drawable> S.setPalette(palette: Colors.() -> Colors.Palette): S

Set the color palette of this drawable during initialization, using the PolyUI colors instance.

fun <S : Drawable> S.setPalette(palette: Colors.Palette): S

setState

fun <S : Drawable> S.setState(state: Byte): S

Set the palette of this drawable according to one of the three possible component states in PolyUI.

shake

fun <S : Component> S.shake(): S

toggleable

fun <S : Drawable> S.toggleable(default: Boolean): S

Make this drawable toggleable, meaning that, when clicked:

withBoarder

fun <S : Block> S.withBoarder(width: Float = 1.0f, color: Colors.() -> PolyColor = { page.border5 }): S

fun <S : Block> S.withBoarder(color: PolyColor, width: Float = 1.0f): S

withCursor

fun <S : Drawable> S.withCursor(cursor: Cursor = Cursor.Clicker): S

withStates

fun <S : Drawable> S.withStates(): S

fun <S : Drawable> S.withStates(consume: Boolean = false, showClicker: Boolean = true, animation: () -> Animation? = { Animations.Default.create(0.08.seconds) }): S