com.io7m.jboxes.core

Class Boxes

java.lang.Object

com.io7m.jboxes.core.Boxes

public final class Boxes
extends Object

Functions to arrange boxes.

Method Summary

Modifier and Type	Method and Description
static <S> BoxType<S>	alignBottomLeft(BoxType<S> outer, BoxType<S> inner) Equivalent to calling alignBottomLeftOffset(BoxType, BoxType, int, int) with zero offsets.
static <S> BoxType<S>	alignBottomLeftOffset(BoxType<S> outer, BoxType<S> inner, int offset_left, int offset_bottom) Align the box inner such that the bottom edge is at least offset_bottom from the inside bottom edge of outer and the left edge is at least offset_left from the inside left edge of outer.
static <S> BoxType<S>	alignBottomRight(BoxType<S> outer, BoxType<S> inner) Equivalent to calling alignBottomRightOffset(BoxType, BoxType, int, int) with zero offsets.
static <S> BoxType<S>	alignBottomRightOffset(BoxType<S> outer, BoxType<S> inner, int offset_right, int offset_bottom) Align the box inner such that the bottom edge is at least offset_bottom from the inside bottom edge of outer and the right edge is at least offset_right from the inside right edge of outer.
static <S> BoxType<S>	alignCenter(BoxType<S> outer, BoxType<S> inner) Align the box inner such that the center of the box is equal to the center of outer.
static <S> BoxType<S>	alignHorizontallyCenter(BoxType<S> outer, BoxType<S> inner) Align the box inner horizontally in the center of outer.
static <S> BoxType<S>	alignHorizontallyLeft(BoxType<S> outer, BoxType<S> inner) Equivalent to calling alignHorizontallyLeftOffset(BoxType, BoxType, int) with a zero offset.
static <S> BoxType<S>	alignHorizontallyLeftOffset(BoxType<S> outer, BoxType<S> inner, int offset) Align the box inner horizontally against the inside left edge of outer.
static <S> BoxType<S>	alignHorizontallyRight(BoxType<S> outer, BoxType<S> inner) Equivalent to calling alignHorizontallyRightOffset(BoxType, BoxType, int) with a zero offset.
static <S> BoxType<S>	alignHorizontallyRightOffset(BoxType<S> outer, BoxType<S> inner, int offset) Align the box inner horizontally against the inside right edge of outer.
static <S> BoxType<S>	alignTopLeft(BoxType<S> outer, BoxType<S> inner) Equivalent to calling alignTopLeftOffset(BoxType, BoxType, int, int) with zero offsets.
static <S> BoxType<S>	alignTopLeftOffset(BoxType<S> outer, BoxType<S> inner, int offset_left, int offset_top) Align the box inner such that the top edge is at least offset_top from the inside top edge of outer and the left edge is at least offset_left from the inside left edge of outer.
static <S> BoxType<S>	alignTopRight(BoxType<S> outer, BoxType<S> inner) Equivalent to calling alignTopRightOffset(BoxType, BoxType, int, int) with zero offsets.
static <S> BoxType<S>	alignTopRightOffset(BoxType<S> outer, BoxType<S> inner, int offset_right, int offset_top) Align the box inner such that the top edge is at least offset_top from the inside top edge of outer and the right edge is at least offset_right from the inside right edge of outer.
static <S> BoxType<S>	alignVerticallyBottom(BoxType<S> outer, BoxType<S> inner) Equivalent to calling alignVerticallyBottomOffset(BoxType, BoxType, int) with a zero offset.
static <S> BoxType<S>	alignVerticallyBottomOffset(BoxType<S> outer, BoxType<S> inner, int offset) Align the box inner vertically against the inside bottom edge of outer.
static <S> BoxType<S>	alignVerticallyCenter(BoxType<S> outer, BoxType<S> inner) Align the box inner vertically in the center of outer.
static <S> BoxType<S>	alignVerticallyTop(BoxType<S> outer, BoxType<S> inner) Equivalent to calling alignVerticallyTopOffset(BoxType, BoxType, int) with a zero offset.
static <S> BoxType<S>	alignVerticallyTopOffset(BoxType<S> outer, BoxType<S> inner, int offset) Align the box inner vertically against the inside top edge of outer.
static <S,T> BoxType<T>	cast(BoxType<S> box) Brand a given box as belonging to a different coordinate space.
static <S> BoxType<S>	containing(BoxType<S> a, BoxType<S> b) Construct a box that will contain both a and b.
static <S> boolean	contains(BoxType<S> a, BoxType<S> b) Determine whether or not one box contains another.
static <S> boolean	containsPoint(BoxType<S> a, int x, int y) Determine whether or not a box contains a given point.
static <S> boolean	couldFitInside(BoxType<S> a, BoxType<S> b) Determine whether or not one box could fit inside another.
static <S> BoxType<S>	create(int x, int y, int width, int height) Create a box of width width and height height, placing the top left corner at (x, y).
static <S> BoxType<S>	fitBetweenHorizontal(BoxType<S> fit, BoxType<S> a, BoxType<S> b) Attempt to fit fit between a and b, horizontally.
static <S> BoxType<S>	fitBetweenVertical(BoxType<S> fit, BoxType<S> a, BoxType<S> b) Attempt to fit fit between a and b, vertically.
static <S> BoxType<S>	hollowOut(BoxType<S> outer, int left_offset, int right_offset, int top_offset, int bottom_offset) Construct a new box that fits inside outer based on the given offsets from each edge.
static <S> BoxType<S>	hollowOutEvenly(BoxType<S> outer, int offset) Equivalent to calling hollowOut(BoxType, int, int, int, int) with offset for all offset parameters.
static <S> BoxType<S>	moveAbsolute(BoxType<S> box, int x, int y) Move the given box to (x, y).
static <S> BoxType<S>	moveRelative(BoxType<S> box, int x, int y) Move the given box by (x, y).
static <S> BoxType<S>	moveToOrigin(BoxType<S> box) Move the given box to (0, 0).
static <S> boolean	overlaps(BoxType<S> a, BoxType<S> b) Determine whether or not two boxes overlap.
static <S> BoxType<S>	scaleFromBottomLeft(BoxType<S> box, int x_diff, int y_diff) Scale box by adding x_diff to the width, and y_diff to the height.
static <S> BoxType<S>	scaleFromBottomRight(BoxType<S> box, int x_diff, int y_diff) Scale box by adding x_diff to the width, and y_diff to the height.
static <S> BoxType<S>	scaleFromCenter(BoxType<S> box, int x_diff, int y_diff) Scale box by adding x_diff to the width, and y_diff to the height.
static <S> BoxType<S>	scaleFromTopLeft(BoxType<S> box, int x_diff, int y_diff) Scale box by adding x_diff to the width, and y_diff to the height.
static <S> BoxType<S>	scaleFromTopRight(BoxType<S> box, int x_diff, int y_diff) Scale box by adding x_diff to the width, and y_diff to the height.
static <S> BoxType<S>	setSizeFromBottomLeft(BoxType<S> box, int width, int height) Set the width and height of box to width and height, respectively.
static <S> BoxType<S>	setSizeFromBottomRight(BoxType<S> box, int width, int height) Set the width and height of box to width and height, respectively.
static <S> BoxType<S>	setSizeFromCenter(BoxType<S> box, int width, int height) Set the width and height of box to width and height, respectively.
static <S> BoxType<S>	setSizeFromTopLeft(BoxType<S> box, int width, int height) Set the width and height of box to width and height, respectively.
static <S> BoxType<S>	setSizeFromTopRight(BoxType<S> box, int width, int height) Set the width and height of box to width and height, respectively.
static <S> String	show(BoxType<S> box)
static <S> String	showToBuilder(BoxType<S> box, StringBuilder sb)
static <S> BoxHorizontalSplitType<S>	splitAlongHorizontal(BoxType<S> box, int height) Split box along a horizontal line placed at height units from its own top edge.
static <S> BoxVerticalSplitType<S>	splitAlongVertical(BoxType<S> box, int width) Split box along a vertical line placed at width units from its own left edge.

