javax.swing
Class SizeRequirements

java.lang.Object
  extended by 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:

See Also:
Serialized Form

Field Summary
 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
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
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