Home » openjdk-7 » javax » swing » [javadoc | source]
javax.swing
public class: SizeRequirements [javadoc | source]
java.lang.Object
   javax.swing.SizeRequirements

All Implemented Interfaces:
    java$io$Serializable

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 JavaBeansTM has been added to the java.beans package. Please see java.beans.XMLEncoder .

Field Summary
public  int minimum    The minimum size required. For a component comp, this should be equal to either comp.getMinimumSize().width or comp.getMinimumSize().height
public  int preferred    The preferred (natural) size. For a component comp, this should be equal to either comp.getPreferredSize().width or comp.getPreferredSize().height
public  int maximum    The maximum size allowed. For a component comp, this should be equal to either comp.getMaximumSize().width or comp.getMaximumSize().height
public  float alignment    The alignment, specified as a value between 0.0 and 1.0, inclusive. To specify centering, the alignment should be 0.5. 
Constructor:
 public SizeRequirements() 
 public SizeRequirements(int min,
    int pref,
    int max,
    float a) 
Method from javax.swing.SizeRequirements Summary:
adjustSizes,   calculateAlignedPositions,   calculateAlignedPositions,   calculateTiledPositions,   calculateTiledPositions,   getAlignedSizeRequirements,   getTiledSizeRequirements,   toString
Methods from java.lang.Object:
clone,   equals,   finalize,   getClass,   hashCode,   notify,   notifyAll,   toString,   wait,   wait,   wait
Method from javax.swing.SizeRequirements Detail:
 public static int[] adjustSizes(int delta,
    SizeRequirements[] children) 
    Adjust a specified array of sizes by a given amount.
 public static  void calculateAlignedPositions(int allocated,
    SizeRequirements total,
    SizeRequirements[] children,
    int[] offsets,
    int[] spans) 
    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.
 public static  void calculateAlignedPositions(int allocated,
    SizeRequirements total,
    SizeRequirements[] children,
    int[] offsets,
    int[] spans,
    boolean normal) 
    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.
 public static  void calculateTiledPositions(int allocated,
    SizeRequirements total,
    SizeRequirements[] children,
    int[] offsets,
    int[] spans) 
    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.
 public static  void calculateTiledPositions(int allocated,
    SizeRequirements total,
    SizeRequirements[] children,
    int[] offsets,
    int[] spans,
    boolean forward) 
    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.
 public static SizeRequirements getAlignedSizeRequirements(SizeRequirements[] children) 
    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.
 public static SizeRequirements getTiledSizeRequirements(SizeRequirements[] children) 
    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.
 public String toString() 
    Returns a string describing the minimum, preferred, and maximum size requirements, along with the alignment.