GridLayout (easel 0.0.2 API)

java.lang.Object
- easel.ui.AbstractWidget<GridLayout>
- - easel.ui.layouts.GridLayout

```
public final class GridLayout
extends AbstractWidget<GridLayout>
```
UNSTABLE / API subject to change. A more powerful layout to aid arranging things in a grid. Since this class is probably going to be redesigned before the first official release, this documentation will remain unfinished until the API is more stable. For now, the general pattern to use this layout is to construct a new Grid, set up the rows/columns by calling one of withExactRows(float...), withNEvenlySizedRows(float, int), etc. and one of withExactCols(float...), withRelativeCols(float, float...), etc. (use one of the row builders to initialize the rows and one of the column builders for the columns). After that, you may add children using the convenience methods withChildrenInRow(int, AbstractWidget[]) or by directly specifying the cell withChild(int, int, AbstractWidget) it falls into. (Row 0, Column 0) is the top left corner and the grid layout grows down and to the right of that, and when specifying widgets to go into certain cells you must be careful to place them into positions that actually exist from your initialized version in order for the grid to function properly. Finally, when you call an AbstractWidget.anchoredAt(float, float, AnchorPosition), the children are all moved into place. Like other layouts, you can automatically scale rows or columns using the various helper methods, (e.g. resizeRowToFitTallestChild(int)), and managing the usual suspects (render, update, etc.) is as simple as calling those functions on the layout itself (as everything will trickle down the hierarchy as usual).

Field Summary
- Fields inherited from class easel.ui.AbstractWidget
  hasInteractivity, hb, isHovered, leftClickStarted, onLeftClick, onMouseEnter, onMouseLeave, onRightClick, rightClickStarted

Constructor Summary

Constructors
Constructor and Description

GridLayout()

