All Implemented Interfaces:
```
public final class PolyUI

                    
```
PolyUI is a declarative UI framework developed for, and by Polyfrost.
It is designed to be lightweight, fast, extensible and easy to use, while still being very powerful. Make sure to check out the examples for more information.
PolyUI is split into two parts, being PolyUI and its logic, and it's accompanying Renderer implementation. This allows us to have PolyUI in many places, including inside Minecraft! It is declarative, meaning that you don't have to worry about the logic of the UI, just the layout and the components.
PolyUI has the policy of 'render what you need ONLY WHEN you need it'. Most of the time, PolyUI will be drawing frame buffers to the screen instead of drawing directly to the screen, as long as they are suitably complex for it to be worth it; or not drawing at all! This allows us to have a very fast rendering pipeline, and allows us to have a lot of components on screen at once, without a performance hit.
Rendering can be requested by components, and if so, it will be rendered during the next frame. This should only be requested if it is necessary, for example to do an animation or something.
During a render cycle, PolyUI will systematically go through every layout, and render it to its framebuffer or to the screen. Each layout will then render its components and child layouts, and so on. Rendering happens in three steps:
- preRender: This will do pre-rendering logic, such as setting up transformations, updating animations, and more.
- render: This is where the actual rendering happens.
- postRender: This will do post-rendering logic, such as cleaning up transformations.
Check out some components to see how this works.
Components are the interactive parts of the UI, such as buttons, text fields, etc.
Layouts are the containers for components, such as a grid layout, or a flex layout, etc. They are responsible for positioning and sizing the components.
Properties are the shared states or tokens for the components. They describe default values, and can be overridden by the components.
Interactions are driven by events, which thanks to Kotlin's inlining are a zero-overhead way of distributing events, such as mouse clicks, or key presses.
PolyUI also supports a variety of animations and transitions, which can be used to make your UI more dynamic, along with dynamically adding and removing components.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description

Field Summary

Fields
Modifier and Type	Field	Description
`public final static Logger`	`LOGGER`
`public static FontFamily`	`defaultFonts`
`public static Font`	`monospaceFont`
`public static PolyImage`	`defaultImage`
`public final static Byte`	`INIT_NOT_STARTED`
`public final static Byte`	`INIT_SETUP`
`public final static Byte`	`INIT_COMPLETE`
`private final Settings`	`settings`
`private Colors`	`colors`
`private FontFamily`	`fonts`
`private Window`	`window`
`private String`	`clipboard`
`private final PixelLayout`	`master`
`private final EventManager`	`eventManager`
`private final KeyBinder`	`keyBinder`
`private final Translator`	`translator`
`private final PropertyManager`	`propertyManager`
`private final Boolean`	`drew`
`private final Float`	`mouseX`
`private final Float`	`mouseY`
`private final Boolean`	`mouseDown`
`private Cursor`	`cursor`
`private Float`	`width`
`private Float`	`height`
`private final Long`	`delta`
`private Focusable`	`focused`
`private final Integer`	`fps`
`private final Float`	`longestFrame`
`private final Float`	`shortestFrame`
`private final Float`	`avgFrame`
`private final Renderer`	`renderer`

Constructor Summary

Constructors
Constructor	Description
`PolyUI(String translationDirectory, Renderer renderer, Settings settings, Colors colors, Drawable drawables)`
`PolyUI(String translationDirectory, Renderer renderer, Settings settings, Drawable drawables)`
`PolyUI(String translationDirectory, Renderer renderer, Drawable drawables)`
`PolyUI(Renderer renderer, Drawable drawables)`

Enum Constant Summary

Enum Constants
Enum Constant	Description

Method Summary

