easel.ui.containers

Class StyledContainer

java.lang.Object

easel.ui.AbstractWidget<StyledContainer>

easel.ui.containers.StyledContainer

public class StyledContainer
extends AbstractWidget<StyledContainer>

A container with a nice textured background and borders. Contains some helpers for making it have a nice header and for scaling everything to fit the given contents. Like layouts or other containers: anchoring, rendering, updates and the other usual suspects will be passed down the hierarchy, so calling them once on the container itself will be sufficient to handle the content and header widgets managed by this container. StyledContainers work nicely with MoveContainers, and are designed as a "super" tooltip to give the base game tooltips a bit more flexibility. They can also be used as larger screens as well.

Example use:

 
 StyledContainer c = new StyledContainer(500, 500)
     .withHeader("Title", "Subtitle")
     .withHeaderAnchor(AnchorPosition.LEFT_CENTER)
     .withHeaderColor(EaselColors.HEADER_PURPLE())
     .withContent(
         new VerticalLayout(20)
             .withChild(new Label("Content One"))
             .withChild(new Label("Content Two"))
     )
     .scaleToContent()
     .anchoredCenteredOnScreen();
 
 

Field Summary

Fields inherited from class easel.ui.AbstractWidget

hasInteractivity, hb, isHovered, leftClickStarted, onLeftClick, onMouseEnter, onMouseLeave, onRightClick, rightClickStarted

Constructor Summary

Constructors

Constructor and Description
StyledContainer(float width, float height) Constructs a new styled container with the given dimensions.

Method Summary

Modifier and Type	Method and Description
StyledContainer	anchoredAt(float x, float y, AnchorPosition anchorPosition, InterpolationSpeed movementSpeed) Moves the widget towards a specific spot.
protected void	cancelMovementQueueForAllChildren(boolean shouldTryAndResolveOneLastTime)
float	getContentHeight() The internal content height of the widget (excludes margins).
float	getContentWidth() The internal content width of the widget (excludes margins).
protected void	renderWidget(com.badlogic.gdx.graphics.g2d.SpriteBatch sb) Custom widgets should implement this method for rendering.
StyledContainer	scaleToContent() Automatically scale the container to fit the main contents.
StyledContainer	scaleToContentHeight() Automatically scale the container to fit its main content (and header) height.
StyledContainer	scaleToContentWidth() Automatically scale the container to fit its main content (and header) width.
protected void	setChildrenDelayedMovement(float deltaX, float deltaY, InterpolationSpeed movementSpeed, long startingTimeMillis) For use with AbstractWidget.delayedTranslate(float, float, InterpolationSpeed, long).
static void	syncContainerHeights(boolean scaleToContentFirst, java.util.List<StyledContainer> containers) See syncContainerHeights(boolean, Stream).
static void	syncContainerHeights(boolean scaleToContentFirst, java.util.stream.Stream<StyledContainer> containers) Makes all containers share the height of the tallest container.
static void	syncContainerHeights(boolean scaleToContentFirst, StyledContainer... containers) See syncContainerHeights(boolean, Stream).
static void	syncContainerHeights(java.util.List<StyledContainer> containers) See syncContainerHeights(boolean, Stream).
static void	syncContainerHeights(java.util.stream.Stream<StyledContainer> containers) See syncContainerHeights(boolean, Stream).
static void	syncContainerHeights(StyledContainer... containers) See syncContainerHeights(boolean, Stream).
static void	syncContainerWidths(boolean scaleToContentFirst, java.util.List<StyledContainer> containers) See syncContainerWidths(boolean, Stream)
static void	syncContainerWidths(boolean scaleToContentFirst, java.util.stream.Stream<StyledContainer> containers) Makes all StyledContainers in the stream share the width of the widest one.
static void	syncContainerWidths(boolean scaleToContentFirst, StyledContainer... containers) See syncContainerWidths(boolean, Stream)
static void	syncContainerWidths(java.util.List<StyledContainer> containers) See syncContainerWidths(boolean, Stream).
static void	syncContainerWidths(java.util.stream.Stream<StyledContainer> containers) See syncContainerWidths(boolean, Stream).
static void	syncContainerWidths(StyledContainer... containers) See syncContainerWidths(boolean, Stream).
protected void	updateWidget() Required for interactive components.
StyledContainer	withBaseColor(com.badlogic.gdx.graphics.Color baseColor) The background color of the entire container texture.
StyledContainer	withContent(AbstractWidget content, boolean autoAddMargins) Set the main content of this container.
StyledContainer	withContentAnchor(AnchorPosition contentAnchor) Sets the position of the main contents inside the bottom region.
StyledContainer	withDimensions(float newWidth, float newHeight) Set new dimensions for the full container.
StyledContainer	withHeader(AbstractWidget customHeader, boolean autoAddMargins) Add a custom child widget to serve as this containers header.
StyledContainer	withHeader(java.lang.String title) Add a single-line title to this container with the given text.
StyledContainer	withHeader(java.lang.String title, java.lang.String subtitle) Add a double-line title/subtitle to this container with the given text.
StyledContainer	withHeaderAnchor(AnchorPosition headerAnchor) Sets the position of the header contents inside the header region.
StyledContainer	withHeaderColor(com.badlogic.gdx.graphics.Color headerColor) The background color of the header, if it exists (use with one of the header builder functions: withHeader(String) etc.).
StyledContainer	withHeight(float newHeight) Set the new height of the full container to a new value Requires re-anchoring.
StyledContainer	withShadows(boolean enabled) Set whether a drop shadow is rendered underneath the container.
StyledContainer	withTrimColors(com.badlogic.gdx.graphics.Color trimColor, com.badlogic.gdx.graphics.Color trimHighlightColor) The trim colors of the entire container texture (for the outermost borders).
StyledContainer	withWidth(float newWidth) Set the new width of the full container to a new value.

