easel.ui

Enum AnchorPosition

java.lang.Object

java.lang.Enum<AnchorPosition>

easel.ui.AnchorPosition

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<AnchorPosition>

public enum AnchorPosition
extends java.lang.Enum<AnchorPosition>

Enum specifying nine anchorable positions which are mostly used for aligning widgets into the proper location. Contains some helper methods to make working with the anchors a bit easier.

Enum Constant Summary

Enum Constants

Enum Constant and Description
CENTER
CENTER_BOTTOM
CENTER_TOP
LEFT_BOTTOM
LEFT_CENTER
LEFT_TOP
RIGHT_BOTTOM
RIGHT_CENTER
RIGHT_TOP

Method Summary

Modifier and Type	Method and Description
static AnchorPosition	combine(AnchorPosition horizontal, AnchorPosition vertical) Produces a new anchor position which takes the horizontal position from horizontal and the vertical position from vertical.
static float	deltaX(float startX, AnchorPosition startAnchor, float newX, AnchorPosition newAnchor, float width) Determines how much the coordinates move horizontally from a starting point to the ending point.
static float	deltaY(float startY, AnchorPosition startAnchor, float newY, AnchorPosition newAnchor, float height) Determines how much the coordinates move vertically from a starting point to the ending point.
float	getBottom(float y, float height) Return the bottom-most point of a region with the given height where y is a point inside that region determined by this anchor.
float	getLeft(float x, float width) Return the left-most point of a region with the given width where x is a point inside that region determined by this anchor.
float	getXFromLeft(float left, float width) Computes an x value adjusted by this anchor, given a leftmost point and the width of the area.
float	getXFromRight(float right, float width) Similar to getXFromLeft(float, float), except the range is inside [right - width, right].
float	getYFromBottom(float bottom, float height) Computes a y value adjusted by this anchor, given a bottom point and the height of the area.
float	getYFromTop(float top, float height) Similar to getYFromBottom(float, float), except the range is inside [top - height, top].
boolean	isBottom() Returns true if the anchor is vertically bottom.
boolean	isCenterX() Returns true if the anchor is horizontally centered.
boolean	isCenterY() Returns true if the anchor is vertically centered.
boolean	isLeft() Returns true if the anchor is horizontally left.
boolean	isRight() Returns true if the anchor is horizontally right.
boolean	isTop() Returns true if the anchor is vertically top.
AnchorPosition	next() DEBUG.
static AnchorPosition	randomAnchor() DEBUG.
static AnchorPosition	randomAnchor(AnchorPosition previous) DEBUG.
static AnchorPosition	valueOf(java.lang.String name) Returns the enum constant of this type with the specified name.
static AnchorPosition[]	values() Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum

clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Enum Constant Detail

LEFT_TOP

public static final AnchorPosition LEFT_TOP

CENTER_TOP

public static final AnchorPosition CENTER_TOP

RIGHT_TOP

public static final AnchorPosition RIGHT_TOP

LEFT_CENTER

public static final AnchorPosition LEFT_CENTER

CENTER

public static final AnchorPosition CENTER

RIGHT_CENTER

public static final AnchorPosition RIGHT_CENTER

LEFT_BOTTOM

public static final AnchorPosition LEFT_BOTTOM

CENTER_BOTTOM

public static final AnchorPosition CENTER_BOTTOM

RIGHT_BOTTOM

public static final AnchorPosition RIGHT_BOTTOM

Method Detail

values

public static AnchorPosition[] values()

Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:

for (AnchorPosition c : AnchorPosition.values())
    System.out.println(c);

Returns:

an array containing the constants of this enum type, in the order they are declared

valueOf

public static AnchorPosition valueOf(java.lang.String name)

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

Parameters:

name - the name of the enum constant to be returned.

Returns:

the enum constant with the specified name

Throws:

java.lang.IllegalArgumentException - if this enum type has no constant with the specified name

java.lang.NullPointerException - if the argument is null

isLeft

public boolean isLeft()

Returns true if the anchor is horizontally left.

Returns:

true if this is LEFT_TOP, LEFT_CENTER, or LEFT_BOTTOM

isRight

public boolean isRight()

Returns true if the anchor is horizontally right.

Returns:

true if this is RIGHT_TOP, RIGHT_CENTER, or RIGHT_BOTTOM

isBottom

public boolean isBottom()

Returns true if the anchor is vertically bottom.

Returns:

true if this is LEFT_BOTTOM, CENTER_BOTTOM, or RIGHT_BOTTOM

isTop

public boolean isTop()

Returns true if the anchor is vertically top.

Returns:

true if this is LEFT_TOP, CENTER_TOP, or RIGHT_TOP

isCenterX

public boolean isCenterX()

Returns true if the anchor is horizontally centered.

Returns:

true if this is CENTER_TOP, CENTER, or CENTER_BOTTOM

isCenterY

public boolean isCenterY()

Returns true if the anchor is vertically centered.

Returns:

true if this is LEFT_CENTER, CENTER, or RIGHT_CENTER

getXFromLeft

public float getXFromLeft(float left,
                          float width)

Computes an x value adjusted by this anchor, given a leftmost point and the width of the area. If the anchor is LEFT_*, the returned x is just the left point. If the anchor is CENTER_*, the returned x is the left plus half the width. Otherwise, returns the rightmost point (computed by the left + width).

Parameters:

left - leftmost point of the region to anchor into

width - width of the region to anchor into

Returns:

an x coordinate contained inside the region [left, left + width] with the horizontal position determined by this anchor

getXFromRight

public float getXFromRight(float right,
                           float width)

Similar to getXFromLeft(float, float), except the range is inside [right - width, right].

