javax.swing

Class SizeRequirements

java.lang.Object

javax.swing.SizeRequirements

All Implemented Interfaces:

Serializable

public class SizeRequirements
extends Object
implements Serializable

This class calculates information about the size and position requirements of components. Two types of layout are supported:

• Tiled: the components are placed at position top-left or bottom-right position within their allocated space
• Aligned: the components are placed aligned in their allocated space according to their alignment value

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
float	alignment The horizontal or vertical alignment of a component.
int	maximum The maximum reasonable width or height of a component.
int	minimum The minimum reasonable width or height of a component.
int	preferred The preferred width or height of a component.

Constructor Summary

Constructors

Constructor and Description
SizeRequirements() Creates a SizeRequirements object with minimum, preferred and maximum size set to zero, and an alignment value of 0.5.
SizeRequirements(int min, int pref, int max, float align) Creates a SizeRequirements object with the specified minimum, preferred, maximum and alignment values.

Method Summary

Methods

Modifier and Type	Method and Description
static int[]	adjustSizes(int delta, SizeRequirements[] children) Returns an array of new preferred sizes for the children based on delta.
static void	calculateAlignedPositions(int allocated, SizeRequirements total, SizeRequirements[] children, int[] offsets, int[] spans) Calculate the offsets and spans of the components, when they should be placed end-to-end.
static void	calculateAlignedPositions(int allocated, SizeRequirements total, SizeRequirements[] children, int[] offset, int[] spans, boolean forward) Calculate the offsets and spans of the components, when they should be placed end-to-end.
static void	calculateTiledPositions(int allocated, SizeRequirements total, SizeRequirements[] children, int[] offsets, int[] spans) Calculate the offsets and spans of the components, when they should be placed end-to-end.
static void	calculateTiledPositions(int allocated, SizeRequirements total, SizeRequirements[] children, int[] offsets, int[] spans, boolean forward) Calculate the offsets and spans of the components, when they should be placed end-to-end.
static SizeRequirements	getAlignedSizeRequirements(SizeRequirements[] children) Calculates how much space is nessecary to place a set of components aligned according to their alignment value.
static SizeRequirements	getTiledSizeRequirements(SizeRequirements[] children) Calculates how much space is nessecary to place a set of components end-to-end.
String	toString() Returns a String representation of this SizeRequirements object, containing information about the minimum, preferred, maximum and alignment value.

Methods inherited from class java.lang.Object

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

Field Detail

minimum

public int minimum

The minimum reasonable width or height of a component.

preferred

public int preferred

The preferred width or height of a component.

maximum

public int maximum

The maximum reasonable width or height of a component.

alignment

public float alignment

The horizontal or vertical alignment of a component.

Constructor Detail

SizeRequirements

public SizeRequirements()

Creates a SizeRequirements object with minimum, preferred and maximum size set to zero, and an alignment value of 0.5.

SizeRequirements

public SizeRequirements(int min,
                int pref,
                int max,
                float align)

Creates a SizeRequirements object with the specified minimum, preferred, maximum and alignment values.

Parameters:

min - the minimum reasonable size of the component

pref - the preferred size of the component

max - the maximum size of the component

align - the alignment of the component

Method Detail

toString

public String toString()

Returns a String representation of this SizeRequirements object, containing information about the minimum, preferred, maximum and alignment value.

Overrides:

toString in class Object

Returns:

a String representation of this SizeRequirements object

See Also:

Object.getClass(), Object.hashCode(), Class.getName(), Integer.toHexString(int)

getTiledSizeRequirements

public static SizeRequirements getTiledSizeRequirements(SizeRequirements[] children)

Calculates how much space is nessecary to place a set of components end-to-end. The size requirements of the components is specified in children.

Parameters:

children - the SizeRequirements of each of the components

Returns:

the SizeRequirements that describe how much space is needed to place the components end-to-end

getAlignedSizeRequirements

public static SizeRequirements getAlignedSizeRequirements(SizeRequirements[] children)

Calculates how much space is nessecary to place a set of components aligned according to their alignment value. The size requirements of the components is specified in children.