Constructors
Constructor and Description
`GridLayout()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`GridLayout`	`anchoredAt(float x, float y, AnchorPosition anchorPosition, InterpolationSpeed movementSpeed)` Moves the widget towards a specific spot.
`protected void`	`cancelMovementQueueForAllChildren(boolean shouldTryAndResolveOneLastTime)`
`void`	`clear()`
`float`	`getContentHeight()` The internal content height of the widget (excludes margins).
`float`	`getContentWidth()` The internal content width of the widget (excludes margins).
`void`	`hide()`
`java.util.stream.Stream<AbstractWidget>`	`iterator()` The ordering of this stream is dependent on the underlying map (which does not have a predictable order).
`java.util.stream.Stream<easel.ui.layouts.LayoutItem>`	`iteratorByCol(int col)` Returns all children in the given column, in no particular order.
`<T> java.util.stream.Stream<T>`	`iteratorByColOfType(int col, java.lang.Class<T> clz)` Returns all children in the given column of a particular type, in no particular order.
`java.util.stream.Stream<easel.ui.layouts.LayoutItem>`	`iteratorByRow(int row)` Returns all children in the given row, in no particular order.
`<T> java.util.stream.Stream<T>`	`iteratorByRowOfType(int row, java.lang.Class<T> clz)` Returns all children in the given row of a particular type, in no particular order.
`<T> java.util.stream.Stream<T>`	`iteratorOfType(java.lang.Class<T> clz)` A stream of children handled by this widget who are of the specific type, for convenience purposes.
`void`	`renderTopLevel(com.badlogic.gdx.graphics.g2d.SpriteBatch sb)` Renders top level (especially tooltip) effects.
`protected void`	`renderWidget(com.badlogic.gdx.graphics.g2d.SpriteBatch sb)` Custom widgets should implement this method for rendering.
`GridLayout`	`resizeColsToFitWidestChildren()`
`GridLayout`	`resizeColToFitWidestChild(int col)`
`GridLayout`	`resizeRowsToFitTallestChildren()`
`GridLayout`	`resizeRowToFitTallestChild(int row)`
`protected void`	`setChildrenDelayedMovement(float deltaX, float deltaY, InterpolationSpeed movementSpeed, long startingTimeMillis)` For use with `AbstractWidget.delayedTranslate(float, float, InterpolationSpeed, long)`.
`void`	`show()`
`void`	`updateWidget()` Required for interactive components.
`GridLayout`	`withChild(int row, int col, AbstractWidget widget)` Let this grid manage the given widget.
`GridLayout`	`withChild(int row, int col, AbstractWidget widget, AnchorPosition anchorPosition)` Let this grid manage the given widget.
`GridLayout`	`withChildrenInCol(int col, AbstractWidget... widgets)` Adds the provided children to the specified column, starting at row 0.
`GridLayout`	`withChildrenInRow(int row, AbstractWidget... widgets)` Adds the provided children to the specified row, starting at column 0.
`GridLayout`	`withDefaultChildAnchorPosition(AnchorPosition anchorPosition)`
`GridLayout`	`withExactCols(float... widths)` Sets the widths of each column to an exact pixel value.
`GridLayout`	`withExactRows(float... heights)` Sets the heights of each row to an exact pixel value.
`GridLayout`	`withNEvenlySizedCols(float totalWidth, int numCols)` Makes `numCols` evenly sized columns.
`GridLayout`	`withNEvenlySizedRows(float totalHeight, int numRows)` Makes `numRows` evenly sized rows.
`GridLayout`	`withRelativeCols(float totalWidth, float... widthRatios)` Sets the column widths relative to each other as a fraction of some given `totalWidth`.
`GridLayout`	`withRelativeRows(float totalHeight, float... heightRatios)` Sets the row heights relative to each other as a fraction of some given `totalHeight`.
`GridLayout`	`withRowsCols(float totalWidth, float totalHeight, int numRows, int numCols)` Makes evenly distributed rows/cols for a certain width and height.

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

- Constructor Detail
  - GridLayout
```
public GridLayout()
```
- Method Detail
  - withDefaultChildAnchorPosition
```
public GridLayout withDefaultChildAnchorPosition(AnchorPosition anchorPosition)
```
  - clear
```
public void clear()
```
  - withExactRows
```
public GridLayout withExactRows(float... heights)
```
    Sets the heights of each row to an exact pixel value. Each argument to this function produces a row in the grid with the given height. The following example makes the grid have three rows, where the top-most row is given a height of 100px, the middle row 200px, and the bottom row 300px:
```
 
 grid.withExactRows(100.0f, 200.0f, 300.0f);
 
 
```
    NOTE: using negative values for a row height lets the layout overlap multiple rows (usually undesired behavior).
    Parameters:
    
    heights - a list of heights for row 0, row 1, row 2, etc., where row 0 is the top-most row. Heights are assumed to be in 1080p space.
    
    Returns:
    
    this
    
    See Also:
    
    withExactCols(float...), withRelativeRows(float, float...), withNEvenlySizedRows(float, int)
  - withExactCols
```
public GridLayout withExactCols(float... widths)
```
    Sets the widths of each column to an exact pixel value. Each argument to this function produces a column in the grid with the given width. The following example makes the grid have three columns, where the left-most column is given a width of 100px, the middle column 200px, and the right-most row 300px:
```
 
 grid.withExactCols(100.0f, 200.0f, 300.0f);
 
 
```
    NOTE: using negative values for a column width lets the layout overlap multiple columns (usually undesired behavior).
    Parameters:
    
    widths - a list of widths for column 0, column 1, column 2, etc., where column 0 is the left-most column. Widths are assumed to be in 1080p space.
    
    Returns:
    
    this
    
    See Also:
    
    withExactRows(float...), withRelativeCols(float, float...), withNEvenlySizedCols(float, int)
  - withRelativeRows
```
public GridLayout withRelativeRows(float totalHeight,
                                   float... heightRatios)
```
    Sets the row heights relative to each other as a fraction of some given totalHeight. Each argument in the heightRatios variadic list produces a row in the final grid. The following example makes the grid have three rows, where the top-most row is considered the "baseline" height with the middle row being twice as tall and the bottom row being half as tall. With a totalHeight of 350px, this results in row heights being 100px, 200px, and 50px respectively.
```
 
 grid.withRelativeRows(350.0f, 1f, 2f, 0.5f);
 
 