Methods inherited from class java.lang.Object

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

Method Detail

cast

public static <S,T> BoxType<T> cast(BoxType<S> box)

Brand a given box as belonging to a different coordinate space. Mixing up coordinate spaces is a common source of difficult-to-locate bugs. Use at your own risk.

Type Parameters:

S - The starting coordinate space

T - The resulting coordinate space

Parameters:

box - A box

Returns:

box

moveRelative

public static <S> BoxType<S> moveRelative(BoxType<S> box,
                                          int x,
                                          int y)

Move the given box by (x, y).

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

x - The amount to move on the X axis

y - The amount to move on the Y axis

Returns:

A moved box

moveAbsolute

public static <S> BoxType<S> moveAbsolute(BoxType<S> box,
                                          int x,
                                          int y)

Move the given box to (x, y).

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

x - The position to which to move on the X axis

y - The position to which to move on the Y axis

Returns:

A moved box

moveToOrigin

public static <S> BoxType<S> moveToOrigin(BoxType<S> box)

Move the given box to (0, 0).

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

Returns:

A moved box

create

public static <S> BoxType<S> create(int x,
                                    int y,
                                    int width,
                                    int height)

Create a box of width width and height height, placing the top left corner at (x, y).

Type Parameters:

S - The coordinate space of the box

