All Implemented Interfaces:

kotlin.Cloneable
```
public abstract class Layout
extends Drawable
                    
```
Layout is PolyUI's take on containers. They can contain components and other layouts, as children.
They can dynamically add and remove their children and components.
They are responsible for all their children's sizes, positions and rendering.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description

Field Summary

Fields
Modifier and Type	Field	Description
`public final static ArrayList<Component>`	`EMPTY_CMPLIST`
`public final static ArrayList<Layout>`	`EMPTY_CHLDLIST`
`private transient PropertyManager`	`propertyManager`
`private final transient Colors`	`colors`
`private final transient FontFamily`	`fonts`
`private final ArrayList<Component>`	`components`
`private final ArrayList<Layout>`	`children`
`private Boolean`	`consumesHover`
`private transient Boolean`	`needsRedraw`
`private Boolean`	`refuseFramebuffer`
`private transient Layout`	`layout`
`private final transient ArrayList<Function1<Layout, Unit>>`	`initCompleteHooks`
`private final transient Boolean`	`draggable`
`private Vec2<Unit>`	`visibleSize`
`private Vec2<Unit>`	`size`
`private final Boolean`	`resizesChildren`
`private final transient HashMap<Event, Function2<Drawable, Event, Boolean>>`	`eventHandlers`
`private transient String`	`simpleName`
`private transient Renderer`	`renderer`
`private transient PolyUI`	`polyUI`
`private Boolean`	`acceptsInput`
`private final transient Byte`	`initStage`
`private final transient Boolean`	`mouseOver`
`private Boolean`	`renders`
`private Float`	`x`
`private Float`	`y`
`private Float`	`width`
`private Float`	`height`
`private Boolean`	`exists`
`private transient Float`	`trueX`
`private transient Float`	`trueY`
`private final Unit.Type`	`atType`
`private final Unit.Type`	`sizeType`
`private final Boolean`	`isDynamic`
`private Double`	`rotation`
`private Double`	`skewX`
`private Double`	`skewY`
`private Float`	`scaleX`
`private Float`	`scaleY`
`private Float`	`alpha`
`private transient Float`	`acx`
`private transient Float`	`acy`
`private final Vec2<Unit>`	`at`
`private final Boolean`	`rawResize`

Constructor Summary

Constructors
Constructor	Description
`Layout(Vec2<Unit> at, Vec2<Unit> size, Function2<Drawable, Added, Unit> onAdded, Function2<Drawable, Removed, Unit> onRemoved, PropertyManager propertyManager, Boolean rawResize, Boolean resizesChildren, Boolean acceptInput, Drawable drawables)`

Enum Constant Summary

Enum Constants
Enum Constant	Description

Method Summary