```
    The portion of the total height allotted to each row is entirely relative, so these will both produce 100px tall rows:
```
 
 grid.withRelativeRows(300.0f, 0.2f, 0.2f, 0.2f);
 grid.withRelativeRows(300.0f, 1f, 1f, 1f);
 
 
```
    Given ratios (x, y, z), the space allotted for row x is simply totalHeight * (x / (x + y + z)) Note: undefined behavior if supplied negative or zero ratios
    Parameters:
    
    totalHeight - the total space allotted for all rows combined
    
    heightRatios - a list of ratios used to divide up the totalHeight in a relative manner
    
    Returns:
    
    this
    
    See Also:
    
    withRelativeCols(float, float...), withExactRows(float...), withNEvenlySizedRows(float, int)
  - withRelativeCols
```
public GridLayout withRelativeCols(float totalWidth,
                                   float... widthRatios)
```
    Sets the column widths relative to each other as a fraction of some given totalWidth. Each argument in the widthRatios variadic list produces a column in the final grid. The following example makes the grid have three columns, where the left-most column is considered the "baseline" width with the middle column being twice as wide and the bottom column being half as wide. With a totalWidth of 350px, this results in column widths being 100px, 200px, and 50px respectively.
```
 
 grid.withRelativeCols(350.0f, 1f, 2f, 0.5f);
 
 
```
    The portion of the total width allotted to each row is entirely relative, so these will both produce 100px wide columns:
```
 
 grid.withRelativeCols(300.0f, 0.2f, 0.2f, 0.2f);
 grid.withRelativeCols(300.0f, 1f, 1f, 1f);
 
 
```
    Given ratios (x, y, z), the space allotted for column x is simply totalWidth * (x / (x + y + z)) NOTE: undefined behavior if supplied negative or zero ratios
    Parameters:
    
    totalWidth - the total space allotted for all columns combined
    
    widthRatios - a list of ratios used to divide up the totalWidth in a relative manner
    
    Returns:
    
    this
    
    See Also:
    
    withRelativeRows(float, float...), withExactCols(float...), withNEvenlySizedCols(float, int)
  - withNEvenlySizedRows
```
public GridLayout withNEvenlySizedRows(float totalHeight,
                                       int numRows)
```
    Makes numRows evenly sized rows. Each row will be given a height of totalHeight / numRows pixels. NOTE: undefined behavior if numRows is less than or equal to 0 or if totalHeight is less than 0
    
    Parameters:
    
    totalHeight - the combined height of all rows
    
    numRows - the number of rows to construct
    
    Returns:
    
    this
    
    See Also:
    
    withNEvenlySizedCols(float, int), withExactRows(float...), withRelativeRows(float, float...)
  - withNEvenlySizedCols
```
public GridLayout withNEvenlySizedCols(float totalWidth,
                                       int numCols)
```
    Makes numCols evenly sized columns. Each column will be given a width of totalWidth / numCols pixels. NOTE: undefined behavior if numCols is less than or equal to 0 or if totalWidth is less than 0
    
    Parameters:
    
    totalWidth - the combined width of all columns
    
    numCols - the number of columns to construct
    
    Returns:
    
    this
    
    See Also:
    
    withNEvenlySizedRows(float, int), withExactCols(float...), withRelativeCols(float, float...)
  - withRowsCols
```
public GridLayout withRowsCols(float totalWidth,
                               float totalHeight,
                               int numRows,
                               int numCols)