Parameters:

x - The X value of the top left corner

y - The Y value of the bottom left corner

width - The width of the box

height - The height of the box

Returns:

A box

alignHorizontallyCenter

public static <S> BoxType<S> alignHorizontallyCenter(BoxType<S> outer,
                                                     BoxType<S> inner)

Align the box inner horizontally in the center of outer.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

Returns:

An aligned box

alignHorizontallyLeft

public static <S> BoxType<S> alignHorizontallyLeft(BoxType<S> outer,
                                                   BoxType<S> inner)

Equivalent to calling alignHorizontallyLeftOffset(BoxType, BoxType, int) with a zero offset.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

Returns:

An aligned box

alignHorizontallyLeftOffset

public static <S> BoxType<S> alignHorizontallyLeftOffset(BoxType<S> outer,
                                                         BoxType<S> inner,
                                                         int offset)

Align the box inner horizontally against the inside left edge of outer. The box will be at least offset units from the left edge.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

offset - The offset from the edge

Returns:

An aligned box

alignHorizontallyRight

public static <S> BoxType<S> alignHorizontallyRight(BoxType<S> outer,
                                                    BoxType<S> inner)

Equivalent to calling alignHorizontallyRightOffset(BoxType, BoxType, int) with a zero offset.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

Returns:

An aligned box

alignHorizontallyRightOffset

public static <S> BoxType<S> alignHorizontallyRightOffset(BoxType<S> outer,
                                                          BoxType<S> inner,
                                                          int offset)

Align the box inner horizontally against the inside right edge of outer. The box will be at least offset units from the right edge.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

offset - The offset from the edge

Returns:

An aligned box

alignVerticallyTop

public static <S> BoxType<S> alignVerticallyTop(BoxType<S> outer,
                                                BoxType<S> inner)

Equivalent to calling alignVerticallyTopOffset(BoxType, BoxType, int) with a zero offset.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

Returns:

An aligned box

alignVerticallyTopOffset

public static <S> BoxType<S> alignVerticallyTopOffset(BoxType<S> outer,
                                                      BoxType<S> inner,
                                                      int offset)

Align the box inner vertically against the inside top edge of outer. The box will be at least offset units from the top edge.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

offset - The offset from the edge

Returns:

An aligned box

alignVerticallyBottom

public static <S> BoxType<S> alignVerticallyBottom(BoxType<S> outer,
                                                   BoxType<S> inner)