Modifier and Type	Method	Description
`final Settings`	`getSettings()`
`final Colors`	`getColors()`	Colors attached to this PolyUI instance.
`final Unit`	`setColors(Colors colors)`
`final FontFamily`	`getFonts()`	Fonts attached to this PolyUI instance.
`final Unit`	`setFonts(FontFamily fonts)`
`final Window`	`getWindow()`	The window this polyUI was opened with.
`final Unit`	`setWindow(Window window)`	The window this polyUI was opened with.
`final String`	`getClipboard()`
`final Unit`	`setClipboard(String clipboard)`
`final PixelLayout`	`getMaster()`	This is the root layout of the UI.
`final EventManager`	`getEventManager()`
`final KeyBinder`	`getKeyBinder()`
`final Translator`	`getTranslator()`
`final PropertyManager`	`getPropertyManager()`
`final Boolean`	`getDrew()`	weather this PolyUI instance drew on this frame.
`final Float`	`getMouseX()`
`final Float`	`getMouseY()`
`final Boolean`	`getMouseDown()`
`final Cursor`	`getCursor()`	The cursor currently being displayed.
`final Unit`	`setCursor(Cursor cursor)`
`final Float`	`getWidth()`
`final Unit`	`setWidth(Float width)`
`final Float`	`getHeight()`
`final Unit`	`setHeight(Float height)`
`final Long`	`getDelta()`	the time since the last frame, in nanoseconds.
`final Focusable`	`getFocused()`
`final Unit`	`setFocused(Focusable focused)`
`final Integer`	`getFps()`
`final Float`	`getLongestFrame()`
`final Float`	`getShortestFrame()`
`final Float`	`getAvgFrame()`
`final Renderer`	`getRenderer()`
`final Unit`	`resize(Integer newWidth, Integer newHeight, Float pixelRatio, Boolean force)`	Resize this PolyUI instance.
`final Unit`	`render()`
`final Unit`	`drawDebugOverlay(Float x, Float y)`	draw the debug overlay text.
`final Unit`	`addHook(Function1<Renderer, Boolean> func)`	add a function to be executed on the main thread, after rendering the UI.
`final PolyUI`	`removeComponent(Drawable drawable)`
`final PolyUI`	`addComponent(Drawable drawable)`
`final PolyUI`	`addComponents(Drawable drawables)`
`final PolyUI`	`addComponents(Collection<Drawable> drawables)`
`final PolyUI`	`every(Long nanos, Integer repeats, Function0<Unit> func)`	add a function that is called every nanos nanoseconds.
`final PolyUI`	`until(Long nanos, Long forNanos, Function0<Unit> func)`	Add a function that is called every nanos nanoseconds until forNanos nanoseconds have passed.
`final PolyUI`	`doWhile(Long everyNanos, Function0<Boolean> condition, Function0<Unit> func)`	Add a function that is called every everyNanos nanoseconds until condition returns true.
`final PolyUI`	`after(Long timeNanos, Function0<Unit> func)`	Add a function that is called after timeNanos nanoseconds.
`final ArrayList<Component>`	`getComponentsIn(Float x, Float y, Float width, Float height)`	Return all components in the given rectangle.
`final Boolean`	`focus(Focusable focusable)`	Sets the focus to the specified focusable element.
`final Boolean`	`unfocus()`
`final String`	`getKeyName(Integer key)`	Return the key name for the given key code.
`final String`	`debugPrint()`	print this PolyUI instance's components and children in a list, like this: PolyUI(800.0 x 800.0) with 0 components and 2 layouts: PixelLayout@5bcab519 [Draggable](20.0x570.0, 540.0 x 150.0) Text@6eebc39e(40.0x570.0, 520.0x32.0) Block@2f686d1f(40.0x600.0, 120.0x120.0) Block@7085bdee(220.0x600.0, 120.0x120.0) Image@6fd02e5(400.0x600.0, 120.0x120.0 (auto)) ... 2 more FlexLayout@73846619 [Scrollable](20.0x30.0, 693.73267 x 409.47168, buffered, needsRedraw) Block@32e6e9c3(20.0x30.0, 61.111263x42.21167) Block@5056dfcb(86.11127x30.0, 40.909004x76.32132) Block@6574b225(132.02026x30.0, 52.75415x52.59597) Block@2669b199(189.77441x30.0, 76.59671x45.275665) The string is also returned.
`final Long`	`timed(String msg, Function0<Unit> block)`	Time the block and return how long it took, as well as logging with the msg if debug is active.
`String`	`toString()`
`final Unit`	`cleanup()`	cleanup the polyUI instance.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