```
    Makes evenly distributed rows/cols for a certain width and height. Convenience function for performing both withNEvenlySizedRows(float, int) and withNEvenlySizedCols(float, int) in one function call.
    
    Parameters:
    
    totalWidth - the total width of the grid
    
    totalHeight - the total height of the grid
    
    numRows - the number of rows in the grid
    
    numCols - the number of cols in the grid
    
    Returns:
    
    this layout
    
    See Also:
    
    withNEvenlySizedRows(float, int), withNEvenlySizedCols(float, int)
  - getContentWidth
```
public float getContentWidth()
```
    Description copied from class: AbstractWidget
    
    The internal content width of the widget (excludes margins). Safe to use before anchoring (values should be accurate after constructor).
    
    Specified by:
    
    getContentWidth in class AbstractWidget<GridLayout>
    
    Returns:
    
    the width of this widget (excluding margins)
    
    See Also:
    
    AbstractWidget.getWidth(), AbstractWidget.getContentHeight()
  - getContentHeight
```
public float getContentHeight()
```
    Description copied from class: AbstractWidget
    
    The internal content height of the widget (excludes margins). Safe to use before anchoring (values should be accurate after constructor).
    
    Specified by:
    
    getContentHeight in class AbstractWidget<GridLayout>
    
    Returns:
    
    the height of this widget (excluding margins)
    
    See Also:
    
    AbstractWidget.getHeight(), AbstractWidget.getContentWidth()
  - iteratorByRow
```
public java.util.stream.Stream<easel.ui.layouts.LayoutItem> iteratorByRow(int row)
```
    Returns all children in the given row, in no particular order.
    
    Parameters:
    
    row - the row to pull children from
    
    Returns:
    
    a stream containing any widget that sits in this row
  - iteratorByCol
```
public java.util.stream.Stream<easel.ui.layouts.LayoutItem> iteratorByCol(int col)
```
    Returns all children in the given column, in no particular order.
    
    Parameters:
    
    col - the column to pull children from
    
    Returns:
    
    a stream containing any widget that sits in this column
  - iteratorByColOfType
```
public <T> java.util.stream.Stream<T> iteratorByColOfType(int col,
                                                          java.lang.Class<T> clz)
```
    Returns all children in the given column of a particular type, in no particular order. Children in this column which are not instances of the given type are not added to the stream. This is mostly for convenience as recovering the type inside the stream can make some code cleaner. This variant of iteratorByCol(int) has a slight performance penalty due to making sure the casts are safe.
    
    Type Parameters:
    
    T - the type of widget that will be in the final stream
    
    Parameters:
    
    col - the column to pull children from
    
    clz - the class of widget caught by the filter
    
    Returns:
    
    a stream containing any widget of type T that sits in this column
    
    See Also:
    
    iteratorByCol(int)
  - iteratorByRowOfType
```
public <T> java.util.stream.Stream<T> iteratorByRowOfType(int row,
                                                          java.lang.Class<T> clz)
```
    Returns all children in the given row of a particular type, in no particular order. Children in this row which are not instances of the given type are not added to the stream. This is mostly for convenience as recovering the type inside the stream can make some code cleaner. This variant of iteratorByRow(int) has a slight performance penalty due to making sure the casts are safe.
    
    Type Parameters:
    
    T - the type of widget that will be in the final stream
    
    Parameters:
    
    row - the row to pull children from
    
    clz - the class of widget caught by the filter
    
    Returns:
    
    a stream containing any widget of type T that sits in this row
    
    See Also:
    
    iteratorByRow(int)
  - withChild
```
public GridLayout withChild(int row,
                            int col,
                            AbstractWidget widget,
                            AnchorPosition anchorPosition)
```
    Let this grid manage the given widget. This function uses the specified anchor (ignoring defaultChildAnchor) to position this child inside its grid cell. The widget is moved into the proper position next time AbstractWidget.anchoredAt(float, float, AnchorPosition) (or another in the anchoredAt family) is called.
    
    NOTE: This widget will replace any existing widget at the same (row, col) position if it already exists. It also assumes that (row,col) will be a valid position in the grid, but no bounds checking is provided. The grid will add this widget to its tracked HashMap regardless.
    
    Parameters:
    
    row - the row the widget will be placed in (0 is the top-most row)
    
    col - the col the widget will be placed in (0 is the left-most column)
    
    widget - the widget to track
    
    anchorPosition - how the child will be situated inside the (row, col) grid cell [which may be wider and taller than the widget's own width/height]
    
    Returns:
    
    this layout
    
    See Also:
    
    withChild(int, int, AbstractWidget)
  - withChild
```
public GridLayout withChild(int row,
                            int col,
                            AbstractWidget widget)