Parameters:

right - rightmost point of the region to anchor into

width - width of the region to anchor into

Returns:

an x coordinate contained inside the region [right - width, right] with the horizontal position determined by this anchor

See Also:

getXFromLeft(float, float)

getYFromBottom

public float getYFromBottom(float bottom,
                            float height)

Computes a y value adjusted by this anchor, given a bottom point and the height of the area. If the anchor is *_BOTTOM, the returned y is just the bottom point. If the anchor is *_CENTER, the returned y is the bottom plus half the height. Otherwise, returns the topmost point (computed by the bottom + height).

Parameters:

bottom - lowest point of the region to anchor into

height - height of the region to anchor into

Returns:

a y coordinate contained inside the region [bottom, bottom + height] with the vertical position determined by this anchor

getYFromTop

public float getYFromTop(float top,
                         float height)

Similar to getYFromBottom(float, float), except the range is inside [top - height, top].

Parameters:

top - highest point of the region to anchor into

height - height of the region to anchor into

Returns:

a y coordinate contained inside the region [top - height, top] with the vertical position determined by this anchor

See Also:

getYFromBottom(float, float)

getLeft

public float getLeft(float x,
                     float width)

Return the left-most point of a region with the given width where x is a point inside that region determined by this anchor. Implementation wise, this is: returns x if this anchor is left, x minus half the width if this anchor is centered, or x minus the full width if this anchor is on the right. If this doesn't make sense, you can ignore this function as it is just convenience for internal use (and it's surprisingly difficult to describe concisely).

Parameters:

x - a point placed inside the region according to this anchor

width - the width of the region

Returns:

the left-most point of the region

getBottom

public float getBottom(float y,
                       float height)

Return the bottom-most point of a region with the given height where y is a point inside that region determined by this anchor. Implementation wise, this is: returns y if this anchor is bottom, y minus half the height if this anchor is centered, or y minus the full height if this anchor is on the top. If this doesn't make sense, you can ignore this function as it is just convenience for internal use (and it's surprisingly difficult to describe concisely).

Parameters:

y - a point placed inside the region according to this anchor

height - the height of the region

Returns:

the bottom-most point of the region

deltaX

public static float deltaX(float startX,
                           AnchorPosition startAnchor,
                           float newX,
                           AnchorPosition newAnchor,
                           float width)

Determines how much the coordinates move horizontally from a starting point to the ending point. This function allows computations to occur when the two x values are not the same anchor (if they were, you'd just be able to do newX - startX). This lets you quickly find the horizontal delta between ALL points in the region, given any anchored point in the original position compared to any anchored point in the new position. This assumes the width of the region stays constant, and the move is a strict translation.

Parameters:

startX - a point placed inside the starting region with its local position determined by startAnchor

startAnchor - the position of startX inside the starting region (is it on the left side of the region, the center, or the right)

newX - a point placed inside the ending region with its local position determined by newAnchor

newAnchor - the position of newX inside the ending region (is it on the left side of the region, the center, or the right)

width - the width of the region being translated (assumed constant)

Returns:

the horizontal delta between any same anchor position points in the region (e.g. how much the LEFT_BOTTOM point moves horizontally to become the new LEFT_BOTTOM, or the CENTER_TOP moves to become the new CENTER_TOP, etc.)

See Also:

deltaY(float, AnchorPosition, float, AnchorPosition, float)

deltaY

public static float deltaY(float startY,
                           AnchorPosition startAnchor,
                           float newY,
                           AnchorPosition newAnchor,
                           float height)

Determines how much the coordinates move vertically from a starting point to the ending point. This function allows computations to occur when the two y values are not the same anchor (if they were, you'd just be able to do newY - startY). This lets you quickly find the vertical delta between ALL points in the region, given any anchored point in the original position compared to any anchored point in the new position. This assumes the height of the region stays constant, and the move is a strict translation.

Parameters:

startY - a point placed inside the starting region with its local position determined by startAnchor

startAnchor - the position of startY inside the starting region (is it on the bottom of the region, the center, or the top)

newY - a point placed inside the ending region with its local position determined by newAnchor

newAnchor - the position of newY inside the ending region (is it on the bottom of the region, the center, or the top)

height - the height of the region being translated (assumed constant)

Returns:

the vertical delta between any same anchor position points in the region (e.g. how much the LEFT_BOTTOM point moves vertically to become the new LEFT_BOTTOM, or the CENTER_TOP moves to become the new CENTER_TOP, etc.)

See Also:

deltaX(float, AnchorPosition, float, AnchorPosition, float)

combine

public static AnchorPosition combine(AnchorPosition horizontal,
                                     AnchorPosition vertical)

Produces a new anchor position which takes the horizontal position from horizontal and the vertical position from vertical.

Parameters:

horizontal - determines if the output anchor is LEFT_, CENTER_, or RIGHT_.

vertical - determines if the output anchor is _BOTTOM, _CENTER, or _TOP.

Returns:

a new anchor

randomAnchor

public static AnchorPosition randomAnchor()

DEBUG.

Returns:

a random anchor position out of the nine possibilities

See Also:

randomAnchor(AnchorPosition)

randomAnchor

public static AnchorPosition randomAnchor(AnchorPosition previous)

DEBUG. Note: will loop until it randomly finds an anchor that isn't the one given - consider using next() instead, which will cycle through the enum and not have to loop.

Parameters:

previous - the anchor position to skip (can't be in the output)

Returns:

a random anchor position excluding the previous

See Also:

next(), randomAnchor()

next

public AnchorPosition next()

DEBUG.

Returns:

the next anchor in the enum (will loop back around and cycle forever)