Equivalent to calling alignVerticallyBottomOffset(BoxType, BoxType, int) with a zero offset.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

Returns:

An aligned box

alignVerticallyBottomOffset

public static <S> BoxType<S> alignVerticallyBottomOffset(BoxType<S> outer,
                                                         BoxType<S> inner,
                                                         int offset)

Align the box inner vertically against the inside bottom edge of outer. The box will be at least offset units from the bottom edge.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

offset - The offset from the edge

Returns:

An aligned box

alignVerticallyCenter

public static <S> BoxType<S> alignVerticallyCenter(BoxType<S> outer,
                                                   BoxType<S> inner)

Align the box inner vertically in the center of outer.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

Returns:

An aligned box

alignTopLeft

public static <S> BoxType<S> alignTopLeft(BoxType<S> outer,
                                          BoxType<S> inner)

Equivalent to calling alignTopLeftOffset(BoxType, BoxType, int, int) with zero offsets.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

Returns:

An aligned box

alignTopLeftOffset

public static <S> BoxType<S> alignTopLeftOffset(BoxType<S> outer,
                                                BoxType<S> inner,
                                                int offset_left,
                                                int offset_top)

Align the box inner such that the top edge is at least offset_top from the inside top edge of outer and the left edge is at least offset_left from the inside left edge of outer.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

offset_left - The offset from the left edge

offset_top - The offset from the top edge

Returns:

An aligned box

alignTopRight

public static <S> BoxType<S> alignTopRight(BoxType<S> outer,
                                           BoxType<S> inner)

Equivalent to calling alignTopRightOffset(BoxType, BoxType, int, int) with zero offsets.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

Returns:

An aligned box

alignTopRightOffset

public static <S> BoxType<S> alignTopRightOffset(BoxType<S> outer,
                                                 BoxType<S> inner,
                                                 int offset_right,
                                                 int offset_top)

Align the box inner such that the top edge is at least offset_top from the inside top edge of outer and the right edge is at least offset_right from the inside right edge of outer.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

offset_right - The offset from the right edge

offset_top - The offset from the top edge

Returns:

An aligned box

alignBottomLeft

public static <S> BoxType<S> alignBottomLeft(BoxType<S> outer,
                                             BoxType<S> inner)

Equivalent to calling alignBottomLeftOffset(BoxType, BoxType, int, int) with zero offsets.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

Returns:

An aligned box

alignBottomLeftOffset

public static <S> BoxType<S> alignBottomLeftOffset(BoxType<S> outer,
                                                   BoxType<S> inner,
                                                   int offset_left,
                                                   int offset_bottom)

Align the box inner such that the bottom edge is at least offset_bottom from the inside bottom edge of outer and the left edge is at least offset_left from the inside left edge of outer.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

offset_left - The offset from the left edge

offset_bottom - The offset from the bottom edge

Returns:

An aligned box

alignBottomRight

public static <S> BoxType<S> alignBottomRight(BoxType<S> outer,
                                              BoxType<S> inner)

Equivalent to calling alignBottomRightOffset(BoxType, BoxType, int, int) with zero offsets.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

Returns:

An aligned box

alignBottomRightOffset

public static <S> BoxType<S> alignBottomRightOffset(BoxType<S> outer,
                                                    BoxType<S> inner,
                                                    int offset_right,
                                                    int offset_bottom)

Align the box inner such that the bottom edge is at least offset_bottom from the inside bottom edge of outer and the right edge is at least offset_right from the inside right edge of outer.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

offset_right - The offset from the right edge

offset_bottom - The offset from the bottom edge

Returns:

An aligned box

alignCenter

public static <S> BoxType<S> alignCenter(BoxType<S> outer,
                                         BoxType<S> inner)

Align the box inner such that the center of the box is equal to the center of outer.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The outer box

inner - The inner box

Returns:

An aligned box

hollowOut