```
    Let this grid manage the given widget. This function uses the current defaultChildAnchor position to set this child's position inside its grid cell (see withDefaultChildAnchorPosition(AnchorPosition) for details). The widget is moved into the proper position next time AbstractWidget.anchoredAt(float, float, AnchorPosition) (or another in the anchoredAt family) is called.
    
    NOTE: This widget will replace any existing widget at the same (row, col) position if it already exists. It also assumes that (row,col) will be a valid position in the grid, but no bounds checking is provided. The grid will add this widget to its tracked HashMap regardless.
    
    Parameters:
    
    row - the row the widget will be placed in (0 is the top-most row)
    
    col - the col the widget will be placed in (0 is the left-most column)
    
    widget - the widget to track
    
    Returns:
    
    this layout
    
    See Also:
    
    withChild(int, int, AbstractWidget, AnchorPosition), withDefaultChildAnchorPosition(AnchorPosition)
  - withChildrenInRow
```
public GridLayout withChildrenInRow(int row,
                                    AbstractWidget... widgets)
```
    Adds the provided children to the specified row, starting at column 0. E.g. the first widget provided will be placed in the row at column 0, the second in the row at column 1, etc.
    
    Parameters:
    
    row - the row to add the children into
    
    widgets - a list of child widgets
    
    Returns:
    
    this layout
    
    See Also:
    
    withChild(int, int, AbstractWidget, AnchorPosition)
  - withChildrenInCol
```
public GridLayout withChildrenInCol(int col,
                                    AbstractWidget... widgets)
```
    Adds the provided children to the specified column, starting at row 0. E.g. the first widget provided will be placed in the column in row 0, the second in the column in row 1, etc.
    
    Parameters:
    
    col - the column to add the children into
    
    widgets - a list of child widgets
    
    Returns:
    
    this layout
    
    See Also:
    
    withChild(int, int, AbstractWidget, AnchorPosition)
  - resizeRowToFitTallestChild
```
public GridLayout resizeRowToFitTallestChild(int row)
```
  - resizeRowsToFitTallestChildren
```
public GridLayout resizeRowsToFitTallestChildren()
```
  - resizeColToFitWidestChild
```
public GridLayout resizeColToFitWidestChild(int col)
```
  - resizeColsToFitWidestChildren
```
public GridLayout resizeColsToFitWidestChildren()
```
  - iterator
```
public java.util.stream.Stream<AbstractWidget> iterator()
```
    The ordering of this stream is dependent on the underlying map (which does not have a predictable order).
    
    Returns:
    
    a stream of all children currently handled by this widget, in no particular order
  - iteratorOfType
```
public <T> java.util.stream.Stream<T> iteratorOfType(java.lang.Class<T> clz)
```
    A stream of children handled by this widget who are of the specific type, for convenience purposes. Like iterator(), the resulting stream is in no particular order. If you know you've built the layout with all objects of a particular type, you can quickly recover them all into a stream that remembers the type. This has a slight performance penalty over iterator() due to checking each child against the type for safe casts, but the resulting stream will be properly typed to make it easier to work with. Children managed by this layout who are not of the given type will not be included in the stream, so be wary if using this variant of the iterator.
    
    Type Parameters:
    
    T - the type of child to extract
    
    Parameters:
    
    clz - the class for the type
    
    Returns:
    
    a stream of children who fit the given type
    
    See Also:
    
    iterator()
  - cancelMovementQueueForAllChildren
```
protected void cancelMovementQueueForAllChildren(boolean shouldTryAndResolveOneLastTime)
```
    Overrides:
    
    cancelMovementQueueForAllChildren in class AbstractWidget<GridLayout>
  - anchoredAt
```
public GridLayout anchoredAt(float x,
                             float y,
                             AnchorPosition anchorPosition,
                             InterpolationSpeed movementSpeed)