PolyUI

PolyUI(String translationDirectory, Renderer renderer, Settings settings, Colors colors, Drawable drawables)

PolyUI

PolyUI(String translationDirectory, Renderer renderer, Settings settings, Drawable drawables)

PolyUI

PolyUI(String translationDirectory, Renderer renderer, Drawable drawables)

PolyUI

PolyUI(Renderer renderer, Drawable drawables)

Method Detail

getSettings
```
 final Settings getSettings()
```

getColors
```
 final Colors getColors()
```
Colors attached to this PolyUI instance. This contains all the colors needed for the UI.
Note that changing this value can be an expensive operation while the UI is running, as it has to update all the components.

setColors
```
 final Unit setColors(Colors colors)
```

getFonts
```
 final FontFamily getFonts()
```
Fonts attached to this PolyUI instance. This contains all the colors needed for the UI.
Note that changing this value can be an expensive operation while the UI is running, as it has to update all the components.

setFonts
```
 final Unit setFonts(FontFamily fonts)
```

getWindow
```
 final Window getWindow()
```
The window this polyUI was opened with.

setWindow
```
 final Unit setWindow(Window window)
```
The window this polyUI was opened with.

getClipboard
```
 final String getClipboard()
```

setClipboard

 final Unit setClipboard(String clipboard)

getMaster
```
 final PixelLayout getMaster()
```
This is the root layout of the UI. It is the parent of all other layouts.

getEventManager
```
 final EventManager getEventManager()
```

getKeyBinder
```
 final KeyBinder getKeyBinder()
```

getTranslator
```
 final Translator getTranslator()
```

getPropertyManager

 final PropertyManager getPropertyManager()

getDrew
```
 final Boolean getDrew()
```
weather this PolyUI instance drew on this frame.
You can use this value to implement a 'render pausing' function, if you are using a dual-buffered rendering implementation (like OpenGL/GLFW) by enabling this flag:
if (polyUI.drew) glfwSwapBuffers(handle)
This is very handy as it will drastically reduce required system resources. If you are looking for more efficiency optimizations, see the settings for max fps and framebuffer settings.

getMouseX
```
 final Float getMouseX()
```

getMouseY
```
 final Float getMouseY()
```

getMouseDown
```
 final Boolean getMouseDown()
```

getCursor
```
 final Cursor getCursor()
```
The cursor currently being displayed.

setCursor
```
 final Unit setCursor(Cursor cursor)
```

getWidth
```
 final Float getWidth()
```

setWidth
```
 final Unit setWidth(Float width)
```

getHeight
```
 final Float getHeight()
```

setHeight
```
 final Unit setHeight(Float height)
```

getDelta
```
 final Long getDelta()
```
the time since the last frame, in nanoseconds. It is used internally a lot for animations, etc.

getFocused
```
 final Focusable getFocused()
```

setFocused

 final Unit setFocused(Focusable focused)

getFps
```
 final Integer getFps()
```

getLongestFrame
```
 final Float getLongestFrame()
```

getShortestFrame
```
 final Float getShortestFrame()
```

getAvgFrame
```
 final Float getAvgFrame()
```

getRenderer
```
 final Renderer getRenderer()
```

resize

 final Unit resize(Integer newWidth, Integer newHeight, Float pixelRatio, Boolean force)

Resize this PolyUI instance.

render
```
 final Unit render()
```

