Overview Package Class Use Source Tree Index Deprecated About
Prev Class | Next ClassFrames | No Frames
Summary: Nested | Field | Method | ConstrDetail: Nested | Field | Method | Constr

javax.swing

Class SizeRequirements

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, extends Object> getClass, finalize, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

alignment

public float alignment
The horizontal or vertical alignment of a component.

maximum

public int maximum
The maximum reasonable width or height of a component.

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.

Constructor Details

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 Details

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

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(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(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)

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(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(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)

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

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

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 interface Object
Returns:
a String representation of this SizeRequirements object
SizeRequirements.java -- Copyright (C) 2002, 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Classpath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Classpath; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination. As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version.

Overview Package Class Use Source Tree Index Deprecated About