/*
* Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package javax.swing;
import java.awt.
Component;
import java.awt.
Container;
import java.awt.
Dimension;
import java.awt.
Insets;
import java.awt.
LayoutManager2;
import java.util.*;
import static java.awt.
Component.
BaselineResizeBehavior;
import static javax.swing.
LayoutStyle.
ComponentPlacement;
import static javax.swing.
SwingConstants.
HORIZONTAL;
import static javax.swing.
SwingConstants.
VERTICAL;
/**
* {@code GroupLayout} is a {@code LayoutManager} that hierarchically
* groups components in order to position them in a {@code Container}.
* {@code GroupLayout} is intended for use by builders, but may be
* hand-coded as well.
* Grouping is done by instances of the {@link Group Group} class. {@code
* GroupLayout} supports two types of groups. A sequential group
* positions its child elements sequentially, one after another. A
* parallel group aligns its child elements in one of four ways.
* <p>
* Each group may contain any number of elements, where an element is
* a {@code Group}, {@code Component}, or gap. A gap can be thought
* of as an invisible component with a minimum, preferred and maximum
* size. In addition {@code GroupLayout} supports a preferred gap,
* whose value comes from {@code LayoutStyle}.
* <p>
* Elements are similar to a spring. Each element has a range as
* specified by a minimum, preferred and maximum. Gaps have either a
* developer-specified range, or a range determined by {@code
* LayoutStyle}. The range for {@code Component}s is determined from
* the {@code Component}'s {@code getMinimumSize}, {@code
* getPreferredSize} and {@code getMaximumSize} methods. In addition,
* when adding {@code Component}s you may specify a particular range
* to use instead of that from the component. The range for a {@code
* Group} is determined by the type of group. A {@code ParallelGroup}'s
* range is the maximum of the ranges of its elements. A {@code
* SequentialGroup}'s range is the sum of the ranges of its elements.
* <p>
* {@code GroupLayout} treats each axis independently. That is, there
* is a group representing the horizontal axis, and a group
* representing the vertical axis. The horizontal group is
* responsible for determining the minimum, preferred and maximum size
* along the horizontal axis as well as setting the x and width of the
* components contained in it. The vertical group is responsible for
* determining the minimum, preferred and maximum size along the
* vertical axis as well as setting the y and height of the
* components contained in it. Each {@code Component} must exist in both
* a horizontal and vertical group, otherwise an {@code IllegalStateException}
* is thrown during layout, or when the minimum, preferred or
* maximum size is requested.
* <p>
* The following diagram shows a sequential group along the horizontal
* axis. The sequential group contains three components. A parallel group
* was used along the vertical axis.
* <p style="text-align:center">
* <img src="doc-files/groupLayout.1.gif" alt="Sequential group along the horizontal axis in three components">
* <p>
* To reinforce that each axis is treated independently the diagram shows
* the range of each group and element along each axis. The
* range of each component has been projected onto the axes,
* and the groups are rendered in blue (horizontal) and red (vertical).
* For readability there is a gap between each of the elements in the
* sequential group.
* <p>
* The sequential group along the horizontal axis is rendered as a solid
* blue line. Notice the sequential group is the sum of the children elements
* it contains.
* <p>
* Along the vertical axis the parallel group is the maximum of the height
* of each of the components. As all three components have the same height,
* the parallel group has the same height.
* <p>
* The following diagram shows the same three components, but with the
* parallel group along the horizontal axis and the sequential group along
* the vertical axis.
*
* <p style="text-align:center">
* <img src="doc-files/groupLayout.2.gif" alt="Sequential group along the vertical axis in three components">
* <p>
* As {@code c1} is the largest of the three components, the parallel
* group is sized to {@code c1}. As {@code c2} and {@code c3} are smaller
* than {@code c1} they are aligned based on the alignment specified
* for the component (if specified) or the default alignment of the
* parallel group. In the diagram {@code c2} and {@code c3} were created
* with an alignment of {@code LEADING}. If the component orientation were
* right-to-left then {@code c2} and {@code c3} would be positioned on
* the opposite side.
* <p>
* The following diagram shows a sequential group along both the horizontal
* and vertical axis.
* <p style="text-align:center">
* <img src="doc-files/groupLayout.3.gif" alt="Sequential group along both the horizontal and vertical axis in three components">
* <p>
* {@code GroupLayout} provides the ability to insert gaps between
* {@code Component}s. The size of the gap is determined by an
* instance of {@code LayoutStyle}. This may be turned on using the
* {@code setAutoCreateGaps} method. Similarly, you may use
* the {@code setAutoCreateContainerGaps} method to insert gaps
* between components that touch the edge of the parent container and the
* container.
* <p>
* The following builds a panel consisting of two labels in
* one column, followed by two textfields in the next column:
* <pre>
* JComponent panel = ...;
* GroupLayout layout = new GroupLayout(panel);
* panel.setLayout(layout);
*
* // Turn on automatically adding gaps between components
* layout.setAutoCreateGaps(true);
*
* // Turn on automatically creating gaps between components that touch
* // the edge of the container and the container.
* layout.setAutoCreateContainerGaps(true);
*
* // Create a sequential group for the horizontal axis.
*
* GroupLayout.SequentialGroup hGroup = layout.createSequentialGroup();
*
* // The sequential group in turn contains two parallel groups.
* // One parallel group contains the labels, the other the text fields.
* // Putting the labels in a parallel group along the horizontal axis
* // positions them at the same x location.
* //
* // Variable indentation is used to reinforce the level of grouping.
* hGroup.addGroup(layout.createParallelGroup().
* addComponent(label1).addComponent(label2));
* hGroup.addGroup(layout.createParallelGroup().
* addComponent(tf1).addComponent(tf2));
* layout.setHorizontalGroup(hGroup);
*
* // Create a sequential group for the vertical axis.
* GroupLayout.SequentialGroup vGroup = layout.createSequentialGroup();
*
* // The sequential group contains two parallel groups that align
* // the contents along the baseline. The first parallel group contains
* // the first label and text field, and the second parallel group contains
* // the second label and text field. By using a sequential group
* // the labels and text fields are positioned vertically after one another.
* vGroup.addGroup(layout.createParallelGroup(Alignment.BASELINE).
* addComponent(label1).addComponent(tf1));
* vGroup.addGroup(layout.createParallelGroup(Alignment.BASELINE).
* addComponent(label2).addComponent(tf2));
* layout.setVerticalGroup(vGroup);
* </pre>
* <p>
* When run the following is produced.
* <p style="text-align:center">
* <img src="doc-files/groupLayout.example.png" alt="Produced horizontal/vertical form">
* <p>
* This layout consists of the following.
* <ul><li>The horizontal axis consists of a sequential group containing two
* parallel groups. The first parallel group contains the labels,
* and the second parallel group contains the text fields.
* <li>The vertical axis consists of a sequential group
* containing two parallel groups. The parallel groups are configured
* to align their components along the baseline. The first parallel
* group contains the first label and first text field, and
* the second group consists of the second label and second
* text field.
* </ul>
* There are a couple of things to notice in this code:
* <ul>
* <li>You need not explicitly add the components to the container; this
* is indirectly done by using one of the {@code add} methods of
* {@code Group}.
* <li>The various {@code add} methods return
* the caller. This allows for easy chaining of invocations. For
* example, {@code group.addComponent(label1).addComponent(label2);} is
* equivalent to
* {@code group.addComponent(label1); group.addComponent(label2);}.
* <li>There are no public constructors for {@code Group}s; instead
* use the create methods of {@code GroupLayout}.
* </ul>
*
* @author Tomas Pavek
* @author Jan Stola
* @author Scott Violet
* @since 1.6
*/
public class
GroupLayout implements
LayoutManager2 {
// Used in size calculations
private static final int
MIN_SIZE = 0;
private static final int
PREF_SIZE = 1;
private static final int
MAX_SIZE = 2;
// Used by prepare, indicates min, pref or max isn't going to be used.
private static final int
SPECIFIC_SIZE = 3;
private static final int
UNSET =
Integer.
MIN_VALUE;
/**
* Indicates the size from the component or gap should be used for a
* particular range value.
*
* @see Group
*/
public static final int
DEFAULT_SIZE = -1;
/**
* Indicates the preferred size from the component or gap should
* be used for a particular range value.
*
* @see Group
*/
public static final int
PREFERRED_SIZE = -2;
// Whether or not we automatically try and create the preferred
// padding between components.
private boolean
autocreatePadding;
// Whether or not we automatically try and create the preferred
// padding between components the touch the edge of the container and
// the container.
private boolean
autocreateContainerPadding;
/**
* Group responsible for layout along the horizontal axis. This is NOT
* the user specified group, use getHorizontalGroup to dig that out.
*/
private
Group horizontalGroup;
/**
* Group responsible for layout along the vertical axis. This is NOT
* the user specified group, use getVerticalGroup to dig that out.
*/
private
Group verticalGroup;
// Maps from Component to ComponentInfo. This is used for tracking
// information specific to a Component.
private
Map<
Component,
ComponentInfo>
componentInfos;
// Container we're doing layout for.
private
Container host;
// Used by areParallelSiblings, cached to avoid excessive garbage.
private
Set<
Spring>
tmpParallelSet;
// Indicates Springs have changed in some way since last change.
private boolean
springsChanged;
// Indicates invalidateLayout has been invoked.
private boolean
isValid;
// Whether or not any preferred padding (or container padding) springs
// exist
private boolean
hasPreferredPaddingSprings;
/**
* The LayoutStyle instance to use, if null the sharedInstance is used.
*/
private
LayoutStyle layoutStyle;
/**
* If true, components that are not visible are treated as though they
* aren't there.
*/
private boolean
honorsVisibility;
/**
* Enumeration of the possible ways {@code ParallelGroup} can align
* its children.
*
* @see #createParallelGroup(Alignment)
* @since 1.6
*/
public enum
Alignment {
/**
* Indicates the elements should be
* aligned to the origin. For the horizontal axis with a left to
* right orientation this means aligned to the left edge. For the
* vertical axis leading means aligned to the top edge.
*
* @see #createParallelGroup(Alignment)
*/
LEADING,
/**
* Indicates the elements should be aligned to the end of the
* region. For the horizontal axis with a left to right
* orientation this means aligned to the right edge. For the
* vertical axis trailing means aligned to the bottom edge.
*
* @see #createParallelGroup(Alignment)
*/
TRAILING,
/**
* Indicates the elements should be centered in
* the region.
*
* @see #createParallelGroup(Alignment)
*/
CENTER,
/**
* Indicates the elements should be aligned along
* their baseline.
*
* @see #createParallelGroup(Alignment)
* @see #createBaselineGroup(boolean,boolean)
*/
BASELINE
}
private static void
checkSize(int
min, int
pref, int
max,
boolean
isComponentSpring) {
checkResizeType(
min,
isComponentSpring);
if (!
isComponentSpring &&
pref < 0) {
throw new
IllegalArgumentException("Pref must be >= 0");
} else if (
isComponentSpring) {
checkResizeType(
pref, true);
}
checkResizeType(
max,
isComponentSpring);
checkLessThan(
min,
pref);
checkLessThan(
pref,
max);
}
private static void
checkResizeType(int
type, boolean
isComponentSpring) {
if (
type < 0 && ((
isComponentSpring &&
type !=
DEFAULT_SIZE &&
type !=
PREFERRED_SIZE) ||
(!
isComponentSpring &&
type !=
PREFERRED_SIZE))) {
throw new
IllegalArgumentException("Invalid size");
}
}
private static void
checkLessThan(int
min, int
max) {
if (
min >= 0 &&
max >= 0 &&
min >
max) {
throw new
IllegalArgumentException(
"Following is not met: min<=pref<=max");
}
}
/**
* Creates a {@code GroupLayout} for the specified {@code Container}.
*
* @param host the {@code Container} the {@code GroupLayout} is
* the {@code LayoutManager} for
* @throws IllegalArgumentException if host is {@code null}
*/
public
GroupLayout(
Container host) {
if (
host == null) {
throw new
IllegalArgumentException("Container must be non-null");
}
honorsVisibility = true;
this.
host =
host;
setHorizontalGroup(
createParallelGroup(
Alignment.
LEADING, true));
setVerticalGroup(
createParallelGroup(
Alignment.
LEADING, true));
componentInfos = new
HashMap<
Component,
ComponentInfo>();
tmpParallelSet = new
HashSet<
Spring>();
}
/**
* Sets whether component visibility is considered when sizing and
* positioning components. A value of {@code true} indicates that
* non-visible components should not be treated as part of the
* layout. A value of {@code false} indicates that components should be
* positioned and sized regardless of visibility.
* <p>
* A value of {@code false} is useful when the visibility of components
* is dynamically adjusted and you don't want surrounding components and
* the sizing to change.
* <p>
* The specified value is used for components that do not have an
* explicit visibility specified.
* <p>
* The default is {@code true}.
*
* @param honorsVisibility whether component visibility is considered when
* sizing and positioning components
* @see #setHonorsVisibility(Component,Boolean)
*/
public void
setHonorsVisibility(boolean
honorsVisibility) {
if (this.
honorsVisibility !=
honorsVisibility) {
this.
honorsVisibility =
honorsVisibility;
springsChanged = true;
isValid = false;
invalidateHost();
}
}
/**
* Returns whether component visibility is considered when sizing and
* positioning components.
*
* @return whether component visibility is considered when sizing and
* positioning components
*/
public boolean
getHonorsVisibility() {
return
honorsVisibility;
}
/**
* Sets whether the component's visibility is considered for
* sizing and positioning. A value of {@code Boolean.TRUE}
* indicates that if {@code component} is not visible it should
* not be treated as part of the layout. A value of {@code false}
* indicates that {@code component} is positioned and sized
* regardless of it's visibility. A value of {@code null}
* indicates the value specified by the single argument method {@code
* setHonorsVisibility} should be used.
* <p>
* If {@code component} is not a child of the {@code Container} this
* {@code GroupLayout} is managing, it will be added to the
* {@code Container}.
*
* @param component the component
* @param honorsVisibility whether visibility of this {@code component} should be
* considered for sizing and positioning
* @throws IllegalArgumentException if {@code component} is {@code null}
* @see #setHonorsVisibility(Component,Boolean)
*/
public void
setHonorsVisibility(
Component component,
Boolean honorsVisibility) {
if (
component == null) {
throw new
IllegalArgumentException("Component must be non-null");
}
getComponentInfo(
component).
setHonorsVisibility(
honorsVisibility);
springsChanged = true;
isValid = false;
invalidateHost();
}
/**
* Sets whether a gap between components should automatically be
* created. For example, if this is {@code true} and you add two
* components to a {@code SequentialGroup} a gap between the
* two components is automatically be created. The default is
* {@code false}.
*
* @param autoCreatePadding whether a gap between components is
* automatically created
*/
public void
setAutoCreateGaps(boolean
autoCreatePadding) {
if (this.
autocreatePadding !=
autoCreatePadding) {
this.
autocreatePadding =
autoCreatePadding;
invalidateHost();
}
}
/**
* Returns {@code true} if gaps between components are automatically
* created.
*
* @return {@code true} if gaps between components are automatically
* created
*/
public boolean
getAutoCreateGaps() {
return
autocreatePadding;
}
/**
* Sets whether a gap between the container and components that
* touch the border of the container should automatically be
* created. The default is {@code false}.
*
* @param autoCreateContainerPadding whether a gap between the container and
* components that touch the border of the container should
* automatically be created
*/
public void
setAutoCreateContainerGaps(boolean
autoCreateContainerPadding){
if (this.
autocreateContainerPadding !=
autoCreateContainerPadding) {
this.
autocreateContainerPadding =
autoCreateContainerPadding;
horizontalGroup =
createTopLevelGroup(
getHorizontalGroup());
verticalGroup =
createTopLevelGroup(
getVerticalGroup());
invalidateHost();
}
}
/**
* Returns {@code true} if gaps between the container and components that
* border the container are automatically created.
*
* @return {@code true} if gaps between the container and components that
* border the container are automatically created
*/
public boolean
getAutoCreateContainerGaps() {
return
autocreateContainerPadding;
}
/**
* Sets the {@code Group} that positions and sizes
* components along the horizontal axis.
*
* @param group the {@code Group} that positions and sizes
* components along the horizontal axis
* @throws IllegalArgumentException if group is {@code null}
*/
public void
setHorizontalGroup(
Group group) {
if (
group == null) {
throw new
IllegalArgumentException("Group must be non-null");
}
horizontalGroup =
createTopLevelGroup(
group);
invalidateHost();
}
/**
* Returns the {@code Group} that positions and sizes components
* along the horizontal axis.
*
* @return the {@code Group} responsible for positioning and
* sizing component along the horizontal axis
*/
private
Group getHorizontalGroup() {
int
index = 0;
if (
horizontalGroup.
springs.
size() > 1) {
index = 1;
}
return (
Group)
horizontalGroup.
springs.
get(
index);
}
/**
* Sets the {@code Group} that positions and sizes
* components along the vertical axis.
*
* @param group the {@code Group} that positions and sizes
* components along the vertical axis
* @throws IllegalArgumentException if group is {@code null}
*/
public void
setVerticalGroup(
Group group) {
if (
group == null) {
throw new
IllegalArgumentException("Group must be non-null");
}
verticalGroup =
createTopLevelGroup(
group);
invalidateHost();
}
/**
* Returns the {@code Group} that positions and sizes components
* along the vertical axis.
*
* @return the {@code Group} responsible for positioning and
* sizing component along the vertical axis
*/
private
Group getVerticalGroup() {
int
index = 0;
if (
verticalGroup.
springs.
size() > 1) {
index = 1;
}
return (
Group)
verticalGroup.
springs.
get(
index);
}
/**
* Wraps the user specified group in a sequential group. If
* container gaps should be generated the necessary springs are
* added.
*/
private
Group createTopLevelGroup(
Group specifiedGroup) {
SequentialGroup group =
createSequentialGroup();
if (
getAutoCreateContainerGaps()) {
group.
addSpring(new
ContainerAutoPreferredGapSpring());
group.
addGroup(
specifiedGroup);
group.
addSpring(new
ContainerAutoPreferredGapSpring());
} else {
group.
addGroup(
specifiedGroup);
}
return
group;
}
/**
* Creates and returns a {@code SequentialGroup}.
*
* @return a new {@code SequentialGroup}
*/
public
SequentialGroup createSequentialGroup() {
return new
SequentialGroup();
}
/**
* Creates and returns a {@code ParallelGroup} with an alignment of
* {@code Alignment.LEADING}. This is a cover method for the more
* general {@code createParallelGroup(Alignment)} method.
*
* @return a new {@code ParallelGroup}
* @see #createParallelGroup(Alignment)
*/
public
ParallelGroup createParallelGroup() {
return
createParallelGroup(
Alignment.
LEADING);
}
/**
* Creates and returns a {@code ParallelGroup} with the specified
* alignment. This is a cover method for the more general {@code
* createParallelGroup(Alignment,boolean)} method with {@code true}
* supplied for the second argument.
*
* @param alignment the alignment for the elements of the group
* @throws IllegalArgumentException if {@code alignment} is {@code null}
* @return a new {@code ParallelGroup}
* @see #createBaselineGroup
* @see ParallelGroup
*/
public
ParallelGroup createParallelGroup(
Alignment alignment) {
return
createParallelGroup(
alignment, true);
}
/**
* Creates and returns a {@code ParallelGroup} with the specified
* alignment and resize behavior. The {@code
* alignment} argument specifies how children elements are
* positioned that do not fill the group. For example, if a {@code
* ParallelGroup} with an alignment of {@code TRAILING} is given
* 100 and a child only needs 50, the child is
* positioned at the position 50 (with a component orientation of
* left-to-right).
* <p>
* Baseline alignment is only useful when used along the vertical
* axis. A {@code ParallelGroup} created with a baseline alignment
* along the horizontal axis is treated as {@code LEADING}.
* <p>
* Refer to {@link GroupLayout.ParallelGroup ParallelGroup} for details on
* the behavior of baseline groups.
*
* @param alignment the alignment for the elements of the group
* @param resizable {@code true} if the group is resizable; if the group
* is not resizable the preferred size is used for the
* minimum and maximum size of the group
* @throws IllegalArgumentException if {@code alignment} is {@code null}
* @return a new {@code ParallelGroup}
* @see #createBaselineGroup
* @see GroupLayout.ParallelGroup
*/
public
ParallelGroup createParallelGroup(
Alignment alignment,
boolean
resizable){
if (
alignment == null) {
throw new
IllegalArgumentException("alignment must be non null");
}
if (
alignment ==
Alignment.
BASELINE) {
return new
BaselineGroup(
resizable);
}
return new
ParallelGroup(
alignment,
resizable);
}
/**
* Creates and returns a {@code ParallelGroup} that aligns it's
* elements along the baseline.
*
* @param resizable whether the group is resizable
* @param anchorBaselineToTop whether the baseline is anchored to
* the top or bottom of the group
* @see #createBaselineGroup
* @see ParallelGroup
*/
public
ParallelGroup createBaselineGroup(boolean
resizable,
boolean
anchorBaselineToTop) {
return new
BaselineGroup(
resizable,
anchorBaselineToTop);
}
/**
* Forces the specified components to have the same size
* regardless of their preferred, minimum or maximum sizes. Components that
* are linked are given the maximum of the preferred size of each of
* the linked components. For example, if you link two components with
* a preferred width of 10 and 20, both components are given a width of 20.
* <p>
* This can be used multiple times to force any number of
* components to share the same size.
* <p>
* Linked Components are not be resizable.
*
* @param components the {@code Component}s that are to have the same size
* @throws IllegalArgumentException if {@code components} is
* {@code null}, or contains {@code null}
* @see #linkSize(int,Component[])
*/
public void
linkSize(
Component...
components) {
linkSize(
SwingConstants.
HORIZONTAL,
components);
linkSize(
SwingConstants.
VERTICAL,
components);
}
/**
* Forces the specified components to have the same size along the
* specified axis regardless of their preferred, minimum or
* maximum sizes. Components that are linked are given the maximum
* of the preferred size of each of the linked components. For
* example, if you link two components along the horizontal axis
* and the preferred width is 10 and 20, both components are given
* a width of 20.
* <p>
* This can be used multiple times to force any number of
* components to share the same size.
* <p>
* Linked {@code Component}s are not be resizable.
*
* @param components the {@code Component}s that are to have the same size
* @param axis the axis to link the size along; one of
* {@code SwingConstants.HORIZONTAL} or
* {@code SwingConstans.VERTICAL}
* @throws IllegalArgumentException if {@code components} is
* {@code null}, or contains {@code null}; or {@code axis}
* is not {@code SwingConstants.HORIZONTAL} or
* {@code SwingConstants.VERTICAL}
*/
public void
linkSize(int
axis,
Component...
components) {
if (
components == null) {
throw new
IllegalArgumentException("Components must be non-null");
}
for (int
counter =
components.length - 1;
counter >= 0;
counter--) {
Component c =
components[
counter];
if (
components[
counter] == null) {
throw new
IllegalArgumentException(
"Components must be non-null");
}
// Force the component to be added
getComponentInfo(
c);
}
int
glAxis;
if (
axis ==
SwingConstants.
HORIZONTAL) {
glAxis =
HORIZONTAL;
} else if (
axis ==
SwingConstants.
VERTICAL) {
glAxis =
VERTICAL;
} else {
throw new
IllegalArgumentException("Axis must be one of " +
"SwingConstants.HORIZONTAL or SwingConstants.VERTICAL");
}
LinkInfo master =
getComponentInfo(
components[
components.length - 1]).
getLinkInfo(
glAxis);
for (int
counter =
components.length - 2;
counter >= 0;
counter--) {
master.
add(
getComponentInfo(
components[
counter]));
}
invalidateHost();
}
/**
* Replaces an existing component with a new one.
*
* @param existingComponent the component that should be removed
* and replaced with {@code newComponent}
* @param newComponent the component to put in
* {@code existingComponent}'s place
* @throws IllegalArgumentException if either of the components are
* {@code null} or {@code existingComponent} is not being managed
* by this layout manager
*/
public void
replace(
Component existingComponent,
Component newComponent) {
if (
existingComponent == null ||
newComponent == null) {
throw new
IllegalArgumentException("Components must be non-null");
}
// Make sure all the components have been registered, otherwise we may
// not update the correct Springs.
if (
springsChanged) {
registerComponents(
horizontalGroup,
HORIZONTAL);
registerComponents(
verticalGroup,
VERTICAL);
}
ComponentInfo info =
componentInfos.
remove(
existingComponent);
if (
info == null) {
throw new
IllegalArgumentException("Component must already exist");
}
host.
remove(
existingComponent);
if (
newComponent.
getParent() !=
host) {
host.
add(
newComponent);
}
info.
setComponent(
newComponent);
componentInfos.
put(
newComponent,
info);
invalidateHost();
}
/**
* Sets the {@code LayoutStyle} used to calculate the preferred
* gaps between components. A value of {@code null} indicates the
* shared instance of {@code LayoutStyle} should be used.
*
* @param layoutStyle the {@code LayoutStyle} to use
* @see LayoutStyle
*/
public void
setLayoutStyle(
LayoutStyle layoutStyle) {
this.
layoutStyle =
layoutStyle;
invalidateHost();
}
/**
* Returns the {@code LayoutStyle} used for calculating the preferred
* gap between components. This returns the value specified to
* {@code setLayoutStyle}, which may be {@code null}.
*
* @return the {@code LayoutStyle} used for calculating the preferred
* gap between components
*/
public
LayoutStyle getLayoutStyle() {
return
layoutStyle;
}
private
LayoutStyle getLayoutStyle0() {
LayoutStyle layoutStyle =
getLayoutStyle();
if (
layoutStyle == null) {
layoutStyle =
LayoutStyle.
getInstance();
}
return
layoutStyle;
}
private void
invalidateHost() {
if (
host instanceof
JComponent) {
((
JComponent)
host).
revalidate();
} else {
host.
invalidate();
}
host.
repaint();
}
//
// LayoutManager
//
/**
* Notification that a {@code Component} has been added to
* the parent container. You should not invoke this method
* directly, instead you should use one of the {@code Group}
* methods to add a {@code Component}.
*
* @param name the string to be associated with the component
* @param component the {@code Component} to be added
*/
public void
addLayoutComponent(
String name,
Component component) {
}
/**
* Notification that a {@code Component} has been removed from
* the parent container. You should not invoke this method
* directly, instead invoke {@code remove} on the parent
* {@code Container}.
*
* @param component the component to be removed
* @see java.awt.Component#remove
*/
public void
removeLayoutComponent(
Component component) {
ComponentInfo info =
componentInfos.
remove(
component);
if (
info != null) {
info.
dispose();
springsChanged = true;
isValid = false;
}
}
/**
* Returns the preferred size for the specified container.
*
* @param parent the container to return the preferred size for
* @return the preferred size for {@code parent}
* @throws IllegalArgumentException if {@code parent} is not
* the same {@code Container} this was created with
* @throws IllegalStateException if any of the components added to
* this layout are not in both a horizontal and vertical group
* @see java.awt.Container#getPreferredSize
*/
public
Dimension preferredLayoutSize(
Container parent) {
checkParent(
parent);
prepare(
PREF_SIZE);
return
adjustSize(
horizontalGroup.
getPreferredSize(
HORIZONTAL),
verticalGroup.
getPreferredSize(
VERTICAL));
}
/**
* Returns the minimum size for the specified container.
*
* @param parent the container to return the size for
* @return the minimum size for {@code parent}
* @throws IllegalArgumentException if {@code parent} is not
* the same {@code Container} that this was created with
* @throws IllegalStateException if any of the components added to
* this layout are not in both a horizontal and vertical group
* @see java.awt.Container#getMinimumSize
*/
public
Dimension minimumLayoutSize(
Container parent) {
checkParent(
parent);
prepare(
MIN_SIZE);
return
adjustSize(
horizontalGroup.
getMinimumSize(
HORIZONTAL),
verticalGroup.
getMinimumSize(
VERTICAL));
}
/**
* Lays out the specified container.
*
* @param parent the container to be laid out
* @throws IllegalStateException if any of the components added to
* this layout are not in both a horizontal and vertical group
*/
public void
layoutContainer(
Container parent) {
// Step 1: Prepare for layout.
prepare(
SPECIFIC_SIZE);
Insets insets =
parent.
getInsets();
int
width =
parent.
getWidth() -
insets.
left -
insets.
right;
int
height =
parent.
getHeight() -
insets.
top -
insets.
bottom;
boolean
ltr =
isLeftToRight();
if (
getAutoCreateGaps() ||
getAutoCreateContainerGaps() ||
hasPreferredPaddingSprings) {
// Step 2: Calculate autopadding springs
calculateAutopadding(
horizontalGroup,
HORIZONTAL,
SPECIFIC_SIZE, 0,
width);
calculateAutopadding(
verticalGroup,
VERTICAL,
SPECIFIC_SIZE, 0,
height);
}
// Step 3: set the size of the groups.
horizontalGroup.
setSize(
HORIZONTAL, 0,
width);
verticalGroup.
setSize(
VERTICAL, 0,
height);
// Step 4: apply the size to the components.
for (
ComponentInfo info :
componentInfos.
values()) {
info.
setBounds(
insets,
width,
ltr);
}
}
//
// LayoutManager2
//
/**
* Notification that a {@code Component} has been added to
* the parent container. You should not invoke this method
* directly, instead you should use one of the {@code Group}
* methods to add a {@code Component}.
*
* @param component the component added
* @param constraints description of where to place the component
*/
public void
addLayoutComponent(
Component component,
Object constraints) {
}
/**
* Returns the maximum size for the specified container.
*
* @param parent the container to return the size for
* @return the maximum size for {@code parent}
* @throws IllegalArgumentException if {@code parent} is not
* the same {@code Container} that this was created with
* @throws IllegalStateException if any of the components added to
* this layout are not in both a horizontal and vertical group
* @see java.awt.Container#getMaximumSize
*/
public
Dimension maximumLayoutSize(
Container parent) {
checkParent(
parent);
prepare(
MAX_SIZE);
return
adjustSize(
horizontalGroup.
getMaximumSize(
HORIZONTAL),
verticalGroup.
getMaximumSize(
VERTICAL));
}
/**
* Returns the alignment along the x axis. This specifies how
* the component would like to be aligned relative to other
* components. The value should be a number between 0 and 1
* where 0 represents alignment along the origin, 1 is aligned
* the furthest away from the origin, 0.5 is centered, etc.
*
* @param parent the {@code Container} hosting this {@code LayoutManager}
* @throws IllegalArgumentException if {@code parent} is not
* the same {@code Container} that this was created with
* @return the alignment; this implementation returns {@code .5}
*/
public float
getLayoutAlignmentX(
Container parent) {
checkParent(
parent);
return .5f;
}
/**
* Returns the alignment along the y axis. This specifies how
* the component would like to be aligned relative to other
* components. The value should be a number between 0 and 1
* where 0 represents alignment along the origin, 1 is aligned
* the furthest away from the origin, 0.5 is centered, etc.
*
* @param parent the {@code Container} hosting this {@code LayoutManager}
* @throws IllegalArgumentException if {@code parent} is not
* the same {@code Container} that this was created with
* @return alignment; this implementation returns {@code .5}
*/
public float
getLayoutAlignmentY(
Container parent) {
checkParent(
parent);
return .5f;
}
/**
* Invalidates the layout, indicating that if the layout manager
* has cached information it should be discarded.
*
* @param parent the {@code Container} hosting this LayoutManager
* @throws IllegalArgumentException if {@code parent} is not
* the same {@code Container} that this was created with
*/
public void
invalidateLayout(
Container parent) {
checkParent(
parent);
// invalidateLayout is called from Container.invalidate, which
// does NOT grab the treelock. All other methods do. To make sure
// there aren't any possible threading problems we grab the tree lock
// here.
synchronized(
parent.
getTreeLock()) {
isValid = false;
}
}
private void
prepare(int
sizeType) {
boolean
visChanged = false;
// Step 1: If not-valid, clear springs and update visibility.
if (!
isValid) {
isValid = true;
horizontalGroup.
setSize(
HORIZONTAL,
UNSET,
UNSET);
verticalGroup.
setSize(
VERTICAL,
UNSET,
UNSET);
for (
ComponentInfo ci :
componentInfos.
values()) {
if (
ci.
updateVisibility()) {
visChanged = true;
}
ci.
clearCachedSize();
}
}
// Step 2: Make sure components are bound to ComponentInfos
if (
springsChanged) {
registerComponents(
horizontalGroup,
HORIZONTAL);
registerComponents(
verticalGroup,
VERTICAL);
}
// Step 3: Adjust the autopadding. This removes existing
// autopadding, then recalculates where it should go.
if (
springsChanged ||
visChanged) {
checkComponents();
horizontalGroup.
removeAutopadding();
verticalGroup.
removeAutopadding();
if (
getAutoCreateGaps()) {
insertAutopadding(true);
} else if (
hasPreferredPaddingSprings ||
getAutoCreateContainerGaps()) {
insertAutopadding(false);
}
springsChanged = false;
}
// Step 4: (for min/pref/max size calculations only) calculate the
// autopadding. This invokes for unsetting the calculated values, then
// recalculating them.
// If sizeType == SPECIFIC_SIZE, it indicates we're doing layout, this
// step will be done later on.
if (
sizeType !=
SPECIFIC_SIZE && (
getAutoCreateGaps() ||
getAutoCreateContainerGaps() ||
hasPreferredPaddingSprings)) {
calculateAutopadding(
horizontalGroup,
HORIZONTAL,
sizeType, 0, 0);
calculateAutopadding(
verticalGroup,
VERTICAL,
sizeType, 0, 0);
}
}
private void
calculateAutopadding(
Group group, int
axis, int
sizeType,
int
origin, int
size) {
group.
unsetAutopadding();
switch(
sizeType) {
case
MIN_SIZE:
size =
group.
getMinimumSize(
axis);
break;
case
PREF_SIZE:
size =
group.
getPreferredSize(
axis);
break;
case
MAX_SIZE:
size =
group.
getMaximumSize(
axis);
break;
default:
break;
}
group.
setSize(
axis,
origin,
size);
group.
calculateAutopadding(
axis);
}
private void
checkComponents() {
for (
ComponentInfo info :
componentInfos.
values()) {
if (
info.
horizontalSpring == null) {
throw new
IllegalStateException(
info.
component +
" is not attached to a horizontal group");
}
if (
info.
verticalSpring == null) {
throw new
IllegalStateException(
info.
component +
" is not attached to a vertical group");
}
}
}
private void
registerComponents(
Group group, int
axis) {
List<
Spring>
springs =
group.
springs;
for (int
counter =
springs.
size() - 1;
counter >= 0;
counter--) {
Spring spring =
springs.
get(
counter);
if (
spring instanceof
ComponentSpring) {
((
ComponentSpring)
spring).
installIfNecessary(
axis);
} else if (
spring instanceof
Group) {
registerComponents((
Group)
spring,
axis);
}
}
}
private
Dimension adjustSize(int
width, int
height) {
Insets insets =
host.
getInsets();
return new
Dimension(
width +
insets.
left +
insets.
right,
height +
insets.
top +
insets.
bottom);
}
private void
checkParent(
Container parent) {
if (
parent !=
host) {
throw new
IllegalArgumentException(
"GroupLayout can only be used with one Container at a time");
}
}
/**
* Returns the {@code ComponentInfo} for the specified Component,
* creating one if necessary.
*/
private
ComponentInfo getComponentInfo(
Component component) {
ComponentInfo info =
componentInfos.
get(
component);
if (
info == null) {
info = new
ComponentInfo(
component);
componentInfos.
put(
component,
info);
if (
component.
getParent() !=
host) {
host.
add(
component);
}
}
return
info;
}
/**
* Adjusts the autopadding springs for the horizontal and vertical
* groups. If {@code insert} is {@code true} this will insert auto padding
* springs, otherwise this will only adjust the springs that
* comprise auto preferred padding springs.
*/
private void
insertAutopadding(boolean
insert) {
horizontalGroup.
insertAutopadding(
HORIZONTAL,
new
ArrayList<
AutoPreferredGapSpring>(1),
new
ArrayList<
AutoPreferredGapSpring>(1),
new
ArrayList<
ComponentSpring>(1),
new
ArrayList<
ComponentSpring>(1),
insert);
verticalGroup.
insertAutopadding(
VERTICAL,
new
ArrayList<
AutoPreferredGapSpring>(1),
new
ArrayList<
AutoPreferredGapSpring>(1),
new
ArrayList<
ComponentSpring>(1),
new
ArrayList<
ComponentSpring>(1),
insert);
}
/**
* Returns {@code true} if the two Components have a common ParallelGroup
* ancestor along the particular axis.
*/
private boolean
areParallelSiblings(
Component source,
Component target,
int
axis) {
ComponentInfo sourceInfo =
getComponentInfo(
source);
ComponentInfo targetInfo =
getComponentInfo(
target);
Spring sourceSpring;
Spring targetSpring;
if (
axis ==
HORIZONTAL) {
sourceSpring =
sourceInfo.
horizontalSpring;
targetSpring =
targetInfo.
horizontalSpring;
} else {
sourceSpring =
sourceInfo.
verticalSpring;
targetSpring =
targetInfo.
verticalSpring;
}
Set<
Spring>
sourcePath =
tmpParallelSet;
sourcePath.
clear();
Spring spring =
sourceSpring.
getParent();
while (
spring != null) {
sourcePath.
add(
spring);
spring =
spring.
getParent();
}
spring =
targetSpring.
getParent();
while (
spring != null) {
if (
sourcePath.
contains(
spring)) {
sourcePath.
clear();
while (
spring != null) {
if (
spring instanceof
ParallelGroup) {
return true;
}
spring =
spring.
getParent();
}
return false;
}
spring =
spring.
getParent();
}
sourcePath.
clear();
return false;
}
private boolean
isLeftToRight() {
return
host.
getComponentOrientation().
isLeftToRight();
}
/**
* Returns a string representation of this {@code GroupLayout}.
* This method is intended to be used for debugging purposes,
* and the content and format of the returned string may vary
* between implementations.
*
* @return a string representation of this {@code GroupLayout}
**/
public
String toString() {
if (
springsChanged) {
registerComponents(
horizontalGroup,
HORIZONTAL);
registerComponents(
verticalGroup,
VERTICAL);
}
StringBuffer buffer = new
StringBuffer();
buffer.
append("HORIZONTAL\n");
createSpringDescription(
buffer,
horizontalGroup, " ",
HORIZONTAL);
buffer.
append("\nVERTICAL\n");
createSpringDescription(
buffer,
verticalGroup, " ",
VERTICAL);
return
buffer.
toString();
}
private void
createSpringDescription(
StringBuffer buffer,
Spring spring,
String indent, int
axis) {
String origin = "";
String padding = "";
if (
spring instanceof
ComponentSpring) {
ComponentSpring cSpring = (
ComponentSpring)
spring;
origin =
Integer.
toString(
cSpring.
getOrigin()) + " ";
String name =
cSpring.
getComponent().
getName();
if (
name != null) {
origin = "name=" +
name + ", ";
}
}
if (
spring instanceof
AutoPreferredGapSpring) {
AutoPreferredGapSpring paddingSpring =
(
AutoPreferredGapSpring)
spring;
padding = ", userCreated=" +
paddingSpring.
getUserCreated() +
", matches=" +
paddingSpring.
getMatchDescription();
}
buffer.
append(
indent +
spring.
getClass().
getName() + " " +
Integer.
toHexString(
spring.
hashCode()) + " " +
origin +
", size=" +
spring.
getSize() +
", alignment=" +
spring.
getAlignment() +
" prefs=[" +
spring.
getMinimumSize(
axis) +
" " +
spring.
getPreferredSize(
axis) +
" " +
spring.
getMaximumSize(
axis) +
padding + "]\n");
if (
spring instanceof
Group) {
List<
Spring>
springs = ((
Group)
spring).
springs;
indent += " ";
for (int
counter = 0;
counter <
springs.
size();
counter++) {
createSpringDescription(
buffer,
springs.
get(
counter),
indent,
axis);
}
}
}
/**
* Spring consists of a range: min, pref and max, a value some where in
* the middle of that, and a location. Spring caches the
* min/max/pref. If the min/pref/max has internally changes, or needs
* to be updated you must invoke clear.
*/
private abstract class
Spring {
private int
size;
private int
min;
private int
max;
private int
pref;
private
Spring parent;
private
Alignment alignment;
Spring() {
min =
pref =
max =
UNSET;
}
/**
* Calculates and returns the minimum size.
*
* @param axis the axis of layout; one of HORIZONTAL or VERTICAL
* @return the minimum size
*/
abstract int
calculateMinimumSize(int
axis);
/**
* Calculates and returns the preferred size.
*
* @param axis the axis of layout; one of HORIZONTAL or VERTICAL
* @return the preferred size
*/
abstract int
calculatePreferredSize(int
axis);
/**
* Calculates and returns the minimum size.
*
* @param axis the axis of layout; one of HORIZONTAL or VERTICAL
* @return the minimum size
*/
abstract int
calculateMaximumSize(int
axis);
/**
* Sets the parent of this Spring.
*/
void
setParent(
Spring parent) {
this.
parent =
parent;
}
/**
* Returns the parent of this spring.
*/
Spring getParent() {
return
parent;
}
// This is here purely as a convenience for ParallelGroup to avoid
// having to track alignment separately.
void
setAlignment(
Alignment alignment) {
this.
alignment =
alignment;
}
/**
* Alignment for this Spring, this may be null.
*/
Alignment getAlignment() {
return
alignment;
}
/**
* Returns the minimum size.
*/
final int
getMinimumSize(int
axis) {
if (
min ==
UNSET) {
min =
constrain(
calculateMinimumSize(
axis));
}
return
min;
}
/**
* Returns the preferred size.
*/
final int
getPreferredSize(int
axis) {
if (
pref ==
UNSET) {
pref =
constrain(
calculatePreferredSize(
axis));
}
return
pref;
}
/**
* Returns the maximum size.
*/
final int
getMaximumSize(int
axis) {
if (
max ==
UNSET) {
max =
constrain(
calculateMaximumSize(
axis));
}
return
max;
}
/**
* Sets the value and location of the spring. Subclasses
* will want to invoke super, then do any additional sizing.
*
* @param axis HORIZONTAL or VERTICAL
* @param origin of this Spring
* @param size of the Spring. If size is UNSET, this invokes
* clear.
*/
void
setSize(int
axis, int
origin, int
size) {
this.
size =
size;
if (
size ==
UNSET) {
unset();
}
}
/**
* Resets the cached min/max/pref.
*/
void
unset() {
size =
min =
pref =
max =
UNSET;
}
/**
* Returns the current size.
*/
int
getSize() {
return
size;
}
int
constrain(int
value) {
return
Math.
min(
value,
Short.
MAX_VALUE);
}
int
getBaseline() {
return -1;
}
BaselineResizeBehavior getBaselineResizeBehavior() {
return
BaselineResizeBehavior.
OTHER;
}
final boolean
isResizable(int
axis) {
int
min =
getMinimumSize(
axis);
int
pref =
getPreferredSize(
axis);
return (
min !=
pref ||
pref !=
getMaximumSize(
axis));
}
/**
* Returns {@code true} if this spring will ALWAYS have a zero
* size. This should NOT check the current size, rather it's
* meant to quickly test if this Spring will always have a
* zero size.
*
* @param treatAutopaddingAsZeroSized if {@code true}, auto padding
* springs should be treated as having a size of {@code 0}
* @return {@code true} if this spring will have a zero size,
* {@code false} otherwise
*/
abstract boolean
willHaveZeroSize(boolean
treatAutopaddingAsZeroSized);
}
/**
* {@code Group} provides the basis for the two types of
* operations supported by {@code GroupLayout}: laying out
* components one after another ({@link SequentialGroup SequentialGroup})
* or aligned ({@link ParallelGroup ParallelGroup}). {@code Group} and
* its subclasses have no public constructor; to create one use
* one of {@code createSequentialGroup} or
* {@code createParallelGroup}. Additionally, taking a {@code Group}
* created from one {@code GroupLayout} and using it with another
* will produce undefined results.
* <p>
* Various methods in {@code Group} and its subclasses allow you
* to explicitly specify the range. The arguments to these methods
* can take two forms, either a value greater than or equal to 0,
* or one of {@code DEFAULT_SIZE} or {@code PREFERRED_SIZE}. A
* value greater than or equal to {@code 0} indicates a specific
* size. {@code DEFAULT_SIZE} indicates the corresponding size
* from the component should be used. For example, if {@code
* DEFAULT_SIZE} is passed as the minimum size argument, the
* minimum size is obtained from invoking {@code getMinimumSize}
* on the component. Likewise, {@code PREFERRED_SIZE} indicates
* the value from {@code getPreferredSize} should be used.
* The following example adds {@code myComponent} to {@code group}
* with specific values for the range. That is, the minimum is
* explicitly specified as 100, preferred as 200, and maximum as
* 300.
* <pre>
* group.addComponent(myComponent, 100, 200, 300);
* </pre>
* The following example adds {@code myComponent} to {@code group} using
* a combination of the forms. The minimum size is forced to be the
* same as the preferred size, the preferred size is determined by
* using {@code myComponent.getPreferredSize} and the maximum is
* determined by invoking {@code getMaximumSize} on the component.
* <pre>
* group.addComponent(myComponent, GroupLayout.PREFERRED_SIZE,
* GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE);
* </pre>
* <p>
* Unless otherwise specified all the methods of {@code Group} and
* its subclasses that allow you to specify a range throw an
* {@code IllegalArgumentException} if passed an invalid range. An
* invalid range is one in which any of the values are < 0 and
* not one of {@code PREFERRED_SIZE} or {@code DEFAULT_SIZE}, or
* the following is not met (for specific values): {@code min}
* <= {@code pref} <= {@code max}.
* <p>
* Similarly any methods that take a {@code Component} throw a
* {@code IllegalArgumentException} if passed {@code null} and any methods
* that take a {@code Group} throw an {@code NullPointerException} if
* passed {@code null}.
*
* @see #createSequentialGroup
* @see #createParallelGroup
* @since 1.6
*/
public abstract class
Group extends
Spring {
// private int origin;
// private int size;
List<
Spring>
springs;
Group() {
springs = new
ArrayList<
Spring>();
}
/**
* Adds a {@code Group} to this {@code Group}.
*
* @param group the {@code Group} to add
* @return this {@code Group}
*/
public
Group addGroup(
Group group) {
return
addSpring(
group);
}
/**
* Adds a {@code Component} to this {@code Group}.
*
* @param component the {@code Component} to add
* @return this {@code Group}
*/
public
Group addComponent(
Component component) {
return
addComponent(
component,
DEFAULT_SIZE,
DEFAULT_SIZE,
DEFAULT_SIZE);
}
/**
* Adds a {@code Component} to this {@code Group}
* with the specified size.
*
* @param component the {@code Component} to add
* @param min the minimum size or one of {@code DEFAULT_SIZE} or
* {@code PREFERRED_SIZE}
* @param pref the preferred size or one of {@code DEFAULT_SIZE} or
* {@code PREFERRED_SIZE}
* @param max the maximum size or one of {@code DEFAULT_SIZE} or
* {@code PREFERRED_SIZE}
* @return this {@code Group}
*/
public
Group addComponent(
Component component, int
min, int
pref,
int
max) {
return
addSpring(new
ComponentSpring(
component,
min,
pref,
max));
}
/**
* Adds a rigid gap to this {@code Group}.
*
* @param size the size of the gap
* @return this {@code Group}
* @throws IllegalArgumentException if {@code size} is less than
* {@code 0}
*/
public
Group addGap(int
size) {
return
addGap(
size,
size,
size);
}
/**
* Adds a gap to this {@code Group} with the specified size.
*
* @param min the minimum size of the gap
* @param pref the preferred size of the gap
* @param max the maximum size of the gap
* @throws IllegalArgumentException if any of the values are
* less than {@code 0}
* @return this {@code Group}
*/
public
Group addGap(int
min, int
pref, int
max) {
return
addSpring(new
GapSpring(
min,
pref,
max));
}
Spring getSpring(int
index) {
return
springs.
get(
index);
}
int
indexOf(
Spring spring) {
return
springs.
indexOf(
spring);
}
/**
* Adds the Spring to the list of {@code Spring}s and returns
* the receiver.
*/
Group addSpring(
Spring spring) {
springs.
add(
spring);
spring.
setParent(this);
if (!(
spring instanceof
AutoPreferredGapSpring) ||
!((
AutoPreferredGapSpring)
spring).
getUserCreated()) {
springsChanged = true;
}
return this;
}
//
// Spring methods
//
void
setSize(int
axis, int
origin, int
size) {
super.setSize(
axis,
origin,
size);
if (
size ==
UNSET) {
for (int
counter =
springs.
size() - 1;
counter >= 0;
counter--) {
getSpring(
counter).
setSize(
axis,
origin,
size);
}
} else {
setValidSize(
axis,
origin,
size);
}
}
/**
* This is invoked from {@code setSize} if passed a value
* other than UNSET.
*/
abstract void
setValidSize(int
axis, int
origin, int
size);
int
calculateMinimumSize(int
axis) {
return
calculateSize(
axis,
MIN_SIZE);
}
int
calculatePreferredSize(int
axis) {
return
calculateSize(
axis,
PREF_SIZE);
}
int
calculateMaximumSize(int
axis) {
return
calculateSize(
axis,
MAX_SIZE);
}
/**
* Calculates the specified size. This is called from
* one of the {@code getMinimumSize0},
* {@code getPreferredSize0} or
* {@code getMaximumSize0} methods. This will invoke
* to {@code operator} to combine the values.
*/
int
calculateSize(int
axis, int
type) {
int
count =
springs.
size();
if (
count == 0) {
return 0;
}
if (
count == 1) {
return
getSpringSize(
getSpring(0),
axis,
type);
}
int
size =
constrain(
operator(
getSpringSize(
getSpring(0),
axis,
type),
getSpringSize(
getSpring(1),
axis,
type)));
for (int
counter = 2;
counter <
count;
counter++) {
size =
constrain(
operator(
size,
getSpringSize(
getSpring(
counter),
axis,
type)));
}
return
size;
}
int
getSpringSize(
Spring spring, int
axis, int
type) {
switch(
type) {
case
MIN_SIZE:
return
spring.
getMinimumSize(
axis);
case
PREF_SIZE:
return
spring.
getPreferredSize(
axis);
case
MAX_SIZE:
return
spring.
getMaximumSize(
axis);
}
assert false;
return 0;
}
/**
* Used to compute how the two values representing two springs
* will be combined. For example, a group that layed things out
* one after the next would return {@code a + b}.
*/
abstract int
operator(int
a, int
b);
//
// Padding
//
/**
* Adjusts the autopadding springs in this group and its children.
* If {@code insert} is true this will insert auto padding
* springs, otherwise this will only adjust the springs that
* comprise auto preferred padding springs.
*
* @param axis the axis of the springs; HORIZONTAL or VERTICAL
* @param leadingPadding List of AutopaddingSprings that occur before
* this Group
* @param trailingPadding any trailing autopadding springs are added
* to this on exit
* @param leading List of ComponentSprings that occur before this Group
* @param trailing any trailing ComponentSpring are added to this
* List
* @param insert Whether or not to insert AutopaddingSprings or just
* adjust any existing AutopaddingSprings.
*/
abstract void
insertAutopadding(int
axis,
List<
AutoPreferredGapSpring>
leadingPadding,
List<
AutoPreferredGapSpring>
trailingPadding,
List<
ComponentSpring>
leading,
List<
ComponentSpring>
trailing,
boolean
insert);
/**
* Removes any AutopaddingSprings for this Group and its children.
*/
void
removeAutopadding() {
unset();
for (int
counter =
springs.
size() - 1;
counter >= 0;
counter--) {
Spring spring =
springs.
get(
counter);
if (
spring instanceof
AutoPreferredGapSpring) {
if (((
AutoPreferredGapSpring)
spring).
getUserCreated()) {
((
AutoPreferredGapSpring)
spring).
reset();
} else {
springs.
remove(
counter);
}
} else if (
spring instanceof
Group) {
((
Group)
spring).
removeAutopadding();
}
}
}
void
unsetAutopadding() {
// Clear cached pref/min/max.
unset();
for (int
counter =
springs.
size() - 1;
counter >= 0;
counter--) {
Spring spring =
springs.
get(
counter);
if (
spring instanceof
AutoPreferredGapSpring) {
spring.
unset();
} else if (
spring instanceof
Group) {
((
Group)
spring).
unsetAutopadding();
}
}
}
void
calculateAutopadding(int
axis) {
for (int
counter =
springs.
size() - 1;
counter >= 0;
counter--) {
Spring spring =
springs.
get(
counter);
if (
spring instanceof
AutoPreferredGapSpring) {
// Force size to be reset.
spring.
unset();
((
AutoPreferredGapSpring)
spring).
calculatePadding(
axis);
} else if (
spring instanceof
Group) {
((
Group)
spring).
calculateAutopadding(
axis);
}
}
// Clear cached pref/min/max.
unset();
}
@
Override
boolean
willHaveZeroSize(boolean
treatAutopaddingAsZeroSized) {
for (int
i =
springs.
size() - 1;
i >= 0;
i--) {
Spring spring =
springs.
get(
i);
if (!
spring.
willHaveZeroSize(
treatAutopaddingAsZeroSized)) {
return false;
}
}
return true;
}
}
/**
* A {@code Group} that positions and sizes its elements
* sequentially, one after another. This class has no public
* constructor, use the {@code createSequentialGroup} method
* to create one.
* <p>
* In order to align a {@code SequentialGroup} along the baseline
* of a baseline aligned {@code ParallelGroup} you need to specify
* which of the elements of the {@code SequentialGroup} is used to
* determine the baseline. The element used to calculate the
* baseline is specified using one of the {@code add} methods that
* take a {@code boolean}. The last element added with a value of
* {@code true} for {@code useAsBaseline} is used to calculate the
* baseline.
*
* @see #createSequentialGroup
* @since 1.6
*/
public class
SequentialGroup extends
Group {
private
Spring baselineSpring;
SequentialGroup() {
}
/**
* {@inheritDoc}
*/
public
SequentialGroup addGroup(
Group group) {
return (
SequentialGroup)super.addGroup(
group);
}
/**
* Adds a {@code Group} to this {@code Group}.
*
* @param group the {@code Group} to add
* @param useAsBaseline whether the specified {@code Group} should
* be used to calculate the baseline for this {@code Group}
* @return this {@code Group}
*/
public
SequentialGroup addGroup(boolean
useAsBaseline,
Group group) {
super.addGroup(
group);
if (
useAsBaseline) {
baselineSpring =
group;
}
return this;
}
/**
* {@inheritDoc}
*/
public
SequentialGroup addComponent(
Component component) {
return (
SequentialGroup)super.addComponent(
component);
}
/**
* Adds a {@code Component} to this {@code Group}.
*
* @param useAsBaseline whether the specified {@code Component} should
* be used to calculate the baseline for this {@code Group}
* @param component the {@code Component} to add
* @return this {@code Group}
*/
public
SequentialGroup addComponent(boolean
useAsBaseline,
Component component) {
super.addComponent(
component);
if (
useAsBaseline) {
baselineSpring =
springs.
get(
springs.
size() - 1);
}
return this;
}
/**
* {@inheritDoc}
*/
public
SequentialGroup addComponent(
Component component, int
min,
int
pref, int
max) {
return (
SequentialGroup)super.addComponent(
component,
min,
pref,
max);
}
/**
* Adds a {@code Component} to this {@code Group}
* with the specified size.
*
* @param useAsBaseline whether the specified {@code Component} should
* be used to calculate the baseline for this {@code Group}
* @param component the {@code Component} to add
* @param min the minimum size or one of {@code DEFAULT_SIZE} or
* {@code PREFERRED_SIZE}
* @param pref the preferred size or one of {@code DEFAULT_SIZE} or
* {@code PREFERRED_SIZE}
* @param max the maximum size or one of {@code DEFAULT_SIZE} or
* {@code PREFERRED_SIZE}
* @return this {@code Group}
*/
public
SequentialGroup addComponent(boolean
useAsBaseline,
Component component, int
min, int
pref, int
max) {
super.addComponent(
component,
min,
pref,
max);
if (
useAsBaseline) {
baselineSpring =
springs.
get(
springs.
size() - 1);
}
return this;
}
/**
* {@inheritDoc}
*/
public
SequentialGroup addGap(int
size) {
return (
SequentialGroup)super.addGap(
size);
}
/**
* {@inheritDoc}
*/
public
SequentialGroup addGap(int
min, int
pref, int
max) {
return (
SequentialGroup)super.addGap(
min,
pref,
max);
}
/**
* Adds an element representing the preferred gap between two
* components. The element created to represent the gap is not
* resizable.
*
* @param comp1 the first component
* @param comp2 the second component
* @param type the type of gap; one of the constants defined by
* {@code LayoutStyle}
* @return this {@code SequentialGroup}
* @throws IllegalArgumentException if {@code type}, {@code comp1} or
* {@code comp2} is {@code null}
* @see LayoutStyle
*/
public
SequentialGroup addPreferredGap(
JComponent comp1,
JComponent comp2,
ComponentPlacement type) {
return
addPreferredGap(
comp1,
comp2,
type,
DEFAULT_SIZE,
PREFERRED_SIZE);
}
/**
* Adds an element representing the preferred gap between two
* components.
*
* @param comp1 the first component
* @param comp2 the second component
* @param type the type of gap
* @param pref the preferred size of the grap; one of
* {@code DEFAULT_SIZE} or a value >= 0
* @param max the maximum size of the gap; one of
* {@code DEFAULT_SIZE}, {@code PREFERRED_SIZE}
* or a value >= 0
* @return this {@code SequentialGroup}
* @throws IllegalArgumentException if {@code type}, {@code comp1} or
* {@code comp2} is {@code null}
* @see LayoutStyle
*/
public
SequentialGroup addPreferredGap(
JComponent comp1,
JComponent comp2,
ComponentPlacement type, int
pref,
int
max) {
if (
type == null) {
throw new
IllegalArgumentException("Type must be non-null");
}
if (
comp1 == null ||
comp2 == null) {
throw new
IllegalArgumentException(
"Components must be non-null");
}
checkPreferredGapValues(
pref,
max);
return (
SequentialGroup)
addSpring(new
PreferredGapSpring(
comp1,
comp2,
type,
pref,
max));
}
/**
* Adds an element representing the preferred gap between the
* nearest components. During layout, neighboring
* components are found, and the size of the added gap is set
* based on the preferred gap between the components. If no
* neighboring components are found the gap has a size of {@code 0}.
* <p>
* The element created to represent the gap is not
* resizable.
*
* @param type the type of gap; one of
* {@code LayoutStyle.ComponentPlacement.RELATED} or
* {@code LayoutStyle.ComponentPlacement.UNRELATED}
* @return this {@code SequentialGroup}
* @see LayoutStyle
* @throws IllegalArgumentException if {@code type} is not one of
* {@code LayoutStyle.ComponentPlacement.RELATED} or
* {@code LayoutStyle.ComponentPlacement.UNRELATED}
*/
public
SequentialGroup addPreferredGap(
ComponentPlacement type) {
return
addPreferredGap(
type,
DEFAULT_SIZE,
DEFAULT_SIZE);
}
/**
* Adds an element representing the preferred gap between the
* nearest components. During layout, neighboring
* components are found, and the minimum of this
* gap is set based on the size of the preferred gap between the
* neighboring components. If no neighboring components are found the
* minimum size is set to 0.
*
* @param type the type of gap; one of
* {@code LayoutStyle.ComponentPlacement.RELATED} or
* {@code LayoutStyle.ComponentPlacement.UNRELATED}
* @param pref the preferred size of the grap; one of
* {@code DEFAULT_SIZE} or a value >= 0
* @param max the maximum size of the gap; one of
* {@code DEFAULT_SIZE}, {@code PREFERRED_SIZE}
* or a value >= 0
* @return this {@code SequentialGroup}
* @throws IllegalArgumentException if {@code type} is not one of
* {@code LayoutStyle.ComponentPlacement.RELATED} or
* {@code LayoutStyle.ComponentPlacement.UNRELATED}
* @see LayoutStyle
*/
public
SequentialGroup addPreferredGap(
ComponentPlacement type,
int
pref, int
max) {
if (
type !=
ComponentPlacement.
RELATED &&
type !=
ComponentPlacement.
UNRELATED) {
throw new
IllegalArgumentException(
"Type must be one of " +
"LayoutStyle.ComponentPlacement.RELATED or " +
"LayoutStyle.ComponentPlacement.UNRELATED");
}
checkPreferredGapValues(
pref,
max);
hasPreferredPaddingSprings = true;
return (
SequentialGroup)
addSpring(new
AutoPreferredGapSpring(
type,
pref,
max));
}
/**
* Adds an element representing the preferred gap between an edge
* the container and components that touch the border of the
* container. This has no effect if the added gap does not
* touch an edge of the parent container.
* <p>
* The element created to represent the gap is not
* resizable.
*
* @return this {@code SequentialGroup}
*/
public
SequentialGroup addContainerGap() {
return
addContainerGap(
DEFAULT_SIZE,
DEFAULT_SIZE);
}
/**
* Adds an element representing the preferred gap between one
* edge of the container and the next or previous {@code
* Component} with the specified size. This has no
* effect if the next or previous element is not a {@code
* Component} and does not touch one edge of the parent
* container.
*
* @param pref the preferred size; one of {@code DEFAULT_SIZE} or a
* value >= 0
* @param max the maximum size; one of {@code DEFAULT_SIZE},
* {@code PREFERRED_SIZE} or a value >= 0
* @return this {@code SequentialGroup}
*/
public
SequentialGroup addContainerGap(int
pref, int
max) {
if ((
pref < 0 &&
pref !=
DEFAULT_SIZE) ||
(
max < 0 &&
max !=
DEFAULT_SIZE &&
max !=
PREFERRED_SIZE)||
(
pref >= 0 &&
max >= 0 &&
pref >
max)) {
throw new
IllegalArgumentException(
"Pref and max must be either DEFAULT_VALUE " +
"or >= 0 and pref <= max");
}
hasPreferredPaddingSprings = true;
return (
SequentialGroup)
addSpring(
new
ContainerAutoPreferredGapSpring(
pref,
max));
}
int
operator(int
a, int
b) {
return
constrain(
a) +
constrain(
b);
}
void
setValidSize(int
axis, int
origin, int
size) {
int
pref =
getPreferredSize(
axis);
if (
size ==
pref) {
// Layout at preferred size
for (
Spring spring :
springs) {
int
springPref =
spring.
getPreferredSize(
axis);
spring.
setSize(
axis,
origin,
springPref);
origin +=
springPref;
}
} else if (
springs.
size() == 1) {
Spring spring =
getSpring(0);
spring.
setSize(
axis,
origin,
Math.
min(
Math.
max(
size,
spring.
getMinimumSize(
axis)),
spring.
getMaximumSize(
axis)));
} else if (
springs.
size() > 1) {
// Adjust between min/pref
setValidSizeNotPreferred(
axis,
origin,
size);
}
}
private void
setValidSizeNotPreferred(int
axis, int
origin, int
size) {
int
delta =
size -
getPreferredSize(
axis);
assert
delta != 0;
boolean
useMin = (
delta < 0);
int
springCount =
springs.
size();
if (
useMin) {
delta *= -1;
}
// The following algorithm if used for resizing springs:
// 1. Calculate the resizability of each spring (pref - min or
// max - pref) into a list.
// 2. Sort the list in ascending order
// 3. Iterate through each of the resizable Springs, attempting
// to give them (pref - size) / resizeCount
// 4. For any Springs that can not accommodate that much space
// add the remainder back to the amount to distribute and
// recalculate how must space the remaining springs will get.
// 5. Set the size of the springs.
// First pass, sort the resizable springs into the List resizable
List<
SpringDelta>
resizable =
buildResizableList(
axis,
useMin);
int
resizableCount =
resizable.
size();
if (
resizableCount > 0) {
// How much we would like to give each Spring.
int
sDelta =
delta /
resizableCount;
// Remaining space.
int
slop =
delta -
sDelta *
resizableCount;
int[]
sizes = new int[
springCount];
int
sign =
useMin ? -1 : 1;
// Second pass, accumulate the resulting deltas (relative to
// preferred) into sizes.
for (int
counter = 0;
counter <
resizableCount;
counter++) {
SpringDelta springDelta =
resizable.
get(
counter);
if ((
counter + 1) ==
resizableCount) {
sDelta +=
slop;
}
springDelta.
delta =
Math.
min(
sDelta,
springDelta.
delta);
delta -=
springDelta.
delta;
if (
springDelta.
delta !=
sDelta &&
counter + 1 <
resizableCount) {
// Spring didn't take all the space, reset how much
// each spring will get.
sDelta =
delta / (
resizableCount -
counter - 1);
slop =
delta -
sDelta * (
resizableCount -
counter - 1);
}
sizes[
springDelta.
index] =
sign *
springDelta.
delta;
}
// And finally set the size of each spring
for (int
counter = 0;
counter <
springCount;
counter++) {
Spring spring =
getSpring(
counter);
int
sSize =
spring.
getPreferredSize(
axis) +
sizes[
counter];
spring.
setSize(
axis,
origin,
sSize);
origin +=
sSize;
}
} else {
// Nothing resizable, use the min or max of each of the
// springs.
for (int
counter = 0;
counter <
springCount;
counter++) {
Spring spring =
getSpring(
counter);
int
sSize;
if (
useMin) {
sSize =
spring.
getMinimumSize(
axis);
} else {
sSize =
spring.
getMaximumSize(
axis);
}
spring.
setSize(
axis,
origin,
sSize);
origin +=
sSize;
}
}
}
/**
* Returns the sorted list of SpringDelta's for the current set of
* Springs. The list is ordered based on the amount of flexibility of
* the springs.
*/
private
List<
SpringDelta>
buildResizableList(int
axis,
boolean
useMin) {
// First pass, figure out what is resizable
int
size =
springs.
size();
List<
SpringDelta>
sorted = new
ArrayList<
SpringDelta>(
size);
for (int
counter = 0;
counter <
size;
counter++) {
Spring spring =
getSpring(
counter);
int
sDelta;
if (
useMin) {
sDelta =
spring.
getPreferredSize(
axis) -
spring.
getMinimumSize(
axis);
} else {
sDelta =
spring.
getMaximumSize(
axis) -
spring.
getPreferredSize(
axis);
}
if (
sDelta > 0) {
sorted.
add(new
SpringDelta(
counter,
sDelta));
}
}
Collections.
sort(
sorted);
return
sorted;
}
private int
indexOfNextNonZeroSpring(
int
index, boolean
treatAutopaddingAsZeroSized) {
while (
index <
springs.
size()) {
Spring spring =
springs.
get(
index);
if (!
spring.
willHaveZeroSize(
treatAutopaddingAsZeroSized)) {
return
index;
}
index++;
}
return
index;
}
@
Override
void
insertAutopadding(int
axis,
List<
AutoPreferredGapSpring>
leadingPadding,
List<
AutoPreferredGapSpring>
trailingPadding,
List<
ComponentSpring>
leading,
List<
ComponentSpring>
trailing,
boolean
insert) {
List<
AutoPreferredGapSpring>
newLeadingPadding =
new
ArrayList<
AutoPreferredGapSpring>(
leadingPadding);
List<
AutoPreferredGapSpring>
newTrailingPadding =
new
ArrayList<
AutoPreferredGapSpring>(1);
List<
ComponentSpring>
newLeading =
new
ArrayList<
ComponentSpring>(
leading);
List<
ComponentSpring>
newTrailing = null;
int
counter = 0;
// Warning, this must use springs.size, as it may change during the
// loop.
while (
counter <
springs.
size()) {
Spring spring =
getSpring(
counter);
if (
spring instanceof
AutoPreferredGapSpring) {
if (
newLeadingPadding.
size() == 0) {
// Autopadding spring. Set the sources of the
// autopadding spring based on newLeading.
AutoPreferredGapSpring padding =
(
AutoPreferredGapSpring)
spring;
padding.
setSources(
newLeading);
newLeading.
clear();
counter =
indexOfNextNonZeroSpring(
counter + 1, true);
if (
counter ==
springs.
size()) {
// Last spring in the list, add it to
// trailingPadding.
if (!(
padding instanceof
ContainerAutoPreferredGapSpring)) {
trailingPadding.
add(
padding);
}
} else {
newLeadingPadding.
clear();
newLeadingPadding.
add(
padding);
}
} else {
counter =
indexOfNextNonZeroSpring(
counter + 1, true);
}
} else {
// Not a padding spring
if (
newLeading.
size() > 0 &&
insert) {
// There's leading ComponentSprings, create an
// autopadding spring.
AutoPreferredGapSpring padding =
new
AutoPreferredGapSpring();
// Force the newly created spring to be considered
// by NOT incrementing counter
springs.
add(
counter,
padding);
continue;
}
if (
spring instanceof
ComponentSpring) {
// Spring is a Component, make it the target of any
// leading AutopaddingSpring.
ComponentSpring cSpring = (
ComponentSpring)
spring;
if (!
cSpring.
isVisible()) {
counter++;
continue;
}
for (
AutoPreferredGapSpring gapSpring :
newLeadingPadding) {
gapSpring.
addTarget(
cSpring,
axis);
}
newLeading.
clear();
newLeadingPadding.
clear();
counter =
indexOfNextNonZeroSpring(
counter + 1, false);
if (
counter ==
springs.
size()) {
// Last Spring, add it to trailing
trailing.
add(
cSpring);
} else {
// Not that last Spring, add it to leading
newLeading.
add(
cSpring);
}
} else if (
spring instanceof
Group) {
// Forward call to child Group
if (
newTrailing == null) {
newTrailing = new
ArrayList<
ComponentSpring>(1);
} else {
newTrailing.
clear();
}
newTrailingPadding.
clear();
((
Group)
spring).
insertAutopadding(
axis,
newLeadingPadding,
newTrailingPadding,
newLeading,
newTrailing,
insert);
newLeading.
clear();
newLeadingPadding.
clear();
counter =
indexOfNextNonZeroSpring(
counter + 1, (
newTrailing.
size() == 0));
if (
counter ==
springs.
size()) {
trailing.
addAll(
newTrailing);
trailingPadding.
addAll(
newTrailingPadding);
} else {
newLeading.
addAll(
newTrailing);
newLeadingPadding.
addAll(
newTrailingPadding);
}
} else {
// Gap
newLeadingPadding.
clear();
newLeading.
clear();
counter++;
}
}
}
}
int
getBaseline() {
if (
baselineSpring != null) {
int
baseline =
baselineSpring.
getBaseline();
if (
baseline >= 0) {
int
size = 0;
for (
Spring spring :
springs) {
if (
spring ==
baselineSpring) {
return
size +
baseline;
} else {
size +=
spring.
getPreferredSize(
VERTICAL);
}
}
}
}
return -1;
}
BaselineResizeBehavior getBaselineResizeBehavior() {
if (
isResizable(
VERTICAL)) {
if (!
baselineSpring.
isResizable(
VERTICAL)) {
// Spring to use for baseline isn't resizable. In this case
// baseline resize behavior can be determined based on how
// preceding springs resize.
boolean
leadingResizable = false;
for (
Spring spring :
springs) {
if (
spring ==
baselineSpring) {
break;
} else if (
spring.
isResizable(
VERTICAL)) {
leadingResizable = true;
break;
}
}
boolean
trailingResizable = false;
for (int
i =
springs.
size() - 1;
i >= 0;
i--) {
Spring spring =
springs.
get(
i);
if (
spring ==
baselineSpring) {
break;
}
if (
spring.
isResizable(
VERTICAL)) {
trailingResizable = true;
break;
}
}
if (
leadingResizable && !
trailingResizable) {
return
BaselineResizeBehavior.
CONSTANT_DESCENT;
} else if (!
leadingResizable &&
trailingResizable) {
return
BaselineResizeBehavior.
CONSTANT_ASCENT;
}
// If we get here, both leading and trailing springs are
// resizable. Fall through to OTHER.
} else {
BaselineResizeBehavior brb =
baselineSpring.
getBaselineResizeBehavior();
if (
brb ==
BaselineResizeBehavior.
CONSTANT_ASCENT) {
for (
Spring spring :
springs) {
if (
spring ==
baselineSpring) {
return
BaselineResizeBehavior.
CONSTANT_ASCENT;
}
if (
spring.
isResizable(
VERTICAL)) {
return
BaselineResizeBehavior.
OTHER;
}
}
} else if (
brb ==
BaselineResizeBehavior.
CONSTANT_DESCENT) {
for (int
i =
springs.
size() - 1;
i >= 0;
i--) {
Spring spring =
springs.
get(
i);
if (
spring ==
baselineSpring) {
return
BaselineResizeBehavior.
CONSTANT_DESCENT;
}
if (
spring.
isResizable(
VERTICAL)) {
return
BaselineResizeBehavior.
OTHER;
}
}
}
}
return
BaselineResizeBehavior.
OTHER;
}
// Not resizable, treat as constant_ascent
return
BaselineResizeBehavior.
CONSTANT_ASCENT;
}
private void
checkPreferredGapValues(int
pref, int
max) {
if ((
pref < 0 &&
pref !=
DEFAULT_SIZE &&
pref !=
PREFERRED_SIZE) ||
(
max < 0 &&
max !=
DEFAULT_SIZE &&
max !=
PREFERRED_SIZE)||
(
pref >= 0 &&
max >= 0 &&
pref >
max)) {
throw new
IllegalArgumentException(
"Pref and max must be either DEFAULT_SIZE, " +
"PREFERRED_SIZE, or >= 0 and pref <= max");
}
}
}
/**
* Used by SequentialGroup in calculating resizability of springs.
*/
private static final class
SpringDelta implements
Comparable<
SpringDelta> {
// Original index.
public final int
index;
// Delta, one of pref - min or max - pref.
public int
delta;
public
SpringDelta(int
index, int
delta) {
this.
index =
index;
this.
delta =
delta;
}
public int
compareTo(
SpringDelta o) {
return
delta -
o.
delta;
}
public
String toString() {
return super.toString() + "[index=" +
index + ", delta=" +
delta + "]";
}
}
/**
* A {@code Group} that aligns and sizes it's children.
* {@code ParallelGroup} aligns it's children in
* four possible ways: along the baseline, centered, anchored to the
* leading edge, or anchored to the trailing edge.
* <h3>Baseline</h3>
* A {@code ParallelGroup} that aligns it's children along the
* baseline must first decide where the baseline is
* anchored. The baseline can either be anchored to the top, or
* anchored to the bottom of the group. That is, the distance between the
* baseline and the beginning of the group can be a constant
* distance, or the distance between the end of the group and the
* baseline can be a constant distance. The possible choices
* correspond to the {@code BaselineResizeBehavior} constants
* {@link
* java.awt.Component.BaselineResizeBehavior#CONSTANT_ASCENT CONSTANT_ASCENT} and
* {@link
* java.awt.Component.BaselineResizeBehavior#CONSTANT_DESCENT CONSTANT_DESCENT}.
* <p>
* The baseline anchor may be explicitly specified by the
* {@code createBaselineGroup} method, or determined based on the elements.
* If not explicitly specified, the baseline will be anchored to
* the bottom if all the elements with a baseline, and that are
* aligned to the baseline, have a baseline resize behavior of
* {@code CONSTANT_DESCENT}; otherwise the baseline is anchored to the top
* of the group.
* <p>
* Elements aligned to the baseline are resizable if they have have
* a baseline resize behavior of {@code CONSTANT_ASCENT} or
* {@code CONSTANT_DESCENT}. Elements with a baseline resize
* behavior of {@code OTHER} or {@code CENTER_OFFSET} are not resizable.
* <p>
* The baseline is calculated based on the preferred height of each
* of the elements that have a baseline. The baseline is
* calculated using the following algorithm:
* {@code max(maxNonBaselineHeight, maxAscent + maxDescent)}, where the
* {@code maxNonBaselineHeight} is the maximum height of all elements
* that do not have a baseline, or are not aligned along the baseline.
* {@code maxAscent} is the maximum ascent (baseline) of all elements that
* have a baseline and are aligned along the baseline.
* {@code maxDescent} is the maximum descent (preferred height - baseline)
* of all elements that have a baseline and are aligned along the baseline.
* <p>
* A {@code ParallelGroup} that aligns it's elements along the baseline
* is only useful along the vertical axis. If you create a
* baseline group and use it along the horizontal axis an
* {@code IllegalStateException} is thrown when you ask
* {@code GroupLayout} for the minimum, preferred or maximum size or
* attempt to layout the components.
* <p>
* Elements that are not aligned to the baseline and smaller than the size
* of the {@code ParallelGroup} are positioned in one of three
* ways: centered, anchored to the leading edge, or anchored to the
* trailing edge.
*
* <h3>Non-baseline {@code ParallelGroup}</h3>
* {@code ParallelGroup}s created with an alignment other than
* {@code BASELINE} align elements that are smaller than the size
* of the group in one of three ways: centered, anchored to the
* leading edge, or anchored to the trailing edge.
* <p>
* The leading edge is based on the axis and {@code
* ComponentOrientation}. For the vertical axis the top edge is
* always the leading edge, and the bottom edge is always the
* trailing edge. When the {@code ComponentOrientation} is {@code
* LEFT_TO_RIGHT}, the leading edge is the left edge and the
* trailing edge the right edge. A {@code ComponentOrientation} of
* {@code RIGHT_TO_LEFT} flips the left and right edges. Child
* elements are aligned based on the specified alignment the
* element was added with. If you do not specify an alignment, the
* alignment specified for the {@code ParallelGroup} is used.
* <p>
* To align elements along the baseline you {@code createBaselineGroup},
* or {@code createParallelGroup} with an alignment of {@code BASELINE}.
* If the group was not created with a baseline alignment, and you attempt
* to add an element specifying a baseline alignment, an
* {@code IllegalArgumentException} is thrown.
*
* @see #createParallelGroup()
* @see #createBaselineGroup(boolean,boolean)
* @since 1.6
*/
public class
ParallelGroup extends
Group {
// How children are layed out.
private final
Alignment childAlignment;
// Whether or not we're resizable.
private final boolean
resizable;
ParallelGroup(
Alignment childAlignment, boolean
resizable) {
this.
childAlignment =
childAlignment;
this.
resizable =
resizable;
}
/**
* {@inheritDoc}
*/
public
ParallelGroup addGroup(
Group group) {
return (
ParallelGroup)super.addGroup(
group);
}
/**
* {@inheritDoc}
*/
public
ParallelGroup addComponent(
Component component) {
return (
ParallelGroup)super.addComponent(
component);
}
/**
* {@inheritDoc}
*/
public
ParallelGroup addComponent(
Component component, int
min, int
pref,
int
max) {
return (
ParallelGroup)super.addComponent(
component,
min,
pref,
max);
}
/**
* {@inheritDoc}
*/
public
ParallelGroup addGap(int
pref) {
return (
ParallelGroup)super.addGap(
pref);
}
/**
* {@inheritDoc}
*/
public
ParallelGroup addGap(int
min, int
pref, int
max) {
return (
ParallelGroup)super.addGap(
min,
pref,
max);
}
/**
* Adds a {@code Group} to this {@code ParallelGroup} with the
* specified alignment. If the child is smaller than the
* {@code Group} it is aligned based on the specified
* alignment.
*
* @param alignment the alignment
* @param group the {@code Group} to add
* @return this {@code ParallelGroup}
* @throws IllegalArgumentException if {@code alignment} is
* {@code null}
*/
public
ParallelGroup addGroup(
Alignment alignment,
Group group) {
checkChildAlignment(
alignment);
group.
setAlignment(
alignment);
return (
ParallelGroup)
addSpring(
group);
}
/**
* Adds a {@code Component} to this {@code ParallelGroup} with
* the specified alignment.
*
* @param alignment the alignment
* @param component the {@code Component} to add
* @return this {@code Group}
* @throws IllegalArgumentException if {@code alignment} is
* {@code null}
*/
public
ParallelGroup addComponent(
Component component,
Alignment alignment) {
return
addComponent(
component,
alignment,
DEFAULT_SIZE,
DEFAULT_SIZE,
DEFAULT_SIZE);
}
/**
* Adds a {@code Component} to this {@code ParallelGroup} with the
* specified alignment and size.
*
* @param alignment the alignment
* @param component the {@code Component} to add
* @param min the minimum size
* @param pref the preferred size
* @param max the maximum size
* @throws IllegalArgumentException if {@code alignment} is
* {@code null}
* @return this {@code Group}
*/
public
ParallelGroup addComponent(
Component component,
Alignment alignment, int
min, int
pref, int
max) {
checkChildAlignment(
alignment);
ComponentSpring spring = new
ComponentSpring(
component,
min,
pref,
max);
spring.
setAlignment(
alignment);
return (
ParallelGroup)
addSpring(
spring);
}
boolean
isResizable() {
return
resizable;
}
int
operator(int
a, int
b) {
return
Math.
max(
a,
b);
}
int
calculateMinimumSize(int
axis) {
if (!
isResizable()) {
return
getPreferredSize(
axis);
}
return super.calculateMinimumSize(
axis);
}
int
calculateMaximumSize(int
axis) {
if (!
isResizable()) {
return
getPreferredSize(
axis);
}
return super.calculateMaximumSize(
axis);
}
void
setValidSize(int
axis, int
origin, int
size) {
for (
Spring spring :
springs) {
setChildSize(
spring,
axis,
origin,
size);
}
}
void
setChildSize(
Spring spring, int
axis, int
origin, int
size) {
Alignment alignment =
spring.
getAlignment();
int
springSize =
Math.
min(
Math.
max(
spring.
getMinimumSize(
axis),
size),
spring.
getMaximumSize(
axis));
if (
alignment == null) {
alignment =
childAlignment;
}
switch (
alignment) {
case
TRAILING:
spring.
setSize(
axis,
origin +
size -
springSize,
springSize);
break;
case
CENTER:
spring.
setSize(
axis,
origin +
(
size -
springSize) / 2,
springSize);
break;
default: // LEADING, or BASELINE
spring.
setSize(
axis,
origin,
springSize);
break;
}
}
@
Override
void
insertAutopadding(int
axis,
List<
AutoPreferredGapSpring>
leadingPadding,
List<
AutoPreferredGapSpring>
trailingPadding,
List<
ComponentSpring>
leading,
List<
ComponentSpring>
trailing,
boolean
insert) {
for (
Spring spring :
springs) {
if (
spring instanceof
ComponentSpring) {
if (((
ComponentSpring)
spring).
isVisible()) {
for (
AutoPreferredGapSpring gapSpring :
leadingPadding) {
gapSpring.
addTarget((
ComponentSpring)
spring,
axis);
}
trailing.
add((
ComponentSpring)
spring);
}
} else if (
spring instanceof
Group) {
((
Group)
spring).
insertAutopadding(
axis,
leadingPadding,
trailingPadding,
leading,
trailing,
insert);
} else if (
spring instanceof
AutoPreferredGapSpring) {
((
AutoPreferredGapSpring)
spring).
setSources(
leading);
trailingPadding.
add((
AutoPreferredGapSpring)
spring);
}
}
}
private void
checkChildAlignment(
Alignment alignment) {
checkChildAlignment(
alignment, (this instanceof
BaselineGroup));
}
private void
checkChildAlignment(
Alignment alignment,
boolean
allowsBaseline) {
if (
alignment == null) {
throw new
IllegalArgumentException("Alignment must be non-null");
}
if (!
allowsBaseline &&
alignment ==
Alignment.
BASELINE) {
throw new
IllegalArgumentException("Alignment must be one of:" +
"LEADING, TRAILING or CENTER");
}
}
}
/**
* An extension of {@code ParallelGroup} that aligns its
* constituent {@code Spring}s along the baseline.
*/
private class
BaselineGroup extends
ParallelGroup {
// Whether or not all child springs have a baseline
private boolean
allSpringsHaveBaseline;
// max(spring.getBaseline()) of all springs aligned along the baseline
// that have a baseline
private int
prefAscent;
// max(spring.getPreferredSize().height - spring.getBaseline()) of all
// springs aligned along the baseline that have a baseline
private int
prefDescent;
// Whether baselineAnchoredToTop was explicitly set
private boolean
baselineAnchorSet;
// Whether the baseline is anchored to the top or the bottom.
// If anchored to the top the baseline is always at prefAscent,
// otherwise the baseline is at (height - prefDescent)
private boolean
baselineAnchoredToTop;
// Whether or not the baseline has been calculated.
private boolean
calcedBaseline;
BaselineGroup(boolean
resizable) {
super(
Alignment.
LEADING,
resizable);
prefAscent =
prefDescent = -1;
calcedBaseline = false;
}
BaselineGroup(boolean
resizable, boolean
baselineAnchoredToTop) {
this(
resizable);
this.
baselineAnchoredToTop =
baselineAnchoredToTop;
baselineAnchorSet = true;
}
void
unset() {
super.unset();
prefAscent =
prefDescent = -1;
calcedBaseline = false;
}
void
setValidSize(int
axis, int
origin, int
size) {
checkAxis(
axis);
if (
prefAscent == -1) {
super.setValidSize(
axis,
origin,
size);
} else {
// do baseline layout
baselineLayout(
origin,
size);
}
}
int
calculateSize(int
axis, int
type) {
checkAxis(
axis);
if (!
calcedBaseline) {
calculateBaselineAndResizeBehavior();
}
if (
type ==
MIN_SIZE) {
return
calculateMinSize();
}
if (
type ==
MAX_SIZE) {
return
calculateMaxSize();
}
if (
allSpringsHaveBaseline) {
return
prefAscent +
prefDescent;
}
return
Math.
max(
prefAscent +
prefDescent,
super.calculateSize(
axis,
type));
}
private void
calculateBaselineAndResizeBehavior() {
// calculate baseline
prefAscent = 0;
prefDescent = 0;
int
baselineSpringCount = 0;
BaselineResizeBehavior resizeBehavior = null;
for (
Spring spring :
springs) {
if (
spring.
getAlignment() == null ||
spring.
getAlignment() ==
Alignment.
BASELINE) {
int
baseline =
spring.
getBaseline();
if (
baseline >= 0) {
if (
spring.
isResizable(
VERTICAL)) {
BaselineResizeBehavior brb =
spring.
getBaselineResizeBehavior();
if (
resizeBehavior == null) {
resizeBehavior =
brb;
} else if (
brb !=
resizeBehavior) {
resizeBehavior =
BaselineResizeBehavior.
CONSTANT_ASCENT;
}
}
prefAscent =
Math.
max(
prefAscent,
baseline);
prefDescent =
Math.
max(
prefDescent,
spring.
getPreferredSize(
VERTICAL) -
baseline);
baselineSpringCount++;
}
}
}
if (!
baselineAnchorSet) {
if (
resizeBehavior ==
BaselineResizeBehavior.
CONSTANT_DESCENT){
this.
baselineAnchoredToTop = false;
} else {
this.
baselineAnchoredToTop = true;
}
}
allSpringsHaveBaseline = (
baselineSpringCount ==
springs.
size());
calcedBaseline = true;
}
private int
calculateMaxSize() {
int
maxAscent =
prefAscent;
int
maxDescent =
prefDescent;
int
nonBaselineMax = 0;
for (
Spring spring :
springs) {
int
baseline;
int
springMax =
spring.
getMaximumSize(
VERTICAL);
if ((
spring.
getAlignment() == null ||
spring.
getAlignment() ==
Alignment.
BASELINE) &&
(
baseline =
spring.
getBaseline()) >= 0) {
int
springPref =
spring.
getPreferredSize(
VERTICAL);
if (
springPref !=
springMax) {
switch (
spring.
getBaselineResizeBehavior()) {
case
CONSTANT_ASCENT:
if (
baselineAnchoredToTop) {
maxDescent =
Math.
max(
maxDescent,
springMax -
baseline);
}
break;
case
CONSTANT_DESCENT:
if (!
baselineAnchoredToTop) {
maxAscent =
Math.
max(
maxAscent,
springMax -
springPref +
baseline);
}
break;
default: // CENTER_OFFSET and OTHER, not resizable
break;
}
}
} else {
// Not aligned along the baseline, or no baseline.
nonBaselineMax =
Math.
max(
nonBaselineMax,
springMax);
}
}
return
Math.
max(
nonBaselineMax,
maxAscent +
maxDescent);
}
private int
calculateMinSize() {
int
minAscent = 0;
int
minDescent = 0;
int
nonBaselineMin = 0;
if (
baselineAnchoredToTop) {
minAscent =
prefAscent;
} else {
minDescent =
prefDescent;
}
for (
Spring spring :
springs) {
int
springMin =
spring.
getMinimumSize(
VERTICAL);
int
baseline;
if ((
spring.
getAlignment() == null ||
spring.
getAlignment() ==
Alignment.
BASELINE) &&
(
baseline =
spring.
getBaseline()) >= 0) {
int
springPref =
spring.
getPreferredSize(
VERTICAL);
BaselineResizeBehavior brb =
spring.
getBaselineResizeBehavior();
switch (
brb) {
case
CONSTANT_ASCENT:
if (
baselineAnchoredToTop) {
minDescent =
Math.
max(
springMin -
baseline,
minDescent);
} else {
minAscent =
Math.
max(
baseline,
minAscent);
}
break;
case
CONSTANT_DESCENT:
if (!
baselineAnchoredToTop) {
minAscent =
Math.
max(
baseline - (
springPref -
springMin),
minAscent);
} else {
minDescent =
Math.
max(
springPref -
baseline,
minDescent);
}
break;
default:
// CENTER_OFFSET and OTHER are !resizable, use
// the preferred size.
minAscent =
Math.
max(
baseline,
minAscent);
minDescent =
Math.
max(
springPref -
baseline,
minDescent);
break;
}
} else {
// Not aligned along the baseline, or no baseline.
nonBaselineMin =
Math.
max(
nonBaselineMin,
springMin);
}
}
return
Math.
max(
nonBaselineMin,
minAscent +
minDescent);
}
/**
* Lays out springs that have a baseline along the baseline. All
* others are centered.
*/
private void
baselineLayout(int
origin, int
size) {
int
ascent;
int
descent;
if (
baselineAnchoredToTop) {
ascent =
prefAscent;
descent =
size -
ascent;
} else {
ascent =
size -
prefDescent;
descent =
prefDescent;
}
for (
Spring spring :
springs) {
Alignment alignment =
spring.
getAlignment();
if (
alignment == null ||
alignment ==
Alignment.
BASELINE) {
int
baseline =
spring.
getBaseline();
if (
baseline >= 0) {
int
springMax =
spring.
getMaximumSize(
VERTICAL);
int
springPref =
spring.
getPreferredSize(
VERTICAL);
int
height =
springPref;
int
y;
switch(
spring.
getBaselineResizeBehavior()) {
case
CONSTANT_ASCENT:
y =
origin +
ascent -
baseline;
height =
Math.
min(
descent,
springMax -
baseline) +
baseline;
break;
case
CONSTANT_DESCENT:
height =
Math.
min(
ascent,
springMax -
springPref +
baseline) +
(
springPref -
baseline);
y =
origin +
ascent +
(
springPref -
baseline) -
height;
break;
default: // CENTER_OFFSET & OTHER, not resizable
y =
origin +
ascent -
baseline;
break;
}
spring.
setSize(
VERTICAL,
y,
height);
} else {
setChildSize(
spring,
VERTICAL,
origin,
size);
}
} else {
setChildSize(
spring,
VERTICAL,
origin,
size);
}
}
}
int
getBaseline() {
if (
springs.
size() > 1) {
// Force the baseline to be calculated
getPreferredSize(
VERTICAL);
return
prefAscent;
} else if (
springs.
size() == 1) {
return
springs.
get(0).
getBaseline();
}
return -1;
}
BaselineResizeBehavior getBaselineResizeBehavior() {
if (
springs.
size() == 1) {
return
springs.
get(0).
getBaselineResizeBehavior();
}
if (
baselineAnchoredToTop) {
return
BaselineResizeBehavior.
CONSTANT_ASCENT;
}
return
BaselineResizeBehavior.
CONSTANT_DESCENT;
}
// If the axis is VERTICAL, throws an IllegalStateException
private void
checkAxis(int
axis) {
if (
axis ==
HORIZONTAL) {
throw new
IllegalStateException(
"Baseline must be used along vertical axis");
}
}
}
private final class
ComponentSpring extends
Spring {
private
Component component;
private int
origin;
// min/pref/max are either a value >= 0 or one of
// DEFAULT_SIZE or PREFERRED_SIZE
private final int
min;
private final int
pref;
private final int
max;
// Baseline for the component, computed as necessary.
private int
baseline = -1;
// Whether or not the size has been requested yet.
private boolean
installed;
private
ComponentSpring(
Component component, int
min, int
pref,
int
max) {
this.
component =
component;
if (
component == null) {
throw new
IllegalArgumentException(
"Component must be non-null");
}
checkSize(
min,
pref,
max, true);
this.
min =
min;
this.
max =
max;
this.
pref =
pref;
// getComponentInfo makes sure component is a child of the
// Container GroupLayout is the LayoutManager for.
getComponentInfo(
component);
}
int
calculateMinimumSize(int
axis) {
if (
isLinked(
axis)) {
return
getLinkSize(
axis,
MIN_SIZE);
}
return
calculateNonlinkedMinimumSize(
axis);
}
int
calculatePreferredSize(int
axis) {
if (
isLinked(
axis)) {
return
getLinkSize(
axis,
PREF_SIZE);
}
int
min =
getMinimumSize(
axis);
int
pref =
calculateNonlinkedPreferredSize(
axis);
int
max =
getMaximumSize(
axis);
return
Math.
min(
max,
Math.
max(
min,
pref));
}
int
calculateMaximumSize(int
axis) {
if (
isLinked(
axis)) {
return
getLinkSize(
axis,
MAX_SIZE);
}
return
Math.
max(
getMinimumSize(
axis),
calculateNonlinkedMaximumSize(
axis));
}
boolean
isVisible() {
return
getComponentInfo(
getComponent()).
isVisible();
}
int
calculateNonlinkedMinimumSize(int
axis) {
if (!
isVisible()) {
return 0;
}
if (
min >= 0) {
return
min;
}
if (
min ==
PREFERRED_SIZE) {
return
calculateNonlinkedPreferredSize(
axis);
}
assert (
min ==
DEFAULT_SIZE);
return
getSizeAlongAxis(
axis,
component.
getMinimumSize());
}
int
calculateNonlinkedPreferredSize(int
axis) {
if (!
isVisible()) {
return 0;
}
if (
pref >= 0) {
return
pref;
}
assert (
pref ==
DEFAULT_SIZE ||
pref ==
PREFERRED_SIZE);
return
getSizeAlongAxis(
axis,
component.
getPreferredSize());
}
int
calculateNonlinkedMaximumSize(int
axis) {
if (!
isVisible()) {
return 0;
}
if (
max >= 0) {
return
max;
}
if (
max ==
PREFERRED_SIZE) {
return
calculateNonlinkedPreferredSize(
axis);
}
assert (
max ==
DEFAULT_SIZE);
return
getSizeAlongAxis(
axis,
component.
getMaximumSize());
}
private int
getSizeAlongAxis(int
axis,
Dimension size) {
return (
axis ==
HORIZONTAL) ?
size.
width :
size.
height;
}
private int
getLinkSize(int
axis, int
type) {
if (!
isVisible()) {
return 0;
}
ComponentInfo ci =
getComponentInfo(
component);
return
ci.
getLinkSize(
axis,
type);
}
void
setSize(int
axis, int
origin, int
size) {
super.setSize(
axis,
origin,
size);
this.
origin =
origin;
if (
size ==
UNSET) {
baseline = -1;
}
}
int
getOrigin() {
return
origin;
}
void
setComponent(
Component component) {
this.
component =
component;
}
Component getComponent() {
return
component;
}
int
getBaseline() {
if (
baseline == -1) {
Spring horizontalSpring =
getComponentInfo(
component).
horizontalSpring;
int
width =
horizontalSpring.
getPreferredSize(
HORIZONTAL);
int
height =
getPreferredSize(
VERTICAL);
if (
width > 0 &&
height > 0) {
baseline =
component.
getBaseline(
width,
height);
}
}
return
baseline;
}
BaselineResizeBehavior getBaselineResizeBehavior() {
return
getComponent().
getBaselineResizeBehavior();
}
private boolean
isLinked(int
axis) {
return
getComponentInfo(
component).
isLinked(
axis);
}
void
installIfNecessary(int
axis) {
if (!
installed) {
installed = true;
if (
axis ==
HORIZONTAL) {
getComponentInfo(
component).
horizontalSpring = this;
} else {
getComponentInfo(
component).
verticalSpring = this;
}
}
}
@
Override
boolean
willHaveZeroSize(boolean
treatAutopaddingAsZeroSized) {
return !
isVisible();
}
}
/**
* Spring representing the preferred distance between two components.
*/
private class
PreferredGapSpring extends
Spring {
private final
JComponent source;
private final
JComponent target;
private final
ComponentPlacement type;
private final int
pref;
private final int
max;
PreferredGapSpring(
JComponent source,
JComponent target,
ComponentPlacement type, int
pref, int
max) {
this.
source =
source;
this.
target =
target;
this.
type =
type;
this.
pref =
pref;
this.
max =
max;
}
int
calculateMinimumSize(int
axis) {
return
getPadding(
axis);
}
int
calculatePreferredSize(int
axis) {
if (
pref ==
DEFAULT_SIZE ||
pref ==
PREFERRED_SIZE) {
return
getMinimumSize(
axis);
}
int
min =
getMinimumSize(
axis);
int
max =
getMaximumSize(
axis);
return
Math.
min(
max,
Math.
max(
min,
pref));
}
int
calculateMaximumSize(int
axis) {
if (
max ==
PREFERRED_SIZE ||
max ==
DEFAULT_SIZE) {
return
getPadding(
axis);
}
return
Math.
max(
getMinimumSize(
axis),
max);
}
private int
getPadding(int
axis) {
int
position;
if (
axis ==
HORIZONTAL) {
position =
SwingConstants.
EAST;
} else {
position =
SwingConstants.
SOUTH;
}
return
getLayoutStyle0().
getPreferredGap(
source,
target,
type,
position,
host);
}
@
Override
boolean
willHaveZeroSize(boolean
treatAutopaddingAsZeroSized) {
return false;
}
}
/**
* Spring represented a certain amount of space.
*/
private class
GapSpring extends
Spring {
private final int
min;
private final int
pref;
private final int
max;
GapSpring(int
min, int
pref, int
max) {
checkSize(
min,
pref,
max, false);
this.
min =
min;
this.
pref =
pref;
this.
max =
max;
}
int
calculateMinimumSize(int
axis) {
if (
min ==
PREFERRED_SIZE) {
return
getPreferredSize(
axis);
}
return
min;
}
int
calculatePreferredSize(int
axis) {
return
pref;
}
int
calculateMaximumSize(int
axis) {
if (
max ==
PREFERRED_SIZE) {
return
getPreferredSize(
axis);
}
return
max;
}
@
Override
boolean
willHaveZeroSize(boolean
treatAutopaddingAsZeroSized) {
return false;
}
}
/**
* Spring reprensenting the distance between any number of sources and
* targets. The targets and sources are computed during layout. An
* instance of this can either be dynamically created when
* autocreatePadding is true, or explicitly created by the developer.
*/
private class
AutoPreferredGapSpring extends
Spring {
List<
ComponentSpring>
sources;
ComponentSpring source;
private
List<
AutoPreferredGapMatch>
matches;
int
size;
int
lastSize;
private final int
pref;
private final int
max;
// Type of gap
private
ComponentPlacement type;
private boolean
userCreated;
private
AutoPreferredGapSpring() {
this.
pref =
PREFERRED_SIZE;
this.
max =
PREFERRED_SIZE;
this.
type =
ComponentPlacement.
RELATED;
}
AutoPreferredGapSpring(int
pref, int
max) {
this.
pref =
pref;
this.
max =
max;
}
AutoPreferredGapSpring(
ComponentPlacement type, int
pref, int
max) {
this.
type =
type;
this.
pref =
pref;
this.
max =
max;
this.
userCreated = true;
}
public void
setSource(
ComponentSpring source) {
this.
source =
source;
}
public void
setSources(
List<
ComponentSpring>
sources) {
this.
sources = new
ArrayList<
ComponentSpring>(
sources);
}
public void
setUserCreated(boolean
userCreated) {
this.
userCreated =
userCreated;
}
public boolean
getUserCreated() {
return
userCreated;
}
void
unset() {
lastSize =
getSize();
super.unset();
size = 0;
}
public void
reset() {
size = 0;
sources = null;
source = null;
matches = null;
}
public void
calculatePadding(int
axis) {
size =
UNSET;
int
maxPadding =
UNSET;
if (
matches != null) {
LayoutStyle p =
getLayoutStyle0();
int
position;
if (
axis ==
HORIZONTAL) {
if (
isLeftToRight()) {
position =
SwingConstants.
EAST;
} else {
position =
SwingConstants.
WEST;
}
} else {
position =
SwingConstants.
SOUTH;
}
for (int
i =
matches.
size() - 1;
i >= 0;
i--) {
AutoPreferredGapMatch match =
matches.
get(
i);
maxPadding =
Math.
max(
maxPadding,
calculatePadding(
p,
position,
match.
source,
match.
target));
}
}
if (
size ==
UNSET) {
size = 0;
}
if (
maxPadding ==
UNSET) {
maxPadding = 0;
}
if (
lastSize !=
UNSET) {
size +=
Math.
min(
maxPadding,
lastSize);
}
}
private int
calculatePadding(
LayoutStyle p, int
position,
ComponentSpring source,
ComponentSpring target) {
int
delta =
target.
getOrigin() - (
source.
getOrigin() +
source.
getSize());
if (
delta >= 0) {
int
padding;
if ((
source.
getComponent() instanceof
JComponent) &&
(
target.
getComponent() instanceof
JComponent)) {
padding =
p.
getPreferredGap(
(
JComponent)
source.
getComponent(),
(
JComponent)
target.
getComponent(),
type,
position,
host);
} else {
padding = 10;
}
if (
padding >
delta) {
size =
Math.
max(
size,
padding -
delta);
}
return
padding;
}
return 0;
}
public void
addTarget(
ComponentSpring spring, int
axis) {
int
oAxis = (
axis ==
HORIZONTAL) ?
VERTICAL :
HORIZONTAL;
if (
source != null) {
if (
areParallelSiblings(
source.
getComponent(),
spring.
getComponent(),
oAxis)) {
addValidTarget(
source,
spring);
}
} else {
Component component =
spring.
getComponent();
for (int
counter =
sources.
size() - 1;
counter >= 0;
counter--){
ComponentSpring source =
sources.
get(
counter);
if (
areParallelSiblings(
source.
getComponent(),
component,
oAxis)) {
addValidTarget(
source,
spring);
}
}
}
}
private void
addValidTarget(
ComponentSpring source,
ComponentSpring target) {
if (
matches == null) {
matches = new
ArrayList<
AutoPreferredGapMatch>(1);
}
matches.
add(new
AutoPreferredGapMatch(
source,
target));
}
int
calculateMinimumSize(int
axis) {
return
size;
}
int
calculatePreferredSize(int
axis) {
if (
pref ==
PREFERRED_SIZE ||
pref ==
DEFAULT_SIZE) {
return
size;
}
return
Math.
max(
size,
pref);
}
int
calculateMaximumSize(int
axis) {
if (
max >= 0) {
return
Math.
max(
getPreferredSize(
axis),
max);
}
return
size;
}
String getMatchDescription() {
return (
matches == null) ? "" :
matches.
toString();
}
public
String toString() {
return super.toString() +
getMatchDescription();
}
@
Override
boolean
willHaveZeroSize(boolean
treatAutopaddingAsZeroSized) {
return
treatAutopaddingAsZeroSized;
}
}
/**
* Represents two springs that should have autopadding inserted between
* them.
*/
private final static class
AutoPreferredGapMatch {
public final
ComponentSpring source;
public final
ComponentSpring target;
AutoPreferredGapMatch(
ComponentSpring source,
ComponentSpring target) {
this.
source =
source;
this.
target =
target;
}
private
String toString(
ComponentSpring spring) {
return
spring.
getComponent().
getName();
}
public
String toString() {
return "[" +
toString(
source) + "-" +
toString(
target) + "]";
}
}
/**
* An extension of AutopaddingSpring used for container level padding.
*/
private class
ContainerAutoPreferredGapSpring extends
AutoPreferredGapSpring {
private
List<
ComponentSpring>
targets;
ContainerAutoPreferredGapSpring() {
super();
setUserCreated(true);
}
ContainerAutoPreferredGapSpring(int
pref, int
max) {
super(
pref,
max);
setUserCreated(true);
}
public void
addTarget(
ComponentSpring spring, int
axis) {
if (
targets == null) {
targets = new
ArrayList<
ComponentSpring>(1);
}
targets.
add(
spring);
}
public void
calculatePadding(int
axis) {
LayoutStyle p =
getLayoutStyle0();
int
maxPadding = 0;
int
position;
size = 0;
if (
targets != null) {
// Leading
if (
axis ==
HORIZONTAL) {
if (
isLeftToRight()) {
position =
SwingConstants.
WEST;
} else {
position =
SwingConstants.
EAST;
}
} else {
position =
SwingConstants.
SOUTH;
}
for (int
i =
targets.
size() - 1;
i >= 0;
i--) {
ComponentSpring targetSpring =
targets.
get(
i);
int
padding = 10;
if (
targetSpring.
getComponent() instanceof
JComponent) {
padding =
p.
getContainerGap(
(
JComponent)
targetSpring.
getComponent(),
position,
host);
maxPadding =
Math.
max(
padding,
maxPadding);
padding -=
targetSpring.
getOrigin();
} else {
maxPadding =
Math.
max(
padding,
maxPadding);
}
size =
Math.
max(
size,
padding);
}
} else {
// Trailing
if (
axis ==
HORIZONTAL) {
if (
isLeftToRight()) {
position =
SwingConstants.
EAST;
} else {
position =
SwingConstants.
WEST;
}
} else {
position =
SwingConstants.
SOUTH;
}
if (
sources != null) {
for (int
i =
sources.
size() - 1;
i >= 0;
i--) {
ComponentSpring sourceSpring =
sources.
get(
i);
maxPadding =
Math.
max(
maxPadding,
updateSize(
p,
sourceSpring,
position));
}
} else if (
source != null) {
maxPadding =
updateSize(
p,
source,
position);
}
}
if (
lastSize !=
UNSET) {
size +=
Math.
min(
maxPadding,
lastSize);
}
}
private int
updateSize(
LayoutStyle p,
ComponentSpring sourceSpring,
int
position) {
int
padding = 10;
if (
sourceSpring.
getComponent() instanceof
JComponent) {
padding =
p.
getContainerGap(
(
JComponent)
sourceSpring.
getComponent(),
position,
host);
}
int
delta =
Math.
max(0,
getParent().
getSize() -
sourceSpring.
getSize() -
sourceSpring.
getOrigin());
size =
Math.
max(
size,
padding -
delta);
return
padding;
}
String getMatchDescription() {
if (
targets != null) {
return "leading: " +
targets.
toString();
}
if (
sources != null) {
return "trailing: " +
sources.
toString();
}
return "--";
}
}
// LinkInfo contains the set of ComponentInfosthat are linked along a
// particular axis.
private static class
LinkInfo {
private final int
axis;
private final
List<
ComponentInfo>
linked;
private int
size;
LinkInfo(int
axis) {
linked = new
ArrayList<
ComponentInfo>();
size =
UNSET;
this.
axis =
axis;
}
public void
add(
ComponentInfo child) {
LinkInfo childMaster =
child.
getLinkInfo(
axis, false);
if (
childMaster == null) {
linked.
add(
child);
child.
setLinkInfo(
axis, this);
} else if (
childMaster != this) {
linked.
addAll(
childMaster.
linked);
for (
ComponentInfo childInfo :
childMaster.
linked) {
childInfo.
setLinkInfo(
axis, this);
}
}
clearCachedSize();
}
public void
remove(
ComponentInfo info) {
linked.
remove(
info);
info.
setLinkInfo(
axis, null);
if (
linked.
size() == 1) {
linked.
get(0).
setLinkInfo(
axis, null);
}
clearCachedSize();
}
public void
clearCachedSize() {
size =
UNSET;
}
public int
getSize(int
axis) {
if (
size ==
UNSET) {
size =
calculateLinkedSize(
axis);
}
return
size;
}
private int
calculateLinkedSize(int
axis) {
int
size = 0;
for (
ComponentInfo info :
linked) {
ComponentSpring spring;
if (
axis ==
HORIZONTAL) {
spring =
info.
horizontalSpring;
} else {
assert (
axis ==
VERTICAL);
spring =
info.
verticalSpring;
}
size =
Math.
max(
size,
spring.
calculateNonlinkedPreferredSize(
axis));
}
return
size;
}
}
/**
* Tracks the horizontal/vertical Springs for a Component.
* This class is also used to handle Springs that have their sizes
* linked.
*/
private class
ComponentInfo {
// Component being layed out
private
Component component;
ComponentSpring horizontalSpring;
ComponentSpring verticalSpring;
// If the component's size is linked to other components, the
// horizontalMaster and/or verticalMaster reference the group of
// linked components.
private
LinkInfo horizontalMaster;
private
LinkInfo verticalMaster;
private boolean
visible;
private
Boolean honorsVisibility;
ComponentInfo(
Component component) {
this.
component =
component;
updateVisibility();
}
public void
dispose() {
// Remove horizontal/vertical springs
removeSpring(
horizontalSpring);
horizontalSpring = null;
removeSpring(
verticalSpring);
verticalSpring = null;
// Clean up links
if (
horizontalMaster != null) {
horizontalMaster.
remove(this);
}
if (
verticalMaster != null) {
verticalMaster.
remove(this);
}
}
void
setHonorsVisibility(
Boolean honorsVisibility) {
this.
honorsVisibility =
honorsVisibility;
}
private void
removeSpring(
Spring spring) {
if (
spring != null) {
((
Group)
spring.
getParent()).
springs.
remove(
spring);
}
}
public boolean
isVisible() {
return
visible;
}
/**
* Updates the cached visibility.
*
* @return true if the visibility changed
*/
boolean
updateVisibility() {
boolean
honorsVisibility;
if (this.
honorsVisibility == null) {
honorsVisibility =
GroupLayout.this.
getHonorsVisibility();
} else {
honorsVisibility = this.
honorsVisibility;
}
boolean
newVisible = (
honorsVisibility) ?
component.
isVisible() : true;
if (
visible !=
newVisible) {
visible =
newVisible;
return true;
}
return false;
}
public void
setBounds(
Insets insets, int
parentWidth, boolean
ltr) {
int
x =
horizontalSpring.
getOrigin();
int
w =
horizontalSpring.
getSize();
int
y =
verticalSpring.
getOrigin();
int
h =
verticalSpring.
getSize();
if (!
ltr) {
x =
parentWidth -
x -
w;
}
component.
setBounds(
x +
insets.
left,
y +
insets.
top,
w,
h);
}
public void
setComponent(
Component component) {
this.
component =
component;
if (
horizontalSpring != null) {
horizontalSpring.
setComponent(
component);
}
if (
verticalSpring != null) {
verticalSpring.
setComponent(
component);
}
}
public
Component getComponent() {
return
component;
}
/**
* Returns true if this component has its size linked to
* other components.
*/
public boolean
isLinked(int
axis) {
if (
axis ==
HORIZONTAL) {
return
horizontalMaster != null;
}
assert (
axis ==
VERTICAL);
return (
verticalMaster != null);
}
private void
setLinkInfo(int
axis,
LinkInfo linkInfo) {
if (
axis ==
HORIZONTAL) {
horizontalMaster =
linkInfo;
} else {
assert (
axis ==
VERTICAL);
verticalMaster =
linkInfo;
}
}
public
LinkInfo getLinkInfo(int
axis) {
return
getLinkInfo(
axis, true);
}
private
LinkInfo getLinkInfo(int
axis, boolean
create) {
if (
axis ==
HORIZONTAL) {
if (
horizontalMaster == null &&
create) {
// horizontalMaster field is directly set by adding
// us to the LinkInfo.
new
LinkInfo(
HORIZONTAL).
add(this);
}
return
horizontalMaster;
} else {
assert (
axis ==
VERTICAL);
if (
verticalMaster == null &&
create) {
// verticalMaster field is directly set by adding
// us to the LinkInfo.
new
LinkInfo(
VERTICAL).
add(this);
}
return
verticalMaster;
}
}
public void
clearCachedSize() {
if (
horizontalMaster != null) {
horizontalMaster.
clearCachedSize();
}
if (
verticalMaster != null) {
verticalMaster.
clearCachedSize();
}
}
int
getLinkSize(int
axis, int
type) {
if (
axis ==
HORIZONTAL) {
return
horizontalMaster.
getSize(
axis);
} else {
assert (
axis ==
VERTICAL);
return
verticalMaster.
getSize(
axis);
}
}
}
}