GroupLayout.java revision 0
2N/A * Copyright 2006 Sun Microsystems, Inc. All Rights Reserved. 2N/A * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 2N/A * This code is free software; you can redistribute it and/or modify it 2N/A * under the terms of the GNU General Public License version 2 only, as 2N/A * published by the Free Software Foundation. Sun designates this 2N/A * particular file as subject to the "Classpath" exception as provided 2N/A * by Sun in the LICENSE file that accompanied this code. 2N/A * This code is distributed in the hope that it will be useful, but WITHOUT 2N/A * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 2N/A * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 2N/A * version 2 for more details (a copy is included in the LICENSE file that 2N/A * accompanied this code). 2N/A * You should have received a copy of the GNU General Public License version 2N/A * 2 along with this work; if not, write to the Free Software Foundation, 2N/A * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 2N/A * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 2N/A * CA 95054 USA or visit www.sun.com if you need additional information or 2N/A * have any questions. * {@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 * 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. * 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}. * 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. * {@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. * 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. * 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 * 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 * 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. * The following diagram shows the same three components, but with the * parallel group along the horizontal axis and the sequential group along * 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 following diagram shows a sequential group along both the horizontal * {@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 * The following builds a panel consisting of two labels in * one column, followed by two textfields in the next column: * 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); * When run the following is produced. * 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 * There are a couple of things to notice in this code: * <li>You need not explicitly add the components to the container; this * is indirectly done by using one of the {@code add} methods of * <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 * {@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}. // Used in size calculations // Used by prepare, indicates min, pref or max isn't going to be used. * Indicates the size from the component or gap should be used for a * particular range value. * Indicates the preferred size from the component or gap should * be used for a particular range value. // Whether or not we automatically try and create the preferred // padding between components. // Whether or not we automatically try and create the preferred // padding between components the touch the edge of the container and * Group responsible for layout along the horizontal axis. This is NOT * the user specified group, use getHorizontalGroup to dig that out. * Group responsible for layout along the vertical axis. This is NOT * the user specified group, use getVerticalGroup to dig that out. // Maps from Component to ComponentInfo. This is used for tracking // information specific to a Component. // Container we're doing layout for. // Used by areParallelSiblings, cached to avoid excessive garbage. // Indicates Springs have changed in some way since last change. // Indicates invalidateLayout has been invoked. // Whether or not any preferred padding (or container padding) springs * The LayoutStyle instance to use, if null the sharedInstance is used. * If true, components that are not visible are treated as though they * Enumeration of the possible ways {@code ParallelGroup} can align * @see #createParallelGroup(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) * 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) * Indicates the elements should be centered in * @see #createParallelGroup(Alignment) * Indicates the elements should be aligned along * @see #createParallelGroup(Alignment) * @see #createBaselineGroup(boolean,boolean) "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} * Sets whether component visiblity 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. * A value of {@code false} is useful when the visibility of components * is dynamically adjusted and you don't want surrounding components and * The specified value is used for components that do not have an * explicit visibility specified. * The default is {@code true}. * @param honorsVisibility whether component visiblity is considered when * sizing and positioning components * @see #setHonorsVisibility(Component,Boolean) * Returns whether component visiblity is considered when sizing and * positioning components. * @return whether component visiblity is considered when sizing and * Sets whether the component's visiblity 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. * If {@code component} is not a child of the {@code Container} this * {@code GroupLayout} is managine, it will be added to the * @param component the component * @param honorsVisibility whether {@code component}'s visiblity should be * considered for sizing and positioning * @throws IllegalArgumentException if {@code component} is {@code null} * @see #setHonorsVisibility(Component,Boolean) * 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 * @param autoCreatePadding whether a gap between components is * Returns {@code true} if gaps between components are automatically * @return {@code true} if gaps between components are automatically * 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 * 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 * 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} * 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 * 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} * 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 * Wraps the user specified group in a sequential group. If * container gaps should be generated the necessary springs are * Creates and returns a {@code SequentialGroup}. * @return a new {@code 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) * 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 * 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 * 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}. * 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 * 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 * 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. * This can be used multiple times to force any number of * components to share the same size. * 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[]) * 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 * This can be used multiple times to force any number of * components to share the same size. * 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} "Components must be non-null");
// Force the component to be added "SwingConstants.HORIZONTAL or SwingConstants.VERTICAL");
* 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 // Make sure all the components have been registered, otherwise we may // not update the correct Springs. * 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 * 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 * 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 * 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 * @param component the component to be removed * @see java.awt.Component#remove * 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 * 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 * 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 // Step 1: Prepare for layout. // Step 2: Calculate autopadding springs // Step 3: set the size of the groups. // Step 4: apply the size to the components. * 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 * 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 * 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} * 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} * 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 // 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 // Step 1: If not-valid, clear springs and update visibility. // Step 2: Make sure components are bound to ComponentInfos // Step 3: Adjust the autopadding. This removes existing // autopadding, then recalculates where it should go. // Step 4: (for min/pref/max size calculations only) calculate the // autopadding. This invokes for unsetting the calculated values, then // If sizeType == SPECIFIC_SIZE, it indicates we're doing layout, this // step will be done later on. " is not attached to a horizontal group");
" is not attached to a vertical group");
"GroupLayout can only be used with one Container at a time");
* Returns the {@code ComponentInfo} for the specified Component, * creating one if necessary. * 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. * Returns {@code true} if the two Components have a common ParallelGroup * ancestor along the particular axis. * 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} * Spring consists of a range: min, pref and max, a value some where in * the middle of that, and a location. Spring caches the * to be updated you must invoke clear. private abstract class Spring {
* Calculates and returns the minimum size. * @param axis the axis of layout; one of HORIZONTAL or VERTICAL * @return the minimum size * Calculates and returns the preferred size. * @param axis the axis of layout; one of HORIZONTAL or VERTICAL * @return the preferred size * Calculates and returns the minimum size. * @param axis the axis of layout; one of HORIZONTAL or VERTICAL * @return the minimum size * Sets the parent of this Spring. * Returns the parent of this spring. // This is here purely as a conveniance for ParallelGroup to avoid // having to track alignment separately. * Alignment for this Spring, this may be null. * Returns the minimum size. * Returns the preferred size. * Returns the maximum size. * 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 * Returns the current size. * 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 * @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 * {@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. * 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 * group.addComponent(myComponent, 100, 200, 300); * 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. * group.addComponent(myComponent, GroupLayout.PREFERRED_SIZE, * GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE); * 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}. * Similarly any methods that take a {@code Component} throw a * {@code NullPointerException} if passed {@code null} and any methods * that take a {@code Group} throw an {@code IllegalArgumentException} if * @see #createSequentialGroup * @see #createParallelGroup * Adds a {@code Group} to this {@code Group}. * @param group the {@code Group} to add * @return this {@code Group} * Adds a {@code Component} to this {@code Group}. * @param component the {@code Component} to add * @return this {@code Group} * 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 * @param pref the preferred size or one of {@code DEFAULT_SIZE} or * @param max the maximum size or one of {@code DEFAULT_SIZE} or * @return this {@code Group} * 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 * 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 * @return this {@code Group} * Adds the Spring to the list of {@code Spring}s and returns * This is invoked from {@code setSize} if passed a value * 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. * 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}. * 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 * @param trailingPadding any trailing autopadding springs are added * @param leading List of ComponentSprings that occur before this Group * @param trailing any trailing ComponentSpring are added to this * @param insert Whether or not to insert AutopaddingSprings or just * adjust any existing AutopaddingSprings. * Removes any AutopaddingSprings for this Group and its children. // Force size to be reset. * A {@code Group} that positions and sizes its elements * sequentially, one after another. This class has no public * constructor, use the {@code createSequentialGroup} method * 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 * @see #createSequentialGroup * 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} * 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} * 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 * @param pref the preferred size or one of {@code DEFAULT_SIZE} or * @param max the maximum size or one of {@code DEFAULT_SIZE} or * @return this {@code Group} * Adds an element representing the preferred gap between two * components. The element created to represent the gap is not * @param comp1 the first component * @param comp2 the second component * @param type the type of gap; one of the constants defined by * @return this {@code SequentialGroup} * @throws IllegalArgumentException if {@code type}, {@code comp1} or * {@code comp2} is {@code null} * Adds an element representing the preferred gap between two * @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} * @return this {@code SequentialGroup} * @throws IllegalArgumentException if {@code type}, {@code comp1} or * {@code comp2} is {@code null} "Components must be non-null");
* 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}. * The element created to represent the gap is not * @param type the type of gap; one of * {@code LayoutStyle.ComponentPlacement.RELATED} or * {@code LayoutStyle.ComponentPlacement.UNRELATED} * @return this {@code SequentialGroup} * @throws IllegalArgumentException if {@code type} is not one of * {@code LayoutStyle.ComponentPlacement.RELATED} or * {@code LayoutStyle.ComponentPlacement.UNRELATED} * 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} * @return this {@code SequentialGroup} * @throws IllegalArgumentException if {@code type} is not one of * {@code LayoutStyle.ComponentPlacement.RELATED} or * {@code LayoutStyle.ComponentPlacement.UNRELATED} "LayoutStyle.ComponentPlacement.RELATED or " +
"LayoutStyle.ComponentPlacement.UNRELATED");
* 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. * The element created to represent the gap is not * @return this {@code SequentialGroup} * 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 * @param pref the preferred size; one of {@code DEFAULT_SIZE} or a * @param max the maximum size; one of {@code DEFAULT_SIZE}, * {@code PREFERRED_SIZE} or a value >= 0 * @return this {@code SequentialGroup} "Pref and max must be either DEFAULT_VALUE " +
"or >= 0 and pref <= max");
// Layout at preferred size // 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 accomodate 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 // How much we would like to give each Spring. // Second pass, accumulate the resulting deltas (relative to // preferred) into sizes. // Spring didn't take all the space, reset how much // And finally set the size of each spring // Nothing resizable, use the min or max of each of the * Returns the sorted list of SpringDelta's for the current set of * Springs. The list is ordered based on the amount of flexibility of // First pass, figure out what is resizable // Warning, this must use springs.size, as it may change during the // Autopadding spring. Set the sources of the // autopadding spring based on newLeading. // Last spring in the list, add it to // There's leading ComponentSprings, create an // Force the newly created spring to be considered // by NOT incrementing counter // Spring is a Component, make it the target of any // leading AutopaddingSpring. // Last Spring, add it to trailing // Not that last Spring, add it to leading // Forward call to child Group // Spring to use for baseline isn't resizable. In this case // baseline resize behavior can be determined based on how // preceeding springs resize. // If we get here, both leading and trailing springs are // resizable. Fall through to OTHER. // Not resizable, treat as constant_ascent "Pref and max must be either DEFAULT_SIZE, " +
"PREFERRED_SIZE, or >= 0 and pref <= max");
* Used by SequentialGroup in calculating resizability of springs. // Delta, one of pref - min or max - pref. * 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. * 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 * java.awt.Component.BaselineResizeBehavior#CONSTANT_ASCENT CONSTANT_ASCENT} and * java.awt.Component.BaselineResizeBehavior#CONSTANT_DESCENT CONSTANT_DESCENT}. * 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 * 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. * 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. * 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. * 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 * <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. * 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. * 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) // How children are layed out. // Whether or not we're resizable. * 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 * @param alignment the alignment * @param group the {@code Group} to add * @return this {@code ParallelGroup} * @throws IllegalArgumentException if {@code alignment} is * 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 * 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 * @return this {@code Group} default:
// LEADING, or BASELINE "LEADING, TRAILING or CENTER");
* An extension of {@code ParallelGroup} that aligns its * constituent {@code Spring}s along the baseline. // Whether or not all child springs have a baseline // max(spring.getBaseline()) of all springs aligned along the baseline // max(spring.getPreferredSize().height - spring.getBaseline()) of all // springs aligned along the baseline that have a baseline // Whether baselineAnchoredToTop was explicitly set // 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) // Whether or not the baseline has been calculated. default:
// CENTER_OFFSET and OTHER, not resizable // Not aligned along the baseline, or no baseline. // CENTER_OFFSET and OTHER are !resizable, use // Not aligned along the baseline, or no baseline. * Lays out springs that have a baseline along the baseline. All default:
// CENTER_OFFSET & OTHER, not resizable // Force the baseline to be calculated // If the axis is VERTICAL, throws an IllegalStateException "Baseline must be used along vertical axis");
// DEFAULT_SIZE or PREFERRED_SIZE // Baseline for the component, computed as necessary. // Whether or not the size has been requested yet. "Component must be non-null");
// getComponentInfo makes sure component is a child of the // Container GroupLayout is the LayoutManager for. * Spring representing the preferred distance between two components. * Spring represented a certain amount of space. * 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. * Represents two springs that should have autopadding inserted between * An extension of AutopaddingSpring used for container level padding. // LinkInfo contains the set of ComponentInfosthat are linked along a * This class is also used to handle Springs that have their sizes // Component being layed out // If the component's size is linked to other components, the // horizontalMaster and/or verticalMaster reference the group of * Updates the cached visibility. * @return true if the visibility changed * Returns true if this component has its size linked to // horizontalMaster field is directly set by adding // verticalMaster field is directly set by adding