Parameters:

children - the SizeRequirements of each of the components

Returns:

the SizeRequirements that describe how much space is needed to place the components aligned

calculateTiledPositions

public static void calculateTiledPositions(int allocated,
                           SizeRequirements total,
                           SizeRequirements[] children,
                           int[] offsets,
                           int[] spans)

Calculate the offsets and spans of the components, when they should be placed end-to-end. You must specify the amount of allocated space in allocated, the total size requirements of the set of components in total (this can be calculated using getTiledSizeRequirements(javax.swing.SizeRequirements[]) and the size requirements of the components in children. The calculated offset and span values for each component are then stored in the arrays offsets and spans. The components are placed in the forward direction, beginning with an offset of 0.

Parameters:

allocated - the amount of allocated space

total - the total size requirements of the components

children - the size requirement of each component

offsets - will hold the offset values for each component

spans - will hold the span values for each component

calculateTiledPositions

public static void calculateTiledPositions(int allocated,
                           SizeRequirements total,
                           SizeRequirements[] children,
                           int[] offsets,
                           int[] spans,
                           boolean forward)

Calculate the offsets and spans of the components, when they should be placed end-to-end. You must specify the amount of allocated space in allocated, the total size requirements of the set of components in total (this can be calculated using getTiledSizeRequirements(javax.swing.SizeRequirements[]) and the size requirements of the components in children. The calculated offset and span values for each component are then stored in the arrays offsets and spans. Depending on the value of forward the components are placed in the forward direction (left-right or top-bottom), where the offsets begin with 0, or in the reverse direction (right-left or bottom-top).

Parameters:

allocated - the amount of allocated space

total - the total size requirements of the components

children - the size requirement of each component

offsets - will hold the offset values for each component

spans - will hold the span values for each component

forward - whether the components should be placed in the forward direction (left-right or top-bottom) or reverse direction (right-left or bottom-top)

calculateAlignedPositions

public static void calculateAlignedPositions(int allocated,
                             SizeRequirements total,
                             SizeRequirements[] children,
                             int[] offsets,
                             int[] spans)

Calculate the offsets and spans of the components, when they should be placed end-to-end. You must specify the amount of allocated space in allocated, the total size requirements of the set of components in total (this can be calculated using getTiledSizeRequirements(javax.swing.SizeRequirements[]) and the size requirements of the components in children. The calculated offset and span values for each component are then stored in the arrays offsets and spans. The components are tiled in the forward direction, beginning with an offset of 0.

Parameters:

allocated - the amount of allocated space

total - the total size requirements of the components

children - the size requirement of each component

offsets - will hold the offset values for each component

spans - will hold the span values for each component

calculateAlignedPositions

public static void calculateAlignedPositions(int allocated,
                             SizeRequirements total,
                             SizeRequirements[] children,
                             int[] offset,
                             int[] spans,
                             boolean forward)

Calculate the offsets and spans of the components, when they should be placed end-to-end. You must specify the amount of allocated space in allocated, the total size requirements of the set of components in total (this can be calculated using getTiledSizeRequirements(javax.swing.SizeRequirements[]) and the size requirements of the components in children. The calculated offset and span values for each component are then stored in the arrays offsets and spans. Depending on the value of forward the components are placed in the forward direction (left-right or top-bottom), where the offsets begin with 0, or in the reverse direction (right-left or bottom-top).

Parameters:

allocated - the amount of allocated space

total - the total size requirements of the components

children - the size requirement of each component

spans - will hold the span values for each component

forward - whether the components should be placed in the forward direction (left-right or top-bottom) or reverse direction (right-left or bottom-top)

adjustSizes

public static int[] adjustSizes(int delta,
                SizeRequirements[] children)

Returns an array of new preferred sizes for the children based on delta. delta specifies a change in the allocated space. The sizes of the children will be shortened or lengthened to accomodate the new allocation.

Parameters:

delta - the change of the size of the total allocation for the components

children - the size requirements of each component

Returns:

the new preferred sizes for each component