Modifier and Type	Method	Description
`PropertyManager`	`getPropertyManager()`
`Unit`	`setPropertyManager(PropertyManager propertyManager)`
`final Colors`	`getColors()`
`final FontFamily`	`getFonts()`
`final ArrayList<Component>`	`getComponents()`
`final ArrayList<Layout>`	`getChildren()`
`Boolean`	`getConsumesHover()`	If this is `true`, the drawable will be the only drawable that is allowed to be hovered at once.
`Unit`	`setConsumesHover(Boolean consumesHover)`	If this is `true`, the drawable will be the only drawable that is allowed to be hovered at once.
`Boolean`	`getNeedsRedraw()`	Weather this layout needs redrawing.
`Unit`	`setNeedsRedraw(Boolean needsRedraw)`
`Boolean`	`getRefuseFramebuffer()`	set this to true if you want this layout to never use a framebuffer.
`Unit`	`setRefuseFramebuffer(Boolean refuseFramebuffer)`	set this to true if you want this layout to never use a framebuffer.
`final Layout`	`getLayout()`	reference to parent
`final Unit`	`setLayout(Layout layout)`
`final ArrayList<Function1<Layout, Unit>>`	`getInitCompleteHooks()`	These hooks are ran when the onInitComplete function is called.
`final Boolean`	`getDraggable()`	Flag that is true if the layout can be dragged around.
`final Vec2<Unit>`	`getVisibleSize()`	The visible area of this layout.
`final Unit`	`setVisibleSize(Vec2<Unit> visibleSize)`	The visible area of this layout.
`Vec2<Unit>`	`getSize()`	size of this drawable.
`Unit`	`setSize(Vec2<Unit> size)`	size of this drawable.
`final Boolean`	`getResizesChildren()`	If this layout resizes its children (components and layouts!
`Float`	`trueX()`	Calculate the true X value (i.e.
`Float`	`trueY()`	Calculate the true Y value (i.e.
`Unit`	`reRenderIfNecessary()`	this is the function that is called every frame.
`final Unit`	`onAll(Boolean onChildLayouts, Function1<Component, Unit> function)`	perform the given function on all this layout's components, and optionally on all child layouts.
`final Unit`	`onAllLayouts(Boolean reversed, Function1<Layout, Unit> function)`	perform the given function on all this layout's children and itself.
`final <T extends Drawable> T`	`get(String simpleName)`	return a component in this layout, by its simple name.
`final <T extends Component> T`	`getComponent(Integer index)`	Returns the component at the specified index.
`final <T extends Layout> T`	`getLayout(Integer index)`	Retrieves a layout from the children at the specified index.
`final <T extends Drawable> T`	`getOrNull(String simpleName)`	return a component in this layout, by its simple name.
`final Unit`	`add(Collection<Drawable> drawables)`	adds the given components/layouts to this layout.
`final Unit`	`add(Drawable components)`	adds the given components/layouts to this layout.
`Unit`	`add(Drawable drawable, Integer index)`	adds the given component/layout to this layout.
`Unit`	`remove(Drawable drawable)`	removes a component from this layout.
`Unit`	`remove(Integer index)`	Removes a component from this layout at the specified index.
`Unit`	`removeNow(Integer index)`	Removes a component from this layout immediately.
`Unit`	`removeNow(Drawable drawable)`	removes a component immediately, without waiting for it to finish up.
`Unit`	`calculateBounds()`	Calculate the position and size of this drawable.
`Unit`	`onInitComplete()`	This function is called when initialization of a drawable is complete, so it has been fully calculated.
`Unit`	`rescale(Float scaleX, Float scaleY)`	Method that is called when the physical size of the total window area changes.
`Unit`	`render()`	render this layout's components, and remove them if they are ready to be removed.
`final Integer`	`countDrawables()`	count the amount of drawables this contains, including the drawables its children have
`Unit`	`debugPrint()`	debug print for this drawable.
`Unit`	`debugRender()`	add a debug render overlay for this drawable.
`Unit`	`setup(Renderer renderer, PolyUI polyUI)`	give this a renderer reference and a PolyUI reference.
`Unit`	`clipDrawables()`	This function will enable/disable rendering of drawables inside this layout based on their position and size.
`Boolean`	`isInside(Float x, Float y)`
`Boolean`	`isInside(Float x, Float y, Float width, Float height)`
`Boolean`	`intersects(Float x, Float y, Float width, Float height)`
`final Unit`	`changeColors(Colors colors)`
`final Unit`	`changeFonts(FontFamily fonts)`
`Unit`	`onColorsChanged(Colors colors)`	Function that is called when the colors attached to this drawable change.
`Unit`	`onFontsChanged(FontFamily fonts)`	Function that is called when the fonts attached to this drawable change.
`final Unit`	`reset()`	Use this function to reset your drawable's PolyText if it is using one.
`final Layout`	`every(Long nanos, Integer repeats, Function1<Layout, Unit> func)`	add a function that is called every nanos nanoseconds.
`String`	`toString()`
`final Layout`	`draggable()`	Makes the layout draggable.
`final Layout`	`scrolling(Vec2<Unit> size, Boolean withScrollbars)`	add scrolling functionality to the layout and optionally scrollbars.
`final Layout`	`background(Boolean transparent, Boolean drags, FloatArray cornerRadii)`	Adds a background block to the layout.
`final static Array<out Drawable>`	`drawables(Drawable drawables)`	wrapper for varargs, when arguments are in the wrong order

Methods inherited from class org.polyfrost.polyui.component.Drawable
accept, addEventHandler, addEventhandler, addOperation, animateBy, animateTo, calculateSize, canBeRemoved, clone, doDynamicSize, events, fadeBy, fadeTo, getAcceptsInput, getAcx, getAcy, getAlpha, getAt, getAtType, getContainingLayout, getEventHandlers, getExists, getHeight, getInitStage, getMouseOver, getPolyUI, getRawResize, getRenderer, getRenders, getRotation, getScaleX, getScaleY, getSimpleName, getSizeType, getSkewX, getSkewY, getTrueX, getTrueY, getWidth, getX, getY, isDynamic, moveBy, moveTo, onParentInitComplete, postRender, preRender, removeOperation, resize, rotateBy, rotateTo, scaleBy, scaleTo, setAcceptsInput, setAcx, setAcy, setAlpha, setExists, setHeight, setPolyUI, setRenderer, setRenders, setRotation, setScaleX, setScaleY, setSimpleName, setSkewX, setSkewY, setTrueX, setTrueY, setWidth, setX, setY, skewBy, skewTo
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Layout
```
Layout(Vec2<Unit> at, Vec2<Unit> size, Function2<Drawable, Added, Unit> onAdded, Function2<Drawable, Removed, Unit> onRemoved, PropertyManager propertyManager, Boolean rawResize, Boolean resizesChildren, Boolean acceptInput, Drawable drawables)
```
- Method Detail
  - getPropertyManager
```
 PropertyManager getPropertyManager()
```
  - setPropertyManager
```
 Unit setPropertyManager(PropertyManager propertyManager)
```
  - getColors
```
 final Colors getColors()
```
  - getFonts
```
 final FontFamily getFonts()
```
  - getComponents
```
 final ArrayList<Component> getComponents()
```
  - getChildren
```
 final ArrayList<Layout> getChildren()
```
  - getConsumesHover
```
 Boolean getConsumesHover()
```
    If this is true, the drawable will be the only drawable that is allowed to be hovered at once.
    There are essentially two modes for hovering in PolyUI, and by default, components are in the "normal" (false) mode, where only one of them can be hovered as once as would be expected, but layouts are in the "group" (true) mode, so will still receive the events even if another drawable is hovered, for example scrolling.
  - setConsumesHover
```
 Unit setConsumesHover(Boolean consumesHover)
```
    If this is true, the drawable will be the only drawable that is allowed to be hovered at once.
    There are essentially two modes for hovering in PolyUI, and by default, components are in the "normal" (false) mode, where only one of them can be hovered as once as would be expected, but layouts are in the "group" (true) mode, so will still receive the events even if another drawable is hovered, for example scrolling.
  - getNeedsRedraw
```
 Boolean getNeedsRedraw()
```
    Weather this layout needs redrawing.
  - setNeedsRedraw
```
 Unit setNeedsRedraw(Boolean needsRedraw)
```
  - getRefuseFramebuffer
```
 Boolean getRefuseFramebuffer()
```
    set this to true if you want this layout to never use a framebuffer. Recommended in situations with chroma colors
  - setRefuseFramebuffer
```
 Unit setRefuseFramebuffer(Boolean refuseFramebuffer)
```
    set this to true if you want this layout to never use a framebuffer. Recommended in situations with chroma colors
  - getLayout
```
 final Layout getLayout()
```
    reference to parent
  - setLayout
```
 final Unit setLayout(Layout layout)
```
  - getInitCompleteHooks
```
 final ArrayList<Function1<Layout, Unit>> getInitCompleteHooks()
```
    These hooks are ran when the onInitComplete function is called.
  - getDraggable
```
 final Boolean getDraggable()
```
    Flag that is true if the layout can be dragged around.
  - getVisibleSize
```
 final Vec2<Unit> getVisibleSize()
```
    The visible area of this layout. If this is set, it is used for isInside checks.
    If this layout is a scrolling layout, this is the size of the scrollable area.
  - setVisibleSize
```
 final Unit setVisibleSize(Vec2<Unit> visibleSize)
```
    The visible area of this layout. If this is set, it is used for isInside checks.
    If this layout is a scrolling layout, this is the size of the scrollable area.
  - getSize
```
 Vec2<Unit> getSize()
```
    size of this drawable.
  - setSize
```
 Unit setSize(Vec2<Unit> size)
```
    size of this drawable.
  - getResizesChildren
```
 final Boolean getResizesChildren()
```
    If this layout resizes its children (components and layouts!) when it is resized.
  - trueX
```
 Float trueX()
```
    Calculate the true X value (i.e. not relative to the layout)
    This method will NOT assign the value to the trueX field.
  - trueY
```
 Float trueY()
```
    Calculate the true Y value (i.e. not relative to the layout)
    This method will NOT assign the value to the trueY field.
  - reRenderIfNecessary
```
 Unit reRenderIfNecessary()
```
    this is the function that is called every frame. It decides whether the layout needs to be entirely re-rendered. If so, the render function is called which will redraw all its' and components, and this function will redraw all its child layouts as well.
    If this layout is using a framebuffer, it will be drawn to the framebuffer, and then drawn to the screen.
    Note: Do not call this function yourself.
  - onAll
```
 final Unit onAll(Boolean onChildLayouts, Function1<Component, Unit> function)
```
    perform the given function on all this layout's components, and optionally on all child layouts.
  - onAllLayouts
```
 final Unit onAllLayouts(Boolean reversed, Function1<Layout, Unit> function)
```
    perform the given function on all this layout's children and itself.
  - get
```
 final <T extends Drawable> T get(String simpleName)
```
    return a component in this layout, by its simple name. This can be accessed using debugPrint or using the field.
    Note that the simpleName is NOT consistent between updates to PolyUI, or changes to the content of the layout.
  - getComponent
```
 final <T extends Component> T getComponent(Integer index)
```
    Returns the component at the specified index.
    
    Parameters:
    
    index - The index of the component to retrieve.
  - getLayout
```
 final <T extends Layout> T getLayout(Integer index)
```
    Retrieves a layout from the children at the specified index.
    
    Parameters:
    
    index - The index of the layout to retrieve.
  - getOrNull
```
 final <T extends Drawable> T getOrNull(String simpleName)
```
    return a component in this layout, by its simple name. This can be accessed using debugPrint or using the field.
    Note that the simpleName is NOT consistent between updates to PolyUI, or changes to the content of the layout. Returns null if not found.
  - add
```
 final Unit add(Collection<Drawable> drawables)
```
    adds the given components/layouts to this layout.
    this will add the drawables to the Layout.components or children list, and invoke its added event function.
  - add
```
 final Unit add(Drawable components)
```
    adds the given components/layouts to this layout.
    this will add the drawables to the Layout.components or children list, and invoke its added event function.
  - add
```
 Unit add(Drawable drawable, Integer index)
```
    adds the given component/layout to this layout.
    this will add the drawable to the Layout.components or children list, and invoke its Added if it is present.
  - remove
```
 Unit remove(Drawable drawable)
```
    removes a component from this layout.
    this will add the component to the removal queue, and invoke its removal event function.
    This removal queue is used so that component can finish up any animations they're doing before being removed.
  - remove
```
 Unit remove(Integer index)
```
    Removes a component from this layout at the specified index.
    
    Parameters:
    
    index - The index of the component to be removed.
  - removeNow
```
 Unit removeNow(Integer index)
```
    Removes a component from this layout immediately.
    
    Parameters:
    
    index - The index of the component to be removed.
  - removeNow
```
@ApiStatus.Internal() Unit removeNow(Drawable drawable)
```
    removes a component immediately, without waiting for it to finish up.
    This is marked as internal because you should be using remove for most cases to remove a component, as it waits for it to finish and play any removal animations.
  - calculateBounds
```
 Unit calculateBounds()
```
    Calculate the position and size of this drawable. Make sure to call doDynamicSize in this method to avoid issues with sizing.
    This method is called once the layout is populated for children and component, and when a recalculation is requested.
    The value of layout's bounds will be updated after this method is called, so do not use layout's bounds as an updated value in this method.
  - onInitComplete
```
 Unit onInitComplete()
```
    This function is called when initialization of a drawable is complete, so it has been fully calculated.
    This function is called once, and only once.
  - rescale
```
 Unit rescale(Float scaleX, Float scaleY)
```
    Method that is called when the physical size of the total window area changes.
  - render
```
 Unit render()
```
    render this layout's components, and remove them if they are ready to be removed.
  - countDrawables
```
 final Integer countDrawables()
```
    count the amount of drawables this contains, including the drawables its children have
  - debugPrint
```
 Unit debugPrint()
```
    debug print for this drawable.
  - debugRender
```
 Unit debugRender()
```
    add a debug render overlay for this drawable. This is always rendered regardless of the layout re-rendering if debug mode is on.
  - setup
```
 Unit setup(Renderer renderer, PolyUI polyUI)
```
    give this a renderer reference and a PolyUI reference.
    You can also use this method to do some calculations (such as text widths) that are not dependent on other sizes.
    If you need a method that has access to component's sizes, see here or here (if you are operating on yourself only).
    this method is called once, and only once.
  - clipDrawables
```
 Unit clipDrawables()
```
    This function will enable/disable rendering of drawables inside this layout based on their position and size.
    If they lie outside the bounds of this layout, they will not be drawn to save resources.
  - isInside
```
 Boolean isInside(Float x, Float y)
```
  - isInside
```
 Boolean isInside(Float x, Float y, Float width, Float height)
```
  - intersects
```
 Boolean intersects(Float x, Float y, Float width, Float height)
```
  - changeColors
```
 final Unit changeColors(Colors colors)
```
  - changeFonts
```
 final Unit changeFonts(FontFamily fonts)
```
  - onColorsChanged
```
 Unit onColorsChanged(Colors colors)
```
    Function that is called when the colors attached to this drawable change.
    If this is a layout, the colors will change, and all its children and components will be notified and updated accordingly.
    Make sure to call super.onColorsChanged() if you override this!
  - onFontsChanged
```
 Unit onFontsChanged(FontFamily fonts)
```
    Function that is called when the fonts attached to this drawable change.
    If this is a layout, the fonts will change, and all its children and components will be notified and updated accordingly.
    Make sure to call super.onFontsChanged() if you override this!
  - reset
```
 final Unit reset()
```
    Use this function to reset your drawable's PolyText if it is using one.
  - every
```
 final Layout every(Long nanos, Integer repeats, Function1<Layout, Unit> func)
```
    add a function that is called every nanos nanoseconds.
  - toString
```
 String toString()
```
  - draggable
```
 final Layout draggable()
```
    Makes the layout draggable.
    When the layout is made draggable, it can be moved around by dragging it with the mouse. This method adds an internal block component to the layout that handles the dragging functionality.
    This function should only be called in the initialization of your layout, and not programmatically.
  - scrolling
```
 final Layout scrolling(Vec2<Unit> size, Boolean withScrollbars)
```
    add scrolling functionality to the layout and optionally scrollbars.
    
    Parameters:
    
    size - the scrollable area to set.
  - background
```
 final Layout background(Boolean transparent, Boolean drags, FloatArray cornerRadii)
```
    Adds a background block to the layout.
    While there is nothing stopping you adding a background more than once, don't do it. It will cause problems.
    
    Parameters:
    
    transparent - whether the background should be transparent or not.
    
    drags - whether this background should handle dragging the layout around.
  - drawables
```
 final static Array<out Drawable> drawables(Drawable drawables)
```
    wrapper for varargs, when arguments are in the wrong order

Class Layout

Nested Class Summary

Field Summary

Constructor Summary

Enum Constant Summary

Method Summary

Methods inherited from class org.polyfrost.polyui.component.Drawable

Methods inherited from class java.lang.Object

Constructor Detail

Layout

Method Detail

getPropertyManager

setPropertyManager

getColors

getFonts

getComponents

getChildren

getConsumesHover

setConsumesHover

getNeedsRedraw

setNeedsRedraw

getRefuseFramebuffer

setRefuseFramebuffer

getLayout

setLayout

getInitCompleteHooks

getDraggable

getVisibleSize

setVisibleSize

getSize

setSize

getResizesChildren

trueX

trueY

reRenderIfNecessary

onAll

onAllLayouts

get

getComponent

getLayout

getOrNull

add

add

add

remove

remove

removeNow

removeNow

calculateBounds

onInitComplete

rescale

render

countDrawables

debugPrint

debugRender

setup

clipDrawables

isInside

isInside

intersects

changeColors

changeFonts

onColorsChanged

onFontsChanged

reset

every

toString

draggable

scrolling

background

drawables