drawDebugOverlay
```
 final Unit drawDebugOverlay(Float x, Float y)
```
draw the debug overlay text. It is right-aligned.

addHook
```
 final Unit addHook(Function1<Renderer, Boolean> func)
```
add a function to be executed on the main thread, after rendering the UI. a renderer is provided if you want to do any rendering.

removeComponent

 final PolyUI removeComponent(Drawable drawable)

addComponent

 final PolyUI addComponent(Drawable drawable)

addComponents

 final PolyUI addComponents(Drawable drawables)

addComponents

 final PolyUI addComponents(Collection<Drawable> drawables)

every

 final PolyUI every(Long nanos, Integer repeats, Function0<Unit> func)

add a function that is called every nanos nanoseconds.

until
```
 final PolyUI until(Long nanos, Long forNanos, Function0<Unit> func)
```
Add a function that is called every nanos nanoseconds until forNanos nanoseconds have passed.

doWhile

 final PolyUI doWhile(Long everyNanos, Function0<Boolean> condition, Function0<Unit> func)

Add a function that is called every everyNanos nanoseconds until condition returns true.

after

 final PolyUI after(Long timeNanos, Function0<Unit> func)

Add a function that is called after timeNanos nanoseconds.

getComponentsIn

 final ArrayList<Component> getComponentsIn(Float x, Float y, Float width, Float height)

Return all components in the given rectangle.

focus
```
 final Boolean focus(Focusable focusable)
```
Sets the focus to the specified focusable element.

Parameters:

focusable - the element to set focus on

unfocus
```
 final Boolean unfocus()
```

getKeyName
```
 final String getKeyName(Integer key)
```
Return the key name for the given key code.

debugPrint

 final String debugPrint()

print this PolyUI instance's components and children in a list, like this:

PolyUI(800.0 x 800.0) with 0 components and 2 layouts:
  PixelLayout@5bcab519 [Draggable](20.0x570.0, 540.0 x 150.0)
	 Text@6eebc39e(40.0x570.0, 520.0x32.0)
	 Block@2f686d1f(40.0x600.0, 120.0x120.0)
	 Block@7085bdee(220.0x600.0, 120.0x120.0)
	 Image@6fd02e5(400.0x600.0, 120.0x120.0 (auto))
	 ... 2 more
  FlexLayout@73846619 [Scrollable](20.0x30.0, 693.73267 x 409.47168, buffered, needsRedraw)
	 Block@32e6e9c3(20.0x30.0, 61.111263x42.21167)
	 Block@5056dfcb(86.11127x30.0, 40.909004x76.32132)
	 Block@6574b225(132.02026x30.0, 52.75415x52.59597)
	 Block@2669b199(189.77441x30.0, 76.59671x45.275665)

The string is also returned.

timed
```
 final Long timed(String msg, Function0<Unit> block)
```
Time the block and return how long it took, as well as logging with the msg if debug is active.

toString
```
 String toString()
```

cleanup
```
 final Unit cleanup()
```
cleanup the polyUI instance. This will delete all resources, and render this instance unusable.

Class PolyUI

Nested Class Summary

Field Summary

Constructor Summary

Enum Constant Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

PolyUI

PolyUI

PolyUI

PolyUI

Method Detail

getSettings

getColors

setColors

getFonts

setFonts

getWindow

setWindow

getClipboard

setClipboard

getMaster

getEventManager

getKeyBinder

getTranslator

getPropertyManager

getDrew

getMouseX

getMouseY

getMouseDown

getCursor

setCursor

getWidth

setWidth

getHeight

setHeight

getDelta

getFocused

setFocused

getFps

getLongestFrame

getShortestFrame

getAvgFrame

getRenderer

resize

render

drawDebugOverlay

addHook

removeComponent

addComponent

addComponents

addComponents

every

until

doWhile

after

getComponentsIn

focus

unfocus

getKeyName

debugPrint

timed

toString

cleanup