GroupLayout.java

/*
 * Copyright (c) 2006, 2024, 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.
 */
packagejavax.swing;

importjava.awt.Component;
importjava.awt.Container;
importjava.awt.Dimension;
importjava.awt.Insets;
importjava.awt.LayoutManager2;
importjava.util.*;
importstaticjava.awt.Component.BaselineResizeBehavior;
importstaticjavax.swing.LayoutStyle.ComponentPlacement;
importstaticjavax.swing.SwingConstants.HORIZONTAL;
importstaticjavax.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
 */
publicclassGroupLayoutimplementsLayoutManager2 {
// Used in size calculations
privatestaticfinalintMIN_SIZE = 0;

privatestaticfinalintPREF_SIZE = 1;

privatestaticfinalintMAX_SIZE = 2;

// Used by prepare, indicates min, pref or max isn't going to be used.
privatestaticfinalintSPECIFIC_SIZE = 3;

privatestaticfinalintUNSET = Integer.MIN_VALUE;

// Maximum spring size constrain to avoid integer overflow
privatestaticfinalintINFINITE = Integer.MAX_VALUE >> 1;

/**
 * Indicates the size from the component or gap should be used for a
 * particular range value.
 *
 * @see Group
 */
publicstaticfinalintDEFAULT_SIZE = -1;

/**
 * Indicates the preferred size from the component or gap should
 * be used for a particular range value.
 *
 * @see Group
 */
publicstaticfinalintPREFERRED_SIZE = -2;

// Whether or not we automatically try and create the preferred
// padding between components.
privatebooleanautocreatePadding;

// Whether or not we automatically try and create the preferred
// padding between components the touch the edge of the container and
// the container.
privatebooleanautocreateContainerPadding;

/**
 * Group responsible for layout along the horizontal axis. This is NOT
 * the user specified group, use getHorizontalGroup to dig that out.
 */
privateGrouphorizontalGroup;

/**
 * Group responsible for layout along the vertical axis. This is NOT
 * the user specified group, use getVerticalGroup to dig that out.
 */
privateGroupverticalGroup;

// Maps from Component to ComponentInfo. This is used for tracking
// information specific to a Component.
privateMap<Component,ComponentInfo> componentInfos;

// Container we're doing layout for.
privateContainerhost;

// Used by areParallelSiblings, cached to avoid excessive garbage.
privateSet<Spring> tmpParallelSet;

// Indicates Springs have changed in some way since last change.
privatebooleanspringsChanged;

// Indicates invalidateLayout has been invoked.
privatebooleanisValid;

// Whether or not any preferred padding (or container padding) springs
// exist
privatebooleanhasPreferredPaddingSprings;

/**
 * The LayoutStyle instance to use, if null the sharedInstance is used.
 */
privateLayoutStylelayoutStyle;

/**
 * If true, components that are not visible are treated as though they
 * aren't there.
 */
privatebooleanhonorsVisibility;


/**
 * Enumeration of the possible ways {@code ParallelGroup} can align
 * its children.
 *
 * @see #createParallelGroup(Alignment)
 * @since 1.6
 */
publicenumAlignment {
/**
 * 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
 }


privatestaticvoidcheckSize(intmin, intpref, intmax,
booleanisComponentSpring) {
checkResizeType(min, isComponentSpring);
if (!isComponentSpring && pref < 0) {
thrownewIllegalArgumentException("Pref must be >= 0");
 } elseif (isComponentSpring) {
checkResizeType(pref, true);
 }
checkResizeType(max, isComponentSpring);
checkLessThan(min, pref);
checkLessThan(pref, max);
 }

privatestaticvoidcheckResizeType(inttype, booleanisComponentSpring) {
if (type < 0 && ((isComponentSpring && type != DEFAULT_SIZE &&
type != PREFERRED_SIZE) ||
 (!isComponentSpring && type != PREFERRED_SIZE))) {
thrownewIllegalArgumentException("Invalid size");
 }
 }

privatestaticvoidcheckLessThan(intmin, intmax) {
if (min >= 0 && max >= 0 && min > max) {
thrownewIllegalArgumentException(
"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}
 */
publicGroupLayout(Containerhost) {
if (host == null) {
thrownewIllegalArgumentException("Container must be non-null");
 }
honorsVisibility = true;
this.host = host;
setHorizontalGroup(createParallelGroup(Alignment.LEADING, true));
setVerticalGroup(createParallelGroup(Alignment.LEADING, true));
componentInfos = newHashMap<Component,ComponentInfo>();
tmpParallelSet = newHashSet<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)
 */
publicvoidsetHonorsVisibility(booleanhonorsVisibility) {
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
 */
publicbooleangetHonorsVisibility() {
returnhonorsVisibility;
 }

/**
 * 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 its 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)
 */
publicvoidsetHonorsVisibility(Componentcomponent,
BooleanhonorsVisibility) {
if (component == null) {
thrownewIllegalArgumentException("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
 */
publicvoidsetAutoCreateGaps(booleanautoCreatePadding) {
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
 */
publicbooleangetAutoCreateGaps() {
returnautocreatePadding;
 }

/**
 * 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
 */
publicvoidsetAutoCreateContainerGaps(booleanautoCreateContainerPadding){
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
 */
publicbooleangetAutoCreateContainerGaps() {
returnautocreateContainerPadding;
 }

/**
 * 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}
 */
publicvoidsetHorizontalGroup(Groupgroup) {
if (group == null) {
thrownewIllegalArgumentException("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
 */
privateGroupgetHorizontalGroup() {
intindex = 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}
 */
publicvoidsetVerticalGroup(Groupgroup) {
if (group == null) {
thrownewIllegalArgumentException("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
 */
privateGroupgetVerticalGroup() {
intindex = 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.
 */
privateGroupcreateTopLevelGroup(GroupspecifiedGroup) {
SequentialGroupgroup = createSequentialGroup();
if (getAutoCreateContainerGaps()) {
group.addSpring(newContainerAutoPreferredGapSpring());
group.addGroup(specifiedGroup);
group.addSpring(newContainerAutoPreferredGapSpring());
 } else {
group.addGroup(specifiedGroup);
 }
returngroup;
 }

/**
 * Creates and returns a {@code SequentialGroup}.
 *
 * @return a new {@code SequentialGroup}
 */
publicSequentialGroupcreateSequentialGroup() {
returnnewSequentialGroup();
 }

/**
 * 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)
 */
publicParallelGroupcreateParallelGroup() {
returncreateParallelGroup(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
 */
publicParallelGroupcreateParallelGroup(Alignmentalignment) {
returncreateParallelGroup(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
 */
publicParallelGroupcreateParallelGroup(Alignmentalignment,
booleanresizable){
if (alignment == null) {
thrownewIllegalArgumentException("alignment must be non null");
 }

if (alignment == Alignment.BASELINE) {
returnnewBaselineGroup(resizable);
 }
returnnewParallelGroup(alignment, resizable);
 }

/**
 * Creates and returns a {@code ParallelGroup} that aligns its
 * 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
 * @return the {@code ParallelGroup}
 * @see #createBaselineGroup
 * @see ParallelGroup
 */
publicParallelGroupcreateBaselineGroup(booleanresizable,
booleananchorBaselineToTop) {
returnnewBaselineGroup(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[])
 */
publicvoidlinkSize(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 axis the axis to link the size along; one of
 * {@code SwingConstants.HORIZONTAL} or
 * {@code SwingConstants.VERTICAL}
 * @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}; or {@code axis}
 * is not {@code SwingConstants.HORIZONTAL} or
 * {@code SwingConstants.VERTICAL}
 */
publicvoidlinkSize(intaxis, Component... components) {
if (components == null) {
thrownewIllegalArgumentException("Components must be non-null");
 }
for (intcounter = components.length - 1; counter >= 0; counter--) {
Componentc = components[counter];
if (components[counter] == null) {
thrownewIllegalArgumentException(
"Components must be non-null");
 }
// Force the component to be added
getComponentInfo(c);
 }
intglAxis;
if (axis == SwingConstants.HORIZONTAL) {
glAxis = HORIZONTAL;
 } elseif (axis == SwingConstants.VERTICAL) {
glAxis = VERTICAL;
 } else {
thrownewIllegalArgumentException("Axis must be one of " +
"SwingConstants.HORIZONTAL or SwingConstants.VERTICAL");
 }
LinkInfomaster = getComponentInfo(
components[components.length - 1]).getLinkInfo(glAxis);
for (intcounter = 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
 */
publicvoidreplace(ComponentexistingComponent, ComponentnewComponent) {
if (existingComponent == null || newComponent == null) {
thrownewIllegalArgumentException("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);
 }
ComponentInfoinfo = componentInfos.remove(existingComponent);
if (info == null) {
thrownewIllegalArgumentException("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
 */
publicvoidsetLayoutStyle(LayoutStylelayoutStyle) {
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
 */
publicLayoutStylegetLayoutStyle() {
returnlayoutStyle;
 }

privateLayoutStylegetLayoutStyle0() {
LayoutStylelayoutStyle = getLayoutStyle();
if (layoutStyle == null) {
layoutStyle = LayoutStyle.getInstance();
 }
returnlayoutStyle;
 }

privatevoidinvalidateHost() {
if (hostinstanceofJComponent) {
 ((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
 */
publicvoidaddLayoutComponent(Stringname, Componentcomponent) {
 }

/**
 * 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
 */
publicvoidremoveLayoutComponent(Componentcomponent) {
ComponentInfoinfo = 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
 */
publicDimensionpreferredLayoutSize(Containerparent) {
checkParent(parent);
prepare(PREF_SIZE);
returnadjustSize(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
 */
publicDimensionminimumLayoutSize(Containerparent) {
checkParent(parent);
prepare(MIN_SIZE);
returnadjustSize(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
 */
publicvoidlayoutContainer(Containerparent) {
// Step 1: Prepare for layout.
prepare(SPECIFIC_SIZE);
Insetsinsets = parent.getInsets();
intwidth = parent.getWidth() - insets.left - insets.right;
intheight = parent.getHeight() - insets.top - insets.bottom;
booleanltr = 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 (ComponentInfoinfo : 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
 */
publicvoidaddLayoutComponent(Componentcomponent, Objectconstraints) {
 }

/**
 * 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
 */
publicDimensionmaximumLayoutSize(Containerparent) {
checkParent(parent);
prepare(MAX_SIZE);
returnadjustSize(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}
 */
publicfloatgetLayoutAlignmentX(Containerparent) {
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}
 */
publicfloatgetLayoutAlignmentY(Containerparent) {
checkParent(parent);
return.5f;