```
    Description copied from class: AbstractWidget
    Moves the widget towards a specific spot. The anchorPosition defines the point on the widget that will be placed at the position (x, y).
    
    For example, anchoredAt(100, 200, AnchorPosition.LEFT_BOTTOM, InterpolationSpeed.FAST) will set the bottom-left corner of the widget to 100 pixels from the left side of the screen and 200 pixels from the bottom of the screen. The widget then renders up and to the right of this point since we anchored at an AnchorPosition.LEFT_BOTTOM. As a second example, using AnchorPosition.CENTER ensures that (x, y) will be the center of the widget.
    
    The interpolation speed movementSpeed determines how quickly the widget moves to the target location. Using a speed other than InterpolationSpeed.INSTANT makes the widget move towards the desired position over the next few frames in a smoothly animated manner. For convenience since instant moving is often the desired effect, see AbstractWidget.anchoredAt(float, float, AnchorPosition).
    
    Note: you should always anchor at least once before rendering. For more dynamic widgets that move a lot (e.g. a tooltip dependent on the mouse cursor location using InputHelper.mX and InputHelper.mY), a general pattern is to call anchoredAt right before rendering in your main render function, e.g.:
```
 
 widget.anchoredAt(x, y, AnchorPosition.CENTER, InterpolationSpeed.INSTANT)
       .render(sb);
 
 
```
    Overrides:
    
    anchoredAt in class AbstractWidget<GridLayout>
    
    Parameters:
    
    x - the x position in pixels from the left edge of the screen
    
    y - the y position in pixels from the bottom edge of the screen
    
    anchorPosition - what piece of the widget will be moved to (x, y)
    
    movementSpeed - how quickly the widget will move towards the desired position
    
    Returns:
    
    this widget
    
    See Also:
    
    AbstractWidget.anchoredAt(float, float, AnchorPosition), AbstractWidget.anchoredAtClamped(float, float, AnchorPosition, float), AbstractWidget.anchoredAtClamped(float, float, AnchorPosition, InterpolationSpeed, float)
  - setChildrenDelayedMovement
```
protected void setChildrenDelayedMovement(float deltaX,
                                          float deltaY,
                                          InterpolationSpeed movementSpeed,
                                          long startingTimeMillis)