public static <S> BoxType<S> hollowOut(BoxType<S> outer,
                                       int left_offset,
                                       int right_offset,
                                       int top_offset,
                                       int bottom_offset)

Construct a new box that fits inside outer based on the given offsets from each edge.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The containing box

left_offset - The offset from the left edge (must be non-negative)

right_offset - The offset from the right edge (must be non-negative)

top_offset - The offset from the top edge (must be non-negative)

bottom_offset - The offset from the bottom edge (must be non-negative)

Returns:

A new box

hollowOutEvenly

public static <S> BoxType<S> hollowOutEvenly(BoxType<S> outer,
                                             int offset)

Equivalent to calling hollowOut(BoxType, int, int, int, int) with offset for all offset parameters.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

outer - The containing box

offset - The offset from each edge (must be non-negative)

Returns:

A new box

setSizeFromCenter

public static <S> BoxType<S> setSizeFromCenter(BoxType<S> box,
                                               int width,
                                               int height)

Set the width and height of box to width and height, respectively.

The box is resized from its own center.

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

width - The new width (must be non-negative)

height - The new height (must be non-negative)

Returns:

A resized box

setSizeFromTopLeft

public static <S> BoxType<S> setSizeFromTopLeft(BoxType<S> box,
                                                int width,
                                                int height)

Set the width and height of box to width and height, respectively.

The box is resized by moving its top-left corner.

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

width - The new width (must be non-negative)

height - The new height (must be non-negative)

Returns:

A resized box

setSizeFromTopRight

public static <S> BoxType<S> setSizeFromTopRight(BoxType<S> box,
                                                 int width,
                                                 int height)

Set the width and height of box to width and height, respectively.

The box is resized by moving its top-right corner.

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

width - The new width (must be non-negative)

height - The new height (must be non-negative)

Returns:

A resized box

setSizeFromBottomRight

public static <S> BoxType<S> setSizeFromBottomRight(BoxType<S> box,
                                                    int width,
                                                    int height)

Set the width and height of box to width and height, respectively.

The box is resized by moving its bottom-right corner.

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

width - The new width (must be non-negative)

height - The new height (must be non-negative)

Returns:

A resized box

setSizeFromBottomLeft

public static <S> BoxType<S> setSizeFromBottomLeft(BoxType<S> box,
                                                   int width,
                                                   int height)

Set the width and height of box to width and height, respectively.

The box is resized by moving its bottom-left corner.

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

width - The new width (must be non-negative)

height - The new height (must be non-negative)

Returns:

A resized box

scaleFromTopLeft

public static <S> BoxType<S> scaleFromTopLeft(BoxType<S> box,
                                              int x_diff,
                                              int y_diff)

Scale box by adding x_diff to the width, and y_diff to the height. The size of the resulting box is clamped so that its width and height are always non-negative.

The box is resized by moving its top-left corner.

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

x_diff - The X difference

y_diff - The Y difference

Returns:

A resized box

scaleFromTopRight

public static <S> BoxType<S> scaleFromTopRight(BoxType<S> box,
                                               int x_diff,
                                               int y_diff)

Scale box by adding x_diff to the width, and y_diff to the height. The size of the resulting box is clamped so that its width and height are always non-negative.

The box is resized by moving its top-right corner.

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

x_diff - The X difference

y_diff - The Y difference

Returns:

A resized box

scaleFromBottomLeft

public static <S> BoxType<S> scaleFromBottomLeft(BoxType<S> box,
                                                 int x_diff,
                                                 int y_diff)

Scale box by adding x_diff to the width, and y_diff to the height. The size of the resulting box is clamped so that its width and height are always non-negative.

The box is resized by moving its bottom-left corner.

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

x_diff - The X difference

y_diff - The Y difference

Returns:

A resized box

scaleFromBottomRight

public static <S> BoxType<S> scaleFromBottomRight(BoxType<S> box,
                                                  int x_diff,
                                                  int y_diff)

Scale box by adding x_diff to the width, and y_diff to the height. The size of the resulting box is clamped so that its width and height are always non-negative.

