< prev index next >
src/java.desktop/share/classes/java/awt/GridBagLayout.java
Print this page
*** 26,47 ****
import java.util.Hashtable;
import java.util.Arrays;
/**
! * The <code>GridBagLayout</code> class is a flexible layout
* manager that aligns components vertically, horizontally or along their
* baseline without requiring that the components be of the same size.
! * Each <code>GridBagLayout</code> object maintains a dynamic,
* rectangular grid of cells, with each component occupying
* one or more cells, called its <em>display area</em>.
* <p>
! * Each component managed by a <code>GridBagLayout</code> is associated with
* an instance of {@link GridBagConstraints}. The constraints object
* specifies where a component's display area should be located on the grid
* and how the component should be positioned within its display area. In
! * addition to its constraints object, the <code>GridBagLayout</code> also
* considers each component's minimum and preferred sizes in order to
* determine a component's size.
* <p>
* The overall orientation of the grid depends on the container's
* {@link ComponentOrientation} property. For horizontal left-to-right
--- 26,47 ----
import java.util.Hashtable;
import java.util.Arrays;
/**
! * The {@code GridBagLayout} class is a flexible layout
* manager that aligns components vertically, horizontally or along their
* baseline without requiring that the components be of the same size.
! * Each {@code GridBagLayout} object maintains a dynamic,
* rectangular grid of cells, with each component occupying
* one or more cells, called its <em>display area</em>.
* <p>
! * Each component managed by a {@code GridBagLayout} is associated with
* an instance of {@link GridBagConstraints}. The constraints object
* specifies where a component's display area should be located on the grid
* and how the component should be positioned within its display area. In
! * addition to its constraints object, the {@code GridBagLayout} also
* considers each component's minimum and preferred sizes in order to
* determine a component's size.
* <p>
* The overall orientation of the grid depends on the container's
* {@link ComponentOrientation} property. For horizontal left-to-right
*** 50,61 ****
* horizontal right-to-left orientations, grid coordinate (0,0) is in the upper
* right corner of the container with x increasing to the left and y
* increasing downward.
* <p>
* To use a grid bag layout effectively, you must customize one or more
! * of the <code>GridBagConstraints</code> objects that are associated
! * with its components. You customize a <code>GridBagConstraints</code>
* object by setting one or more of its instance variables:
*
* <dl>
* <dt>{@link GridBagConstraints#gridx},
* {@link GridBagConstraints#gridy}
--- 50,61 ----
* horizontal right-to-left orientations, grid coordinate (0,0) is in the upper
* right corner of the container with x increasing to the left and y
* increasing downward.
* <p>
* To use a grid bag layout effectively, you must customize one or more
! * of the {@code GridBagConstraints} objects that are associated
! * with its components. You customize a {@code GridBagConstraints}
* object by setting one or more of its instance variables:
*
* <dl>
* <dt>{@link GridBagConstraints#gridx},
* {@link GridBagConstraints#gridy}
*** 63,126 ****
* display area, where the cell at the origin of the grid has address
* <code>gridx = 0</code>,
* <code>gridy = 0</code>. For horizontal left-to-right layout,
* a component's leading corner is its upper left. For horizontal
* right-to-left layout, a component's leading corner is its upper right.
! * Use <code>GridBagConstraints.RELATIVE</code> (the default value)
* to specify that the component be placed immediately following
! * (along the x axis for <code>gridx</code> or the y axis for
! * <code>gridy</code>) the component that was added to the container
* just before this component was added.
* <dt>{@link GridBagConstraints#gridwidth},
* {@link GridBagConstraints#gridheight}
! * <dd>Specifies the number of cells in a row (for <code>gridwidth</code>)
! * or column (for <code>gridheight</code>)
* in the component's display area.
* The default value is 1.
! * Use <code>GridBagConstraints.REMAINDER</code> to specify
! * that the component's display area will be from <code>gridx</code>
! * to the last cell in the row (for <code>gridwidth</code>)
! * or from <code>gridy</code> to the last cell in the column
! * (for <code>gridheight</code>).
! *
! * Use <code>GridBagConstraints.RELATIVE</code> to specify
! * that the component's display area will be from <code>gridx</code>
! * to the next to the last cell in its row (for <code>gridwidth</code>
! * or from <code>gridy</code> to the next to the last cell in its
! * column (for <code>gridheight</code>).
*
* <dt>{@link GridBagConstraints#fill}
* <dd>Used when the component's display area
* is larger than the component's requested size
* to determine whether (and how) to resize the component.
* Possible values are
! * <code>GridBagConstraints.NONE</code> (the default),
! * <code>GridBagConstraints.HORIZONTAL</code>
* (make the component wide enough to fill its display area
* horizontally, but don't change its height),
! * <code>GridBagConstraints.VERTICAL</code>
* (make the component tall enough to fill its display area
* vertically, but don't change its width), and
! * <code>GridBagConstraints.BOTH</code>
* (make the component fill its display area entirely).
* <dt>{@link GridBagConstraints#ipadx},
* {@link GridBagConstraints#ipady}
* <dd>Specifies the component's internal padding within the layout,
* how much to add to the minimum size of the component.
* The width of the component will be at least its minimum width
! * plus <code>ipadx</code> pixels. Similarly, the height of
* the component will be at least the minimum height plus
! * <code>ipady</code> pixels.
* <dt>{@link GridBagConstraints#insets}
* <dd>Specifies the component's external padding, the minimum
* amount of space between the component and the edges of its display area.
* <dt>{@link GridBagConstraints#anchor}
* <dd>Specifies where the component should be positioned in its display area.
* There are three kinds of possible values: absolute, orientation-relative,
* and baseline-relative
* Orientation relative values are interpreted relative to the container's
! * <code>ComponentOrientation</code> property while absolute values
* are not. Baseline relative values are calculated relative to the
* baseline. Valid values are:
*
* <center><table BORDER=0 WIDTH=800
* SUMMARY="absolute, relative and baseline values as described above">
--- 63,126 ----
* display area, where the cell at the origin of the grid has address
* <code>gridx = 0</code>,
* <code>gridy = 0</code>. For horizontal left-to-right layout,
* a component's leading corner is its upper left. For horizontal
* right-to-left layout, a component's leading corner is its upper right.
! * Use {@code GridBagConstraints.RELATIVE} (the default value)
* to specify that the component be placed immediately following
! * (along the x axis for {@code gridx} or the y axis for
! * {@code gridy}) the component that was added to the container
* just before this component was added.
* <dt>{@link GridBagConstraints#gridwidth},
* {@link GridBagConstraints#gridheight}
! * <dd>Specifies the number of cells in a row (for {@code gridwidth})
! * or column (for {@code gridheight})
* in the component's display area.
* The default value is 1.
! * Use {@code GridBagConstraints.REMAINDER} to specify
! * that the component's display area will be from {@code gridx}
! * to the last cell in the row (for {@code gridwidth})
! * or from {@code gridy} to the last cell in the column
! * (for {@code gridheight}).
! *
! * Use {@code GridBagConstraints.RELATIVE} to specify
! * that the component's display area will be from {@code gridx}
! * to the next to the last cell in its row (for {@code gridwidth}
! * or from {@code gridy} to the next to the last cell in its
! * column (for {@code gridheight}).
*
* <dt>{@link GridBagConstraints#fill}
* <dd>Used when the component's display area
* is larger than the component's requested size
* to determine whether (and how) to resize the component.
* Possible values are
! * {@code GridBagConstraints.NONE} (the default),
! * {@code GridBagConstraints.HORIZONTAL}
* (make the component wide enough to fill its display area
* horizontally, but don't change its height),
! * {@code GridBagConstraints.VERTICAL}
* (make the component tall enough to fill its display area
* vertically, but don't change its width), and
! * {@code GridBagConstraints.BOTH}
* (make the component fill its display area entirely).
* <dt>{@link GridBagConstraints#ipadx},
* {@link GridBagConstraints#ipady}
* <dd>Specifies the component's internal padding within the layout,
* how much to add to the minimum size of the component.
* The width of the component will be at least its minimum width
! * plus {@code ipadx} pixels. Similarly, the height of
* the component will be at least the minimum height plus
! * {@code ipady} pixels.
* <dt>{@link GridBagConstraints#insets}
* <dd>Specifies the component's external padding, the minimum
* amount of space between the component and the edges of its display area.
* <dt>{@link GridBagConstraints#anchor}
* <dd>Specifies where the component should be positioned in its display area.
* There are three kinds of possible values: absolute, orientation-relative,
* and baseline-relative
* Orientation relative values are interpreted relative to the container's
! * {@code ComponentOrientation} property while absolute values
* are not. Baseline relative values are calculated relative to the
* baseline. Valid values are:
*
* <center><table BORDER=0 WIDTH=800
* SUMMARY="absolute, relative and baseline values as described above">
*** 130,186 ****
* <th><P style="text-align:left">Baseline Relative Values</th>
* </tr>
* <tr>
* <td>
* <ul style="list-style-type:none">
! * <li><code>GridBagConstraints.NORTH</code></li>
! * <li><code>GridBagConstraints.SOUTH</code></li>
! * <li><code>GridBagConstraints.WEST</code></li>
! * <li><code>GridBagConstraints.EAST</code></li>
! * <li><code>GridBagConstraints.NORTHWEST</code></li>
! * <li><code>GridBagConstraints.NORTHEAST</code></li>
! * <li><code>GridBagConstraints.SOUTHWEST</code></li>
! * <li><code>GridBagConstraints.SOUTHEAST</code></li>
! * <li><code>GridBagConstraints.CENTER</code> (the default)</li>
* </ul>
* </td>
* <td>
* <ul style="list-style-type:none">
! * <li><code>GridBagConstraints.PAGE_START</code></li>
! * <li><code>GridBagConstraints.PAGE_END</code></li>
! * <li><code>GridBagConstraints.LINE_START</code></li>
! * <li><code>GridBagConstraints.LINE_END</code></li>
! * <li><code>GridBagConstraints.FIRST_LINE_START</code></li>
! * <li><code>GridBagConstraints.FIRST_LINE_END</code></li>
! * <li><code>GridBagConstraints.LAST_LINE_START</code></li>
! * <li><code>GridBagConstraints.LAST_LINE_END</code></li>
* </ul>
* </td>
* <td>
* <ul style="list-style-type:none">
! * <li><code>GridBagConstraints.BASELINE</code></li>
! * <li><code>GridBagConstraints.BASELINE_LEADING</code></li>
! * <li><code>GridBagConstraints.BASELINE_TRAILING</code></li>
! * <li><code>GridBagConstraints.ABOVE_BASELINE</code></li>
! * <li><code>GridBagConstraints.ABOVE_BASELINE_LEADING</code></li>
! * <li><code>GridBagConstraints.ABOVE_BASELINE_TRAILING</code></li>
! * <li><code>GridBagConstraints.BELOW_BASELINE</code></li>
! * <li><code>GridBagConstraints.BELOW_BASELINE_LEADING</code></li>
! * <li><code>GridBagConstraints.BELOW_BASELINE_TRAILING</code></li>
* </ul>
* </td>
* </tr>
* </table></center>
* <dt>{@link GridBagConstraints#weightx},
* {@link GridBagConstraints#weighty}
* <dd>Used to determine how to distribute space, which is
* important for specifying resizing behavior.
* Unless you specify a weight for at least one component
! * in a row (<code>weightx</code>) and column (<code>weighty</code>),
* all the components clump together in the center of their container.
* This is because when the weight is zero (the default),
! * the <code>GridBagLayout</code> object puts any extra space
* between its grid of cells and the edges of the container.
* </dl>
* <p>
* Each row may have a baseline; the baseline is determined by the
* components in that row that have a valid baseline and are aligned
--- 130,186 ----
* <th><P style="text-align:left">Baseline Relative Values</th>
* </tr>
* <tr>
* <td>
* <ul style="list-style-type:none">
! * <li>{@code GridBagConstraints.NORTH}</li>
! * <li>{@code GridBagConstraints.SOUTH}</li>
! * <li>{@code GridBagConstraints.WEST}</li>
! * <li>{@code GridBagConstraints.EAST}</li>
! * <li>{@code GridBagConstraints.NORTHWEST}</li>
! * <li>{@code GridBagConstraints.NORTHEAST}</li>
! * <li>{@code GridBagConstraints.SOUTHWEST}</li>
! * <li>{@code GridBagConstraints.SOUTHEAST}</li>
! * <li>{@code GridBagConstraints.CENTER} (the default)</li>
* </ul>
* </td>
* <td>
* <ul style="list-style-type:none">
! * <li>{@code GridBagConstraints.PAGE_START}</li>
! * <li>{@code GridBagConstraints.PAGE_END}</li>
! * <li>{@code GridBagConstraints.LINE_START}</li>
! * <li>{@code GridBagConstraints.LINE_END}</li>
! * <li>{@code GridBagConstraints.FIRST_LINE_START}</li>
! * <li>{@code GridBagConstraints.FIRST_LINE_END}</li>
! * <li>{@code GridBagConstraints.LAST_LINE_START}</li>
! * <li>{@code GridBagConstraints.LAST_LINE_END}</li>
* </ul>
* </td>
* <td>
* <ul style="list-style-type:none">
! * <li>{@code GridBagConstraints.BASELINE}</li>
! * <li>{@code GridBagConstraints.BASELINE_LEADING}</li>
! * <li>{@code GridBagConstraints.BASELINE_TRAILING}</li>
! * <li>{@code GridBagConstraints.ABOVE_BASELINE}</li>
! * <li>{@code GridBagConstraints.ABOVE_BASELINE_LEADING}</li>
! * <li>{@code GridBagConstraints.ABOVE_BASELINE_TRAILING}</li>
! * <li>{@code GridBagConstraints.BELOW_BASELINE}</li>
! * <li>{@code GridBagConstraints.BELOW_BASELINE_LEADING}</li>
! * <li>{@code GridBagConstraints.BELOW_BASELINE_TRAILING}</li>
* </ul>
* </td>
* </tr>
* </table></center>
* <dt>{@link GridBagConstraints#weightx},
* {@link GridBagConstraints#weighty}
* <dd>Used to determine how to distribute space, which is
* important for specifying resizing behavior.
* Unless you specify a weight for at least one component
! * in a row ({@code weightx}) and column ({@code weighty}),
* all the components clump together in the center of their container.
* This is because when the weight is zero (the default),
! * the {@code GridBagLayout} object puts any extra space
* between its grid of cells and the edges of the container.
* </dl>
* <p>
* Each row may have a baseline; the baseline is determined by the
* components in that row that have a valid baseline and are aligned
*** 204,229 ****
* alt="The following text describes this graphic (Figure 1)." style="float:center">
* </td>
* </table></center>
* This layout consists of three components:
* <ul><li>A panel that starts in row 0 and ends in row 1. The panel
! * has a baseline-resize behavior of <code>CONSTANT_DESCENT</code> and has
! * an anchor of <code>BASELINE</code>. As the baseline-resize behavior
! * is <code>CONSTANT_DESCENT</code> the prevailing row for the panel is
* row 1.
* <li>Two buttons, each with a baseline-resize behavior of
! * <code>CENTER_OFFSET</code> and an anchor of <code>BASELINE</code>.
* </ul>
* Because the second button and the panel share the same prevailing row,
* they are both aligned along their baseline.
* <p>
* Components positioned using one of the baseline-relative values resize
* differently than when positioned using an absolute or orientation-relative
* value. How components change is dictated by how the baseline of the
* prevailing row changes. The baseline is anchored to the
* bottom of the display area if any components with the same prevailing row
! * have a baseline-resize behavior of <code>CONSTANT_DESCENT</code>,
* otherwise the baseline is anchored to the top of the display area.
* The following rules dictate the resize behavior:
* <ul>
* <li>Resizable components positioned above the baseline can only
* grow as tall as the baseline. For example, if the baseline is at 100
--- 204,229 ----
* alt="The following text describes this graphic (Figure 1)." style="float:center">
* </td>
* </table></center>
* This layout consists of three components:
* <ul><li>A panel that starts in row 0 and ends in row 1. The panel
! * has a baseline-resize behavior of {@code CONSTANT_DESCENT} and has
! * an anchor of {@code BASELINE}. As the baseline-resize behavior
! * is {@code CONSTANT_DESCENT} the prevailing row for the panel is
* row 1.
* <li>Two buttons, each with a baseline-resize behavior of
! * {@code CENTER_OFFSET} and an anchor of {@code BASELINE}.
* </ul>
* Because the second button and the panel share the same prevailing row,
* they are both aligned along their baseline.
* <p>
* Components positioned using one of the baseline-relative values resize
* differently than when positioned using an absolute or orientation-relative
* value. How components change is dictated by how the baseline of the
* prevailing row changes. The baseline is anchored to the
* bottom of the display area if any components with the same prevailing row
! * have a baseline-resize behavior of {@code CONSTANT_DESCENT},
* otherwise the baseline is anchored to the top of the display area.
* The following rules dictate the resize behavior:
* <ul>
* <li>Resizable components positioned above the baseline can only
* grow as tall as the baseline. For example, if the baseline is at 100
*** 231,246 ****
* baseline can never grow more than 100 units.
* <li>Similarly, resizable components positioned below the baseline can
* only grow as high as the difference between the display height and the
* baseline.
* <li>Resizable components positioned on the baseline with a
! * baseline-resize behavior of <code>OTHER</code> are only resized if
* the baseline at the resized size fits within the display area. If
* the baseline is such that it does not fit within the display area
* the component is not resized.
* <li>Components positioned on the baseline that do not have a
! * baseline-resize behavior of <code>OTHER</code>
* can only grow as tall as {@code display height - baseline + baseline of component}.
* </ul>
* If you position a component along the baseline, but the
* component does not have a valid baseline, it will be vertically centered
* in its space. Similarly if you have positioned a component relative
--- 231,246 ----
* baseline can never grow more than 100 units.
* <li>Similarly, resizable components positioned below the baseline can
* only grow as high as the difference between the display height and the
* baseline.
* <li>Resizable components positioned on the baseline with a
! * baseline-resize behavior of {@code OTHER} are only resized if
* the baseline at the resized size fits within the display area. If
* the baseline is such that it does not fit within the display area
* the component is not resized.
* <li>Components positioned on the baseline that do not have a
! * baseline-resize behavior of {@code OTHER}
* can only grow as tall as {@code display height - baseline + baseline of component}.
* </ul>
* If you position a component along the baseline, but the
* component does not have a valid baseline, it will be vertically centered
* in its space. Similarly if you have positioned a component relative
*** 264,276 ****
* <td>Figure 2: Horizontal, Left-to-Right</td>
* <td>Figure 3: Horizontal, Right-to-Left</td>
* </tr>
* </table></center>
* <p>
! * Each of the ten components has the <code>fill</code> field
! * of its associated <code>GridBagConstraints</code> object
! * set to <code>GridBagConstraints.BOTH</code>.
* In addition, the components have the following non-default constraints:
*
* <ul>
* <li>Button1, Button2, Button3: <code>weightx = 1.0</code>
* <li>Button4: <code>weightx = 1.0</code>,
--- 264,276 ----
* <td>Figure 2: Horizontal, Left-to-Right</td>
* <td>Figure 3: Horizontal, Right-to-Left</td>
* </tr>
* </table></center>
* <p>
! * Each of the ten components has the {@code fill} field
! * of its associated {@code GridBagConstraints} object
! * set to {@code GridBagConstraints.BOTH}.
* In addition, the components have the following non-default constraints:
*
* <ul>
* <li>Button1, Button2, Button3: <code>weightx = 1.0</code>
* <li>Button4: <code>weightx = 1.0</code>,
*** 385,396 ****
protected static final int PREFERREDSIZE = 2;
/**
* This hashtable maintains the association between
* a component and its gridbag constraints.
! * The Keys in <code>comptable</code> are the components and the
! * values are the instances of <code>GridBagConstraints</code>.
*
* @serial
* @see java.awt.GridBagConstraints
*/
protected Hashtable<Component,GridBagConstraints> comptable;
--- 385,396 ----
protected static final int PREFERREDSIZE = 2;
/**
* This hashtable maintains the association between
* a component and its gridbag constraints.
! * The Keys in {@code comptable} are the components and the
! * values are the instances of {@code GridBagConstraints}.
*
* @serial
* @see java.awt.GridBagConstraints
*/
protected Hashtable<Component,GridBagConstraints> comptable;
*** 398,408 ****
/**
* This field holds a gridbag constraints instance
* containing the default values, so if a component
* does not have gridbag constraints associated with
* it, then the component will be assigned a
! * copy of the <code>defaultConstraints</code>.
*
* @serial
* @see #getConstraints(Component)
* @see #setConstraints(Component, GridBagConstraints)
* @see #lookupConstraints(Component)
--- 398,408 ----
/**
* This field holds a gridbag constraints instance
* containing the default values, so if a component
* does not have gridbag constraints associated with
* it, then the component will be assigned a
! * copy of the {@code defaultConstraints}.
*
* @serial
* @see #getConstraints(Component)
* @see #setConstraints(Component, GridBagConstraints)
* @see #lookupConstraints(Component)
*** 412,422 ****
/**
* This field holds the layout information
* for the gridbag. The information in this field
* is based on the most recent validation of the
* gridbag.
! * If <code>layoutInfo</code> is <code>null</code>
* this indicates that there are no components in
* the gridbag or if there are components, they have
* not yet been validated.
*
* @serial
--- 412,422 ----
/**
* This field holds the layout information
* for the gridbag. The information in this field
* is based on the most recent validation of the
* gridbag.
! * If {@code layoutInfo} is {@code null}
* this indicates that there are no components in
* the gridbag or if there are components, they have
* not yet been validated.
*
* @serial
*** 424,434 ****
*/
protected GridBagLayoutInfo layoutInfo;
/**
* This field holds the overrides to the column minimum
! * width. If this field is non-<code>null</code> the values are
* applied to the gridbag after all of the minimum columns
* widths have been calculated.
* If columnWidths has more elements than the number of
* columns, columns are added to the gridbag to match
* the number of elements in columnWidth.
--- 424,434 ----
*/
protected GridBagLayoutInfo layoutInfo;
/**
* This field holds the overrides to the column minimum
! * width. If this field is non-{@code null} the values are
* applied to the gridbag after all of the minimum columns
* widths have been calculated.
* If columnWidths has more elements than the number of
* columns, columns are added to the gridbag to match
* the number of elements in columnWidth.
*** 438,492 ****
*/
public int columnWidths[];
/**
* This field holds the overrides to the row minimum
! * heights. If this field is non-<code>null</code> the values are
* applied to the gridbag after all of the minimum row
* heights have been calculated.
! * If <code>rowHeights</code> has more elements than the number of
* rows, rows are added to the gridbag to match
! * the number of elements in <code>rowHeights</code>.
*
* @serial
* @see #getLayoutDimensions()
*/
public int rowHeights[];
/**
* This field holds the overrides to the column weights.
! * If this field is non-<code>null</code> the values are
* applied to the gridbag after all of the columns
* weights have been calculated.
! * If <code>columnWeights[i]</code> > weight for column i, then
! * column i is assigned the weight in <code>columnWeights[i]</code>.
! * If <code>columnWeights</code> has more elements than the number
* of columns, the excess elements are ignored - they do
* not cause more columns to be created.
*
* @serial
*/
public double columnWeights[];
/**
* This field holds the overrides to the row weights.
! * If this field is non-<code>null</code> the values are
* applied to the gridbag after all of the rows
* weights have been calculated.
! * If <code>rowWeights[i]</code> > weight for row i, then
! * row i is assigned the weight in <code>rowWeights[i]</code>.
! * If <code>rowWeights</code> has more elements than the number
* of rows, the excess elements are ignored - they do
* not cause more rows to be created.
*
* @serial
*/
public double rowWeights[];
/**
* The component being positioned. This is set before calling into
! * <code>adjustForGravity</code>.
*/
private Component componentAdjusting;
/**
* Creates a grid bag layout manager.
--- 438,492 ----
*/
public int columnWidths[];
/**
* This field holds the overrides to the row minimum
! * heights. If this field is non-{@code null} the values are
* applied to the gridbag after all of the minimum row
* heights have been calculated.
! * If {@code rowHeights} has more elements than the number of
* rows, rows are added to the gridbag to match
! * the number of elements in {@code rowHeights}.
*
* @serial
* @see #getLayoutDimensions()
*/
public int rowHeights[];
/**
* This field holds the overrides to the column weights.
! * If this field is non-{@code null} the values are
* applied to the gridbag after all of the columns
* weights have been calculated.
! * If {@code columnWeights[i] >} weight for column i, then
! * column i is assigned the weight in {@code columnWeights[i]}.
! * If {@code columnWeights} has more elements than the number
* of columns, the excess elements are ignored - they do
* not cause more columns to be created.
*
* @serial
*/
public double columnWeights[];
/**
* This field holds the overrides to the row weights.
! * If this field is non-{@code null} the values are
* applied to the gridbag after all of the rows
* weights have been calculated.
! * If {@code rowWeights[i] > } weight for row i, then
! * row i is assigned the weight in {@code rowWeights[i]}.
! * If {@code rowWeights} has more elements than the number
* of rows, the excess elements are ignored - they do
* not cause more rows to be created.
*
* @serial
*/
public double rowWeights[];
/**
* The component being positioned. This is set before calling into
! * {@code adjustForGravity}.
*/
private Component componentAdjusting;
/**
* Creates a grid bag layout manager.
*** 505,515 ****
comptable.put(comp, (GridBagConstraints)constraints.clone());
}
/**
* Gets the constraints for the specified component. A copy of
! * the actual <code>GridBagConstraints</code> object is returned.
* @param comp the component to be queried
* @return the constraint for the specified component in this
* grid bag layout; a copy of the actual constraint
* object is returned
*/
--- 505,515 ----
comptable.put(comp, (GridBagConstraints)constraints.clone());
}
/**
* Gets the constraints for the specified component. A copy of
! * the actual {@code GridBagConstraints} object is returned.
* @param comp the component to be queried
* @return the constraint for the specified component in this
* grid bag layout; a copy of the actual constraint
* object is returned
*/
*** 523,538 ****
}
/**
* Retrieves the constraints for the specified component.
* The return value is not a copy, but is the actual
! * <code>GridBagConstraints</code> object used by the layout mechanism.
* <p>
! * If <code>comp</code> is not in the <code>GridBagLayout</code>,
! * a set of default <code>GridBagConstraints</code> are returned.
! * A <code>comp</code> value of <code>null</code> is invalid
! * and returns <code>null</code>.
*
* @param comp the component to be queried
* @return the constraints for the specified component
*/
protected GridBagConstraints lookupConstraints(Component comp) {
--- 523,538 ----
}
/**
* Retrieves the constraints for the specified component.
* The return value is not a copy, but is the actual
! * {@code GridBagConstraints} object used by the layout mechanism.
* <p>
! * If {@code comp} is not in the {@code GridBagLayout},
! * a set of default {@code GridBagConstraints} are returned.
! * A {@code comp} value of {@code null} is invalid
! * and returns {@code null}.
*
* @param comp the component to be queried
* @return the constraints for the specified component
*/
protected GridBagConstraints lookupConstraints(Component comp) {
*** 554,564 ****
/**
* Determines the origin of the layout area, in the graphics coordinate
* space of the target container. This value represents the pixel
* coordinates of the top-left corner of the layout area regardless of
! * the <code>ComponentOrientation</code> value of the container. This
* is distinct from the grid origin given by the cell coordinates (0,0).
* Most applications do not call this method directly.
* @return the graphics origin of the cell in the top-left
* corner of the layout grid
* @see java.awt.ComponentOrientation
--- 554,564 ----
/**
* Determines the origin of the layout area, in the graphics coordinate
* space of the target container. This value represents the pixel
* coordinates of the top-left corner of the layout area regardless of
! * the {@code ComponentOrientation} value of the container. This
* is distinct from the grid origin given by the cell coordinates (0,0).
* Most applications do not call this method directly.
* @return the graphics origin of the cell in the top-left
* corner of the layout grid
* @see java.awt.ComponentOrientation
*** 629,648 ****
* minus 1) and its row index (ranging from 0 to the number of
* rows minus 1).
* <p>
* If the <code>(x, y)</code> point lies
* outside the grid, the following rules are used.
! * The column index is returned as zero if <code>x</code> lies to the
* left of the layout for a left-to-right container or to the right of
* the layout for a right-to-left container. The column index is returned
! * as the number of columns if <code>x</code> lies
* to the right of the layout in a left-to-right container or to the left
* in a right-to-left container.
! * The row index is returned as zero if <code>y</code> lies above the
! * layout, and as the number of rows if <code>y</code> lies
* below the layout. The orientation of a container is determined by its
! * <code>ComponentOrientation</code> property.
* @param x the <i>x</i> coordinate of a point
* @param y the <i>y</i> coordinate of a point
* @return an ordered pair of indexes that indicate which cell
* in the layout grid contains the point
* (<i>x</i>, <i>y</i>).
--- 629,648 ----
* minus 1) and its row index (ranging from 0 to the number of
* rows minus 1).
* <p>
* If the <code>(x, y)</code> point lies
* outside the grid, the following rules are used.
! * The column index is returned as zero if {@code x} lies to the
* left of the layout for a left-to-right container or to the right of
* the layout for a right-to-left container. The column index is returned
! * as the number of columns if {@code x} lies
* to the right of the layout in a left-to-right container or to the left
* in a right-to-left container.
! * The row index is returned as zero if {@code y} lies above the
! * layout, and as the number of rows if {@code y} lies
* below the layout. The orientation of a container is determined by its
! * {@code ComponentOrientation} property.
* @param x the <i>x</i> coordinate of a point
* @param y the <i>y</i> coordinate of a point
* @return an ordered pair of indexes that indicate which cell
* in the layout grid contains the point
* (<i>x</i>, <i>y</i>).
*** 690,707 ****
public void addLayoutComponent(String name, Component comp) {
}
/**
* Adds the specified component to the layout, using the specified
! * <code>constraints</code> object. Note that constraints
* are mutable and are, therefore, cloned when cached.
*
* @param comp the component to be added
* @param constraints an object that determines how
* the component is added to the layout
! * @exception IllegalArgumentException if <code>constraints</code>
! * is not a <code>GridBagConstraint</code>
*/
public void addLayoutComponent(Component comp, Object constraints) {
if (constraints instanceof GridBagConstraints) {
setConstraints(comp, (GridBagConstraints)constraints);
} else if (constraints != null) {
--- 690,707 ----
public void addLayoutComponent(String name, Component comp) {
}
/**
* Adds the specified component to the layout, using the specified
! * {@code constraints} object. Note that constraints
* are mutable and are, therefore, cloned when cached.
*
* @param comp the component to be added
* @param constraints an object that determines how
* the component is added to the layout
! * @exception IllegalArgumentException if {@code constraints}
! * is not a {@code GridBagConstraint}
*/
public void addLayoutComponent(Component comp, Object constraints) {
if (constraints instanceof GridBagConstraints) {
setConstraints(comp, (GridBagConstraints)constraints);
} else if (constraints != null) {
*** 720,752 ****
public void removeLayoutComponent(Component comp) {
removeConstraints(comp);
}
/**
! * Determines the preferred size of the <code>parent</code>
* container using this grid bag layout.
* <p>
* Most applications do not call this method directly.
*
* @param parent the container in which to do the layout
* @see java.awt.Container#getPreferredSize
! * @return the preferred size of the <code>parent</code>
* container
*/
public Dimension preferredLayoutSize(Container parent) {
GridBagLayoutInfo info = getLayoutInfo(parent, PREFERREDSIZE);
return getMinSize(parent, info);
}
/**
! * Determines the minimum size of the <code>parent</code> container
* using this grid bag layout.
* <p>
* Most applications do not call this method directly.
* @param parent the container in which to do the layout
* @see java.awt.Container#doLayout
! * @return the minimum size of the <code>parent</code> container
*/
public Dimension minimumLayoutSize(Container parent) {
GridBagLayoutInfo info = getLayoutInfo(parent, MINSIZE);
return getMinSize(parent, info);
}
--- 720,752 ----
public void removeLayoutComponent(Component comp) {
removeConstraints(comp);
}
/**
! * Determines the preferred size of the {@code parent}
* container using this grid bag layout.
* <p>
* Most applications do not call this method directly.
*
* @param parent the container in which to do the layout
* @see java.awt.Container#getPreferredSize
! * @return the preferred size of the {@code parent}
* container
*/
public Dimension preferredLayoutSize(Container parent) {
GridBagLayoutInfo info = getLayoutInfo(parent, PREFERREDSIZE);
return getMinSize(parent, info);
}
/**
! * Determines the minimum size of the {@code parent} container
* using this grid bag layout.
* <p>
* Most applications do not call this method directly.
* @param parent the container in which to do the layout
* @see java.awt.Container#doLayout
! * @return the minimum size of the {@code parent} container
*/
public Dimension minimumLayoutSize(Container parent) {
GridBagLayoutInfo info = getLayoutInfo(parent, MINSIZE);
return getMinSize(parent, info);
}
*** 769,779 ****
* 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.
*
! * @return the value <code>0.5f</code> to indicate centered
*/
public float getLayoutAlignmentX(Container parent) {
return 0.5f;
}
--- 769,779 ----
* 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.
*
! * @return the value {@code 0.5f} to indicate centered
*/
public float getLayoutAlignmentX(Container parent) {
return 0.5f;
}
*** 782,792 ****
* 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.
*
! * @return the value <code>0.5f</code> to indicate centered
*/
public float getLayoutAlignmentY(Container parent) {
return 0.5f;
}
--- 782,792 ----
* 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.
*
! * @return the value {@code 0.5f} to indicate centered
*/
public float getLayoutAlignmentY(Container parent) {
return 0.5f;
}
*** 798,808 ****
}
/**
* Lays out the specified container using this grid bag layout.
* This method reshapes components in the specified container in
! * order to satisfy the constraints of this <code>GridBagLayout</code>
* object.
* <p>
* Most applications do not call this method directly.
* @param parent the container in which to do the layout
* @see java.awt.Container
--- 798,808 ----
}
/**
* Lays out the specified container using this grid bag layout.
* This method reshapes components in the specified container in
! * order to satisfy the constraints of this {@code GridBagLayout}
* object.
* <p>
* Most applications do not call this method directly.
* @param parent the container in which to do the layout
* @see java.awt.Container
*** 888,898 ****
* constraints.ipady);
* }
*/
/**
! * Fills in an instance of <code>GridBagLayoutInfo</code> for the
* current set of managed children. This requires three passes through the
* set of children:
*
* <ol>
* <li>Figure out the dimensions of the layout grid.
--- 888,898 ----
* constraints.ipady);
* }
*/
/**
! * Fills in an instance of {@code GridBagLayoutInfo} for the
* current set of managed children. This requires three passes through the
* set of children:
*
* <ol>
* <li>Figure out the dimensions of the layout grid.
*** 902,917 ****
*
* This also caches the minsizes for all the children when they are
* first encountered (so subsequent loops don't need to ask again).
* <p>
* This method should only be used internally by
! * <code>GridBagLayout</code>.
*
* @param parent the layout container
! * @param sizeflag either <code>PREFERREDSIZE</code> or
! * <code>MINSIZE</code>
! * @return the <code>GridBagLayoutInfo</code> for the set of children
* @since 1.4
*/
protected GridBagLayoutInfo getLayoutInfo(Container parent, int sizeflag) {
return GetLayoutInfo(parent, sizeflag);
}
--- 902,917 ----
*
* This also caches the minsizes for all the children when they are
* first encountered (so subsequent loops don't need to ask again).
* <p>
* This method should only be used internally by
! * {@code GridBagLayout}.
*
* @param parent the layout container
! * @param sizeflag either {@code PREFERREDSIZE} or
! * {@code MINSIZE}
! * @return the {@code GridBagLayoutInfo} for the set of children
* @since 1.4
*/
protected GridBagLayoutInfo getLayoutInfo(Container parent, int sizeflag) {
return GetLayoutInfo(parent, sizeflag);
}
*** 1603,1616 ****
/**
* Adjusts the x, y, width, and height fields to the correct
* values depending on the constraint geometry and pads.
* This method should only be used internally by
! * <code>GridBagLayout</code>.
*
* @param constraints the constraints to be applied
! * @param r the <code>Rectangle</code> to be adjusted
* @since 1.4
*/
protected void adjustForGravity(GridBagConstraints constraints,
Rectangle r) {
AdjustForGravity(constraints, r);
--- 1603,1616 ----
/**
* Adjusts the x, y, width, and height fields to the correct
* values depending on the constraint geometry and pads.
* This method should only be used internally by
! * {@code GridBagLayout}.
*
* @param constraints the constraints to be applied
! * @param r the {@code Rectangle} to be adjusted
* @since 1.4
*/
protected void adjustForGravity(GridBagConstraints constraints,
Rectangle r) {
AdjustForGravity(constraints, r);
*** 1622,1632 ****
* <p>
* This method is obsolete and supplied for backwards
* compatibility only; new code should call {@link
* #adjustForGravity(java.awt.GridBagConstraints, java.awt.Rectangle)
* adjustForGravity} instead.
! * This method is the same as <code>adjustForGravity</code>
*
* @param constraints the constraints to be applied
* @param r the {@code Rectangle} to be adjusted
*/
protected void AdjustForGravity(GridBagConstraints constraints,
--- 1622,1632 ----
* <p>
* This method is obsolete and supplied for backwards
* compatibility only; new code should call {@link
* #adjustForGravity(java.awt.GridBagConstraints, java.awt.Rectangle)
* adjustForGravity} instead.
! * This method is the same as {@code adjustForGravity}
*
* @param constraints the constraints to be applied
* @param r the {@code Rectangle} to be adjusted
*/
protected void AdjustForGravity(GridBagConstraints constraints,
*** 1985,2001 ****
}
}
/**
* Figures out the minimum size of the
! * master based on the information from <code>getLayoutInfo</code>.
* This method should only be used internally by
! * <code>GridBagLayout</code>.
*
* @param parent the layout container
* @param info the layout info for this parent
! * @return a <code>Dimension</code> object containing the
* minimum size
* @since 1.4
*/
protected Dimension getMinSize(Container parent, GridBagLayoutInfo info) {
return GetMinSize(parent, info);
--- 1985,2001 ----
}
}
/**
* Figures out the minimum size of the
! * master based on the information from {@code getLayoutInfo}.
* This method should only be used internally by
! * {@code GridBagLayout}.
*
* @param parent the layout container
* @param info the layout info for this parent
! * @return a {@code Dimension} object containing the
* minimum size
* @since 1.4
*/
protected Dimension getMinSize(Container parent, GridBagLayoutInfo info) {
return GetMinSize(parent, info);
*** 2003,2017 ****
/**
* This method is obsolete and supplied for backwards
* compatibility only; new code should call {@link
* #getMinSize(java.awt.Container, GridBagLayoutInfo) getMinSize} instead.
! * This method is the same as <code>getMinSize</code>
*
* @param parent the layout container
* @param info the layout info for this parent
! * @return a <code>Dimension</code> object containing the
* minimum size
*/
protected Dimension GetMinSize(Container parent, GridBagLayoutInfo info) {
Dimension d = new Dimension();
int i, t;
--- 2003,2017 ----
/**
* This method is obsolete and supplied for backwards
* compatibility only; new code should call {@link
* #getMinSize(java.awt.Container, GridBagLayoutInfo) getMinSize} instead.
! * This method is the same as {@code getMinSize}
*
* @param parent the layout container
* @param info the layout info for this parent
! * @return a {@code Dimension} object containing the
* minimum size
*/
protected Dimension GetMinSize(Container parent, GridBagLayoutInfo info) {
Dimension d = new Dimension();
int i, t;
*** 2033,2043 ****
transient boolean rightToLeft = false;
/**
* Lays out the grid.
* This method should only be used internally by
! * <code>GridBagLayout</code>.
*
* @param parent the layout container
* @since 1.4
*/
protected void arrangeGrid(Container parent) {
--- 2033,2043 ----
transient boolean rightToLeft = false;
/**
* Lays out the grid.
* This method should only be used internally by
! * {@code GridBagLayout}.
*
* @param parent the layout container
* @since 1.4
*/
protected void arrangeGrid(Container parent) {
*** 2046,2056 ****
/**
* This method is obsolete and supplied for backwards
* compatibility only; new code should call {@link
* #arrangeGrid(Container) arrangeGrid} instead.
! * This method is the same as <code>arrangeGrid</code>
*
* @param parent the layout container
*/
protected void ArrangeGrid(Container parent) {
Component comp;
--- 2046,2056 ----
/**
* This method is obsolete and supplied for backwards
* compatibility only; new code should call {@link
* #arrangeGrid(Container) arrangeGrid} instead.
! * This method is the same as {@code arrangeGrid}
*
* @param parent the layout container
*/
protected void ArrangeGrid(Container parent) {
Component comp;
< prev index next >