Back to index...

	/*
	* Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	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);
	}
	}

	}
	}

Back to index...