```
    Description copied from class: AbstractWidget
    
    For use with AbstractWidget.delayedTranslate(float, float, InterpolationSpeed, long). Make sure any widget with children (e.g. containers, layouts, etc.) overrides this function and calls AbstractWidget.setAllDelayedMovement(float, float, InterpolationSpeed, long) using the input to this function on all direct descendants. This is required if you want to be able to use a delayed anchoredAt command on custom widgets.
    
    Overrides:
    
    setChildrenDelayedMovement in class AbstractWidget<GridLayout>
    
    Parameters:
    
    deltaX - how much movement horizontally
    
    deltaY - how much movement vertically
    
    movementSpeed - how fast the widget will move towards the target, once startingTimeMillis is reached (i.e. System.currentTimeMillis() is greater than or equal to this starting time)
    
    startingTimeMillis - a time generated by an offset of System.currentTimeMillis(), determined by the original AbstractWidget.delayedTranslate(float, float, InterpolationSpeed, long) function that starts this chain
  - renderWidget
```
protected void renderWidget(com.badlogic.gdx.graphics.g2d.SpriteBatch sb)
```
    Description copied from class: AbstractWidget
    
    Custom widgets should implement this method for rendering. Use the inner content positions (e.g. AbstractWidget.getContentLeft(), AbstractWidget.getContentWidth(), etc.) to determine any position information necessary for rendering at a specific location. If the library is used as intended, these content locations should be accurate to where the widget needs to be rendered, as they reflect the most up to date location set by an anchoredAt call (this automatically will be interpolated if the anchorAt move is set to occur over several frames).
    
    Note: you NEED to revert any changes you make to the SpriteBatch (e.g. setting a shader, changing the perspective matrix, etc.) by the time this function returns, as the SpriteBatch will be reused for rendering other widgets which will not expect those changes. You also don't technically need to render to this particular SpriteBatch (e.g. you can render to your own batch if you know what you're doing), as long as you follow the general intent of this function to render the widget.
    
    Specified by:
    
    renderWidget in class AbstractWidget<GridLayout>
    
    Parameters:
    
    sb - the SpriteBatch the widget should be rendered on
    
    See Also:
    
    AbstractWidget.renderTopLevel(SpriteBatch)
  - renderTopLevel
```
public void renderTopLevel(com.badlogic.gdx.graphics.g2d.SpriteBatch sb)
```
    Description copied from class: AbstractWidget
    Renders top level (especially tooltip) effects. Like AbstractWidget.render(SpriteBatch), but deliberately delayed. If any of your widgets require custom (Widget-based, not base-game TipHelper based) tooltips or other specific rendering that needs to go on top of all other widgets in the hierarchy, you'll need to set your root node to call this after its main AbstractWidget.render(SpriteBatch) completes.
    
    If you are hooking into BaseMod's RenderSubscriber for your base class, you can simply call this after your main call to rootWidget.render(spriteBatch). All layout managers and other container widgets will extend the calls down the tree automatically (much like how render() works), meaning you only need to call this at the highest level of your widget hierarchy.
```
 
 public void receiveRender(SpriteBatch spriteBatch) {
     // Our normal render call will trickle down the hierarchy in a breadth-first manner, rendering every descendant widget.
     baseWidget.render(spriteBatch);

     // Call this after the above so that we can support custom tooltips (if desired); also trickles down the tree
     baseWidget.renderTopLevel(spriteBatch);
 }
 
 
```
    Note that this is only required if you are using custom widgets that need to be rendered last (on top of everything). If you are sticking to base game style tooltips (e.g. using something like the TipHelper statics), this is NOT required. However, if you do end up needing to draw on top of all widgets in your hierarchy, this is a solid way to do it as it follows the same breadth-first visit order but occurs after all the regular rendering takes place.
    Overrides:
    
    renderTopLevel in class AbstractWidget<GridLayout>
    
    Parameters:
    
    sb - the SpriteBatch to render on
    
    See Also:
    
    AbstractWidget.render(SpriteBatch)
  - updateWidget
```
public void updateWidget()
```
    Description copied from class: AbstractWidget
    
    Required for interactive components. For containers, make sure to call update() on all children. For widgets that require some sort of updates each frame, you can do so here.
    
    Overrides:
    
    updateWidget in class AbstractWidget<GridLayout>
  - show
```
public void show()
```
    Overrides:
    
    show in class AbstractWidget<GridLayout>
  - hide
```
public void hide()
```
    Overrides:
    
    hide in class AbstractWidget<GridLayout>

Class GridLayout

Field Summary

Fields inherited from class easel.ui.AbstractWidget

Constructor Summary

Method Summary

Methods inherited from class easel.ui.AbstractWidget

Methods inherited from class java.lang.Object

Constructor Detail

GridLayout

Method Detail

withDefaultChildAnchorPosition

clear

withExactRows

withExactCols

withRelativeRows

withRelativeCols

withNEvenlySizedRows

withNEvenlySizedCols

withRowsCols

getContentWidth

getContentHeight

iteratorByRow

iteratorByCol

iteratorByColOfType

iteratorByRowOfType

withChild

withChild

withChildrenInRow

withChildrenInCol

resizeRowToFitTallestChild

resizeRowsToFitTallestChildren

resizeColToFitWidestChild

resizeColsToFitWidestChildren

iterator

iteratorOfType

cancelMovementQueueForAllChildren

anchoredAt

setChildrenDelayedMovement

renderWidget

renderTopLevel

updateWidget

show

hide