< prev index next >
src/java.desktop/share/classes/java/awt/GridBagLayout.java
Print this page
@@ -26,22 +26,22 @@
import java.util.Hashtable;
import java.util.Arrays;
/**
- * The <code>GridBagLayout</code> class is a flexible layout
+ * 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</code> object maintains a dynamic,
+ * 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</code> is associated with
+ * 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</code> also
+ * 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,12 +50,12 @@
* 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>
+ * 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,64 +63,64 @@
* 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)
+ * Use {@code GridBagConstraints.RELATIVE} (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
+ * (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</code>)
- * or column (for <code>gridheight</code>)
+ * <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</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>).
+ * 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</code> (the default),
- * <code>GridBagConstraints.HORIZONTAL</code>
+ * {@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</code>
+ * {@code GridBagConstraints.VERTICAL}
* (make the component tall enough to fill its display area
* vertically, but don't change its width), and
- * <code>GridBagConstraints.BOTH</code>
+ * {@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</code> pixels. Similarly, the height of
+ * plus {@code ipadx} pixels. Similarly, the height of
* the component will be at least the minimum height plus
- * <code>ipady</code> pixels.
+ * {@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</code> property while absolute values
+ * {@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,57 +130,57 @@
* <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>
+ * <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</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>
+ * <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</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>
+ * <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</code>) and column (<code>weighty</code>),
+ * 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</code> object puts any extra space
+ * 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,26 +204,26 @@
* 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
+ * 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</code> and an anchor of <code>BASELINE</code>.
+ * {@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</code>,
+ * 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,16 +231,16 @@
* 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
+ * 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</code>
+ * 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,13 +264,13 @@
* <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>.
+ * 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,12 +385,12 @@
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>.
+ * 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,11 +398,11 @@
/**
* 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>.
+ * copy of the {@code defaultConstraints}.
*
* @serial
* @see #getConstraints(Component)
* @see #setConstraints(Component, GridBagConstraints)
* @see #lookupConstraints(Component)
@@ -412,11 +412,11 @@
/**
* 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>
+ * 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,11 +424,11 @@
*/
protected GridBagLayoutInfo layoutInfo;
/**
* This field holds the overrides to the column minimum
- * width. If this field is non-<code>null</code> the values are
+ * 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,55 +438,55 @@
*/
public int columnWidths[];
/**
* This field holds the overrides to the row minimum
- * heights. If this field is non-<code>null</code> the values are
+ * 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</code> has more elements than the number of
+ * 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</code>.
+ * 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</code> the values are
+ * 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]</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
+ * 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</code> the values are
+ * 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]</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
+ * 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</code>.
+ * {@code adjustForGravity}.
*/
private Component componentAdjusting;
/**
* Creates a grid bag layout manager.
@@ -505,11 +505,11 @@
comptable.put(comp, (GridBagConstraints)constraints.clone());
}
/**
* Gets the constraints for the specified component. A copy of
- * the actual <code>GridBagConstraints</code> object is returned.
+ * 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,16 +523,16 @@
}
/**
* 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.
+ * {@code GridBagConstraints} 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>.
+ * 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,11 +554,11 @@
/**
* 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
+ * 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,20 +629,20 @@
* 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
+ * 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</code> lies
+ * 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</code> lies above the
- * layout, and as the number of rows if <code>y</code> lies
+ * 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</code> property.
+ * {@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,18 +690,18 @@
public void addLayoutComponent(String name, Component comp) {
}
/**
* Adds the specified component to the layout, using the specified
- * <code>constraints</code> object. Note that constraints
+ * {@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</code>
- * is not a <code>GridBagConstraint</code>
+ * @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,33 +720,33 @@
public void removeLayoutComponent(Component comp) {
removeConstraints(comp);
}
/**
- * Determines the preferred size of the <code>parent</code>
+ * 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</code>
+ * @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</code> container
+ * 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</code> container
+ * @return the minimum size of the {@code parent} container
*/
public Dimension minimumLayoutSize(Container parent) {
GridBagLayoutInfo info = getLayoutInfo(parent, MINSIZE);
return getMinSize(parent, info);
}
@@ -769,11 +769,11 @@
* 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
+ * @return the value {@code 0.5f} to indicate centered
*/
public float getLayoutAlignmentX(Container parent) {
return 0.5f;
}
@@ -782,11 +782,11 @@
* 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
+ * @return the value {@code 0.5f} to indicate centered
*/
public float getLayoutAlignmentY(Container parent) {
return 0.5f;
}
@@ -798,11 +798,11 @@
}
/**
* 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>
+ * 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,11 +888,11 @@
* constraints.ipady);
* }
*/
/**
- * Fills in an instance of <code>GridBagLayoutInfo</code> for the
+ * 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,16 +902,16 @@
*
* 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>.
+ * {@code GridBagLayout}.
*
* @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
+ * @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,14 +1603,14 @@
/**
* 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>.
+ * {@code GridBagLayout}.
*
* @param constraints the constraints to be applied
- * @param r the <code>Rectangle</code> to be adjusted
+ * @param r the {@code Rectangle} to be adjusted
* @since 1.4
*/
protected void adjustForGravity(GridBagConstraints constraints,
Rectangle r) {
AdjustForGravity(constraints, r);
@@ -1622,11 +1622,11 @@
* <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>
+ * 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,17 +1985,17 @@
}
}
/**
* Figures out the minimum size of the
- * master based on the information from <code>getLayoutInfo</code>.
+ * master based on the information from {@code getLayoutInfo}.
* This method should only be used internally by
- * <code>GridBagLayout</code>.
+ * {@code GridBagLayout}.
*
* @param parent the layout container
* @param info the layout info for this parent
- * @return a <code>Dimension</code> object containing the
+ * @return a {@code Dimension} object containing the
* minimum size
* @since 1.4
*/
protected Dimension getMinSize(Container parent, GridBagLayoutInfo info) {
return GetMinSize(parent, info);
@@ -2003,15 +2003,15 @@
/**
* 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>
+ * 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</code> object containing the
+ * @return a {@code Dimension} object containing the
* minimum size
*/
protected Dimension GetMinSize(Container parent, GridBagLayoutInfo info) {
Dimension d = new Dimension();
int i, t;
@@ -2033,11 +2033,11 @@
transient boolean rightToLeft = false;
/**
* Lays out the grid.
* This method should only be used internally by
- * <code>GridBagLayout</code>.
+ * {@code GridBagLayout}.
*
* @param parent the layout container
* @since 1.4
*/
protected void arrangeGrid(Container parent) {
@@ -2046,11 +2046,11 @@
/**
* 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>
+ * This method is the same as {@code arrangeGrid}
*
* @param parent the layout container
*/
protected void ArrangeGrid(Container parent) {
Component comp;
< prev index next >