|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
java.lang.Objectjavax.swing.SizeRequirements
public class SizeRequirements
This class calculates information about the size and position requirements of components. Two types of layout are supported:
| 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 |
|---|
public int minimum
public int preferred
public int maximum
public float alignment
| Constructor Detail |
|---|
public SizeRequirements()
public SizeRequirements(int min,
int pref,
int max,
float align)
min - the minimum reasonable size of the componentpref - the preferred size of the componentmax - the maximum size of the componentalign - the alignment of the component| Method Detail |
|---|
public String toString()
toString in class ObjectObject.getClass(),
Object.hashCode(),
Class.getName(),
Integer.toHexString(int)public static SizeRequirements getTiledSizeRequirements(SizeRequirements[] children)
children.
children - the SizeRequirements of each of the components
public static SizeRequirements getAlignedSizeRequirements(SizeRequirements[] children)
children.
children - the SizeRequirements of each of the components
public static void calculateTiledPositions(int allocated,
SizeRequirements total,
SizeRequirements[] children,
int[] offsets,
int[] spans)
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.
allocated - the amount of allocated spacetotal - the total size requirements of the componentschildren - the size requirement of each componentoffsets - will hold the offset values for each componentspans - will hold the span values for each component
public static void calculateTiledPositions(int allocated,
SizeRequirements total,
SizeRequirements[] children,
int[] offsets,
int[] spans,
boolean forward)
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).
allocated - the amount of allocated spacetotal - the total size requirements of the componentschildren - the size requirement of each componentoffsets - will hold the offset values for each componentspans - will hold the span values for each componentforward - whether the components should be placed in the forward
direction (left-right or top-bottom) or reverse direction
(right-left or bottom-top)
public static void calculateAlignedPositions(int allocated,
SizeRequirements total,
SizeRequirements[] children,
int[] offsets,
int[] spans)
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.
allocated - the amount of allocated spacetotal - the total size requirements of the componentschildren - the size requirement of each componentoffsets - will hold the offset values for each componentspans - will hold the span values for each component
public static void calculateAlignedPositions(int allocated,
SizeRequirements total,
SizeRequirements[] children,
int[] offset,
int[] spans,
boolean forward)
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).
allocated - the amount of allocated spacetotal - the total size requirements of the componentschildren - the size requirement of each componentspans - will hold the span values for each componentforward - whether the components should be placed in the forward
direction (left-right or top-bottom) or reverse direction
(right-left or bottom-top)
public static int[] adjustSizes(int delta,
SizeRequirements[] children)
delta. delta specifies a change in the
allocated space. The sizes of the children will be shortened or
lengthened to accomodate the new allocation.
delta - the change of the size of the total allocation for
the componentschildren - the size requirements of each component
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||