Methods inherited from class easel.ui.AbstractWidget

anchoredAt, anchoredAtClamped, anchoredAtClamped, anchoredCenteredOnMouse, anchoredCenteredOnMouse, anchoredCenteredOnMouseClamped, anchoredCenteredOnMouseClamped, anchoredCenteredOnScreen, anchoredCenteredOnScreen, cancelMovementQueue, delayedTranslate, getBottom, getContentBottom, getContentCenterX, getContentCenterY, getContentLeft, getContentRight, getContentTop, getHeight, getLeft, getRight, getTop, getWidth, hide, initializeInteractivity, isMouseInBounds, isMouseInContentBounds, leftMouseClick, mouseEnter, mouseLeave, onLeftClick, onMouseEnter, onMouseLeave, onRightClick, refreshAnchor, render, renderTopLevel, resolveMovementQueue, rightMouseClick, scaleHitboxToContent, setAllDelayedMovement, show, toString, translate, update, updateInteractivity, withMargins, withMargins, withMargins

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

StyledContainer

public StyledContainer(float width,
                       float height)

Constructs a new styled container with the given dimensions. These dimensions can be changed later (e.g. scaled to content with scaleToContent() or resized manually with withDimensions(float, float)).

Parameters:

width - the entire width of the container

height - the entire height of the container

Method Detail

withHeader

public StyledContainer withHeader(java.lang.String title)

Add a single-line title to this container with the given text. Header text position is affected by withHeaderAnchor(AnchorPosition).

Parameters:

title - the text to serve as the header

Returns:

this widget

withHeader

public StyledContainer withHeader(java.lang.String title,
                                  java.lang.String subtitle)

Add a double-line title/subtitle to this container with the given text. Header text position is affected by withHeaderAnchor(AnchorPosition).

Parameters:

title - the text to serve as the header title

subtitle - the text to serve as the header subtitle

Returns:

this widget

withHeader

public StyledContainer withHeader(AbstractWidget customHeader,
                                  boolean autoAddMargins)

Add a custom child widget to serve as this containers header. Header position is affected by withHeaderAnchor(AnchorPosition).

Parameters:

customHeader - the widget which will sit in the header region (which automatically scales to surround this custom header)

autoAddMargins - if true, will call AbstractWidget.withMargins(float, float) on the customHeader with some suggested defaults (the header needs some sort of margins to not touch the borders of the container)

Returns:

this widget

withHeaderColor

public StyledContainer withHeaderColor(com.badlogic.gdx.graphics.Color headerColor)

The background color of the header, if it exists (use with one of the header builder functions: withHeader(String) etc.). The header colors can be picked from the EaselColors.HEADER_ family of colors, such as EaselColors.HEADER_RED(). These header colors were chosen since they can fit well with the default background and trim colors of the overall container, and will work with the default header text colors. If not set, defaults to EaselColors.HEADER_BLUE().

Parameters:

headerColor - the desired color of the header

Returns:

this widget

withBaseColor

public StyledContainer withBaseColor(com.badlogic.gdx.graphics.Color baseColor)

The background color of the entire container texture. Defaults to EaselColors.TOOLTIP_BASE() if not set.

Parameters:

baseColor - the new background color

Returns:

this widget

withTrimColors

public StyledContainer withTrimColors(com.badlogic.gdx.graphics.Color trimColor,
                                      com.badlogic.gdx.graphics.Color trimHighlightColor)

