Class SizeRequirements

For the convenience of layout managers,
calculates information about the size and position of components.
All size and position calculation methods are class methods
that take arrays of SizeRequirements as arguments.
The SizeRequirements class supports two types of layout:

tiled

The components are placed end-to-end,
starting either at coordinate 0 (the leftmost or topmost position)
or at the coordinate representing the end of the allocated span
(the rightmost or bottommost position).

aligned

The components are aligned as specified
by each component's X or Y alignment value.

Each SizeRequirements object contains information
about either the width (and X alignment)
or height (and Y alignment)
of a single component or a group of components:

minimum

The smallest reasonable width/height of the component
or component group, in pixels.

preferred

The natural width/height of the component
or component group, in pixels.

maximum

The largest reasonable width/height of the component
or component group, in pixels.

alignment

The X/Y alignment of the component
or component group.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing. As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

getTiledSizeRequirements

Determines the total space necessary to
place a set of components end-to-end. The needs
of each component in the set are represented by an entry in the
passed-in SizeRequirements array.
The returned SizeRequirements object has an alignment of 0.5
(centered). The space requirement is never more than
Integer.MAX_VALUE.

Parameters:

children - the space requirements for a set of components.
The vector may be of zero length, which will result in a
default SizeRequirements object instance being passed back.

Returns:

the total space requirements.

getAlignedSizeRequirements

Determines the total space necessary to
align a set of components. The needs
of each component in the set are represented by an entry in the
passed-in SizeRequirements array. The total space required will
never be more than Integer.MAX_VALUE.

Parameters:

children - the set of child requirements. If of zero length,
the returns result will be a default instance of SizeRequirements.

Returns:

the total space requirements.

calculateTiledPositions

Creates a set of offset/span pairs representing how to
lay out a set of components end-to-end.
This method requires that you specify
the total amount of space to be allocated,
the size requirements for each component to be placed
(specified as an array of SizeRequirements), and
the total size requirement of the set of components.
You can get the total size requirement
by invoking the getTiledSizeRequirements method. The components
will be tiled in the forward direction with offsets increasing from 0.

Parameters:

allocated - the total span to be allocated >= 0.

total - the total of the children requests. This argument
is optional and may be null.

children - the size requirements for each component.

offsets - the offset from 0 for each child where
the spans were allocated (determines placement of the span).

spans - the span allocated for each child to make the
total target span.

calculateTiledPositions

Creates a set of offset/span pairs representing how to
lay out a set of components end-to-end.
This method requires that you specify
the total amount of space to be allocated,
the size requirements for each component to be placed
(specified as an array of SizeRequirements), and
the total size requirement of the set of components.
You can get the total size requirement
by invoking the getTiledSizeRequirements method.
This method also requires a flag indicating whether components
should be tiled in the forward direction (offsets increasing
from 0) or reverse direction (offsets decreasing from the end
of the allocated space). The forward direction represents
components tiled from left to right or top to bottom. The
reverse direction represents components tiled from right to left
or bottom to top.

Parameters:

allocated - the total span to be allocated >= 0.

total - the total of the children requests. This argument
is optional and may be null.

children - the size requirements for each component.

offsets - the offset from 0 for each child where
the spans were allocated (determines placement of the span).

spans - the span allocated for each child to make the
total target span.

forward - tile with offsets increasing from 0 if true
and with offsets decreasing from the end of the allocated space
if false.

Since:

1.4

calculateAlignedPositions

Creates a bunch of offset/span pairs specifying how to
lay out a set of components with the specified alignments.
The resulting span allocations will overlap, with each one
fitting as well as possible into the given total allocation.
This method requires that you specify
the total amount of space to be allocated,
the size requirements for each component to be placed
(specified as an array of SizeRequirements), and
the total size requirements of the set of components
(only the alignment field of which is actually used).
You can get the total size requirement by invoking
getAlignedSizeRequirements.
Normal alignment will be done with an alignment value of 0.0f
representing the left/top edge of a component.

Parameters:

allocated - the total span to be allocated >= 0.

total - the total of the children requests.

children - the size requirements for each component.

offsets - the offset from 0 for each child where
the spans were allocated (determines placement of the span).

spans - the span allocated for each child to make the
total target span.

calculateAlignedPositions

Creates a set of offset/span pairs specifying how to
lay out a set of components with the specified alignments.
The resulting span allocations will overlap, with each one
fitting as well as possible into the given total allocation.
This method requires that you specify
the total amount of space to be allocated,
the size requirements for each component to be placed
(specified as an array of SizeRequirements), and
the total size requirements of the set of components
(only the alignment field of which is actually used)
You can get the total size requirement by invoking
getAlignedSizeRequirements.
This method also requires a flag indicating whether normal or
reverse alignment should be performed. With normal alignment
the value 0.0f represents the left/top edge of the component
to be aligned. With reverse alignment, 0.0f represents the
right/bottom edge.

Parameters:

allocated - the total span to be allocated >= 0.

total - the total of the children requests.

children - the size requirements for each component.

offsets - the offset from 0 for each child where
the spans were allocated (determines placement of the span).

spans - the span allocated for each child to make the
total target span.