The box is resized by moving its bottom-right corner.

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

x_diff - The X difference

y_diff - The Y difference

Returns:

A resized box

scaleFromCenter

public static <S> BoxType<S> scaleFromCenter(BoxType<S> box,
                                             int x_diff,
                                             int y_diff)

Scale box by adding x_diff to the width, and y_diff to the height. The size of the resulting box is clamped so that its width and height are always non-negative.

The box is resized from its own center.

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

x_diff - The X difference

y_diff - The Y difference

Returns:

A resized box

overlaps

public static <S> boolean overlaps(BoxType<S> a,
                                   BoxType<S> b)

Determine whether or not two boxes overlap.

Overlapping is reflexive: overlaps(a, a) == true.

Overlapping is symmetric: overlaps(a, b) == contains(b, a).

Overlapping is not necessarily transitive.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

a - A box

b - A box

Returns:

true iff a overlaps b

couldFitInside

public static <S> boolean couldFitInside(BoxType<S> a,
                                         BoxType<S> b)

Determine whether or not one box could fit inside another.

Fitting is reflexive: couldFitInside(a, a) == true.

Fitting is transitive: couldFitInside(a, b) → couldFitInside(b, c) → couldFitInside(a, c).

Fitting is not necessarily symmetric.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

a - A box

b - A box

Returns:

true iff a could fit inside b

contains

public static <S> boolean contains(BoxType<S> a,
                                   BoxType<S> b)

Determine whether or not one box contains another.

Containing is reflexive: contains(a, a) == true.

Containing is transitive: contains(a, b) → contains(b, c) → contains(a, c).

Containing is not necessarily symmetric.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

a - A box

b - A box

Returns:

true iff a contains b

containing

public static <S> BoxType<S> containing(BoxType<S> a,
                                        BoxType<S> b)

Construct a box that will contain both a and b.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

a - A box

b - A box

Returns:

A box containing a and b

Since:

0.2.0

containsPoint

public static <S> boolean containsPoint(BoxType<S> a,
                                        int x,
                                        int y)

Determine whether or not a box contains a given point.

Type Parameters:

S - The coordinate space of the box

Parameters:

a - A box

x - The X coordinate of the point

y - The Y coordinate of the point

Returns:

true iff a contains (x, y)

fitBetweenHorizontal

public static <S> BoxType<S> fitBetweenHorizontal(BoxType<S> fit,
                                                  BoxType<S> a,
                                                  BoxType<S> b)

Attempt to fit fit between a and b, horizontally.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

fit - The box to be fitted

a - A box

b - A box

Returns:

A fitted box

fitBetweenVertical

public static <S> BoxType<S> fitBetweenVertical(BoxType<S> fit,
                                                BoxType<S> a,
                                                BoxType<S> b)

Attempt to fit fit between a and b, vertically.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

fit - The box to be fitted

a - A box

b - A box

Returns:

A fitted box

splitAlongHorizontal

public static <S> BoxHorizontalSplitType<S> splitAlongHorizontal(BoxType<S> box,
                                                                 int height)

Split box along a horizontal line placed at height units from its own top edge.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

box - The box to be split

height - The relative Y coordinate of the splitting edge

Returns:

A pair of boxes

splitAlongVertical

public static <S> BoxVerticalSplitType<S> splitAlongVertical(BoxType<S> box,
                                                             int width)

Split box along a vertical line placed at width units from its own left edge.

Type Parameters:

S - The coordinate space of the boxes

Parameters:

box - The box to be split

width - The relative X coordinate of the splitting edge

Returns:

A pair of boxes

show

public static <S> String show(BoxType<S> box)

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

Returns:

A terse string describing the position and size of the box

showToBuilder

public static <S> String showToBuilder(BoxType<S> box,
                                       StringBuilder sb)

Type Parameters:

S - The coordinate space of the box

Parameters:

box - The box

sb - A string builder

Returns:

A terse string describing the position and size of the box