The trim colors of the entire container texture (for the outermost borders). The styled container mimics some of the base game border style by having a regular trim color and a specific highlight color to contrast against it. Defaults to EaselColors.TOOLTIP_TRIM() and EaselColors.TOOLTIP_TRIM_HIGHLIGHT() if not set.

Parameters:

trimColor - the basic border color

trimHighlightColor - the highlight color for the border

Returns:

this widget

withHeaderAnchor

public StyledContainer withHeaderAnchor(AnchorPosition headerAnchor)

Sets the position of the header contents inside the header region. Requires anchoring after calling this in order for the changes to take effect.

Parameters:

headerAnchor - where the header contents are anchored inside the header region

Returns:

this widget

withContentAnchor

public StyledContainer withContentAnchor(AnchorPosition contentAnchor)

Sets the position of the main contents inside the bottom region. Requires anchoring afterwards for the changes to take effect.

Parameters:

contentAnchor - where the main contents are anchored in the bottom section of the container

Returns:

this widget

withShadows

public StyledContainer withShadows(boolean enabled)

Set whether a drop shadow is rendered underneath the container. Defaults to false if not set, and recommended to not alter this manually. Toggled by MoveContainer when moving styled containers around to improve the aesthetics a bit.

Parameters:

enabled - if true, will render shadows beneath the entire widget

Returns:

this widget

withContent

public StyledContainer withContent(AbstractWidget content,
                                   boolean autoAddMargins)

Set the main content of this container. This gets rendered underneath the header (if it exists) and takes up the primary area of the container. The content itself is often a layout containing its own widget hierarchy. Like custom header widgets, this contains a autoAddMargins flag which can be used to automatically give the new content a reasonable set of default margins. Margins on the content widget itself are required for the content to not touch the sides of the container. Requires re-anchoring.

Parameters:

content - the main widget that is the focus of this container

autoAddMargins - if true, will call AbstractWidget.withMargins(float) on the content widget with some suggested values

Returns:

this widget

withWidth

public StyledContainer withWidth(float newWidth)

Set the new width of the full container to a new value. Requires re-anchoring.

Parameters:

newWidth - the new width

Returns:

this widget

withHeight

public StyledContainer withHeight(float newHeight)

Set the new height of the full container to a new value Requires re-anchoring.

Parameters:

newHeight - the new height

Returns:

this widget

withDimensions

public StyledContainer withDimensions(float newWidth,
                                      float newHeight)

Set new dimensions for the full container. Convenience for calling both withWidth(float) and withHeight(float) at the same time. Requires re-anchoring.

Parameters:

newWidth - the new width

newHeight - the new height

Returns:

this widget

scaleToContentWidth

public StyledContainer scaleToContentWidth()

Automatically scale the container to fit its main content (and header) width. Does nothing if no content widget has been set. Requires re-anchoring.

Returns:

this widget

scaleToContentHeight

public StyledContainer scaleToContentHeight()

Automatically scale the container to fit its main content (and header) height. Does nothing if no content widget has been set. Requires re-anchoring.

Returns:

this widget

scaleToContent

public StyledContainer scaleToContent()

Automatically scale the container to fit the main contents. Calling this after setting up the container's content and headers is extremely common, as it scales the container itself to fit the widgets you've added.

Returns:

this widget

syncContainerWidths

public static void syncContainerWidths(StyledContainer... containers)

See syncContainerWidths(boolean, Stream). Will not automatically scale to content first.

Parameters:

containers - a variadic list of containers to scale

See Also:

syncContainerWidths(boolean, Stream)

syncContainerWidths

public static void syncContainerWidths(java.util.stream.Stream<StyledContainer> containers)

See syncContainerWidths(boolean, Stream). Will not automatically scale to content first.

Parameters:

containers - a stream of containers to scale

See Also:

syncContainerWidths(boolean, Stream)

syncContainerWidths

public static void syncContainerWidths(java.util.List<StyledContainer> containers)

See syncContainerWidths(boolean, Stream). Will not automatically scale to content first.

Parameters:

containers - a list of containers to scale

See Also:

syncContainerWidths(boolean, Stream)

syncContainerWidths

public static void syncContainerWidths(boolean scaleToContentFirst,
                                       StyledContainer... containers)

See syncContainerWidths(boolean, Stream)

Parameters:

scaleToContentFirst - whether to call scaleToContent() on each container first before scaling all widths to the maximum

containers - a variadic list of containers to scale

See Also:

syncContainerWidths(boolean, Stream)

syncContainerWidths

public static void syncContainerWidths(boolean scaleToContentFirst,
                                       java.util.stream.Stream<StyledContainer> containers)

Makes all StyledContainers in the stream share the width of the widest one. As this is a width altering function, each affected widget will require re-anchoring before being used. The scaleToContentFirst flag is mostly for convenience and if set, will call scaleToContent() on all widgets before computing the the final new width.

An example use:

 
 // This is some layout which contains the StyledContainers as children:
 layout = ...;

 // We want to sync up all the containers to have the same width
 // the first argument "true" simply calls .scaleToContent() on each container
 // before computing the width to scale everything to
 StyledContainer.syncContainerWidths(true, layout.iteratorOfType(StyledContainer.class));

 // We've (probably) adjusted the dimensions of multiple styled containers, so be sure
 // to reanchor everything affected. Since we've stored the containers in a layout, you
 // can just perform your anchoring step on it now
 layout.anchoredCenteredOnScreen();
 
 

Parameters:

scaleToContentFirst - whether to call scaleToContent() on each container first before scaling all widths to the maximum

containers - a stream of containers to scale

See Also:

syncContainerHeights(boolean, Stream), syncContainerWidths(boolean, StyledContainer...), syncContainerWidths(boolean, List), syncContainerWidths(Stream), syncContainerWidths(List), syncContainerWidths(StyledContainer...)

syncContainerWidths

public static void syncContainerWidths(boolean scaleToContentFirst,
                                       java.util.List<StyledContainer> containers)

See syncContainerWidths(boolean, Stream)

Parameters:

scaleToContentFirst - whether to call scaleToContent() on each container first before scaling all widths to the maximum

containers - a list of containers to scale

See Also:

syncContainerWidths(boolean, Stream)

syncContainerHeights

public static void syncContainerHeights(StyledContainer... containers)

See syncContainerHeights(boolean, Stream). Will not automatically scale to content first.

Parameters:

containers - a variadic list of containers to scale

See Also:

syncContainerHeights(boolean, Stream)

syncContainerHeights

public static void syncContainerHeights(java.util.stream.Stream<StyledContainer> containers)

See syncContainerHeights(boolean, Stream). Will not automatically scale to content first.

Parameters:

containers - a stream of containers to scale

See Also:

syncContainerHeights(boolean, Stream)

syncContainerHeights

public static void syncContainerHeights(java.util.List<StyledContainer> containers)

See syncContainerHeights(boolean, Stream). Will not automatically scale to content first.

Parameters:

containers - a list of containers to scale

See Also:

syncContainerHeights(boolean, Stream)

syncContainerHeights

public static void syncContainerHeights(boolean scaleToContentFirst,
                                        StyledContainer... containers)

See syncContainerHeights(boolean, Stream).

Parameters:

scaleToContentFirst - whether to call scaleToContent() on each container first before scaling all heights to the maximum

containers - a stream of containers to scale

See Also:

syncContainerHeights(boolean, Stream)

syncContainerHeights

public static void syncContainerHeights(boolean scaleToContentFirst,
                                        java.util.stream.Stream<StyledContainer> containers)

Makes all containers share the height of the tallest container. Not as common as syncContainerWidths(boolean, Stream), but can be used in a similar manner.

Parameters:

scaleToContentFirst - whether to call scaleToContent() on each container first before scaling all heights to the maximum

containers - a stream of containers to scale heights of

See Also:

syncContainerWidths(boolean, Stream), syncContainerHeights(boolean, StyledContainer...), syncContainerHeights(boolean, List), syncContainerHeights(Stream), syncContainerHeights(StyledContainer...), syncContainerHeights(List)

syncContainerHeights

public static void syncContainerHeights(boolean scaleToContentFirst,
                                        java.util.List<StyledContainer> containers)

See syncContainerHeights(boolean, Stream).

Parameters:

scaleToContentFirst - whether to call scaleToContent() on each container first before scaling all heights to the maximum

containers - a list of containers to scale

See Also:

syncContainerHeights(boolean, Stream)

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<StyledContainer>

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<StyledContainer>

Returns:

the height of this widget (excluding margins)

See Also:

AbstractWidget.getHeight(), AbstractWidget.getContentWidth()

anchoredAt

public StyledContainer 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<StyledContainer>

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)

cancelMovementQueueForAllChildren

protected void cancelMovementQueueForAllChildren(boolean shouldTryAndResolveOneLastTime)

Overrides:

cancelMovementQueueForAllChildren in class AbstractWidget<StyledContainer>

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<StyledContainer>

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

updateWidget

protected 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<StyledContainer>

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<StyledContainer>

Parameters:

sb - the SpriteBatch the widget should be rendered on

See Also:

AbstractWidget.renderTopLevel(SpriteBatch)