< 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&nbsp;=&nbsp;0</code>,
  * <code>gridy&nbsp;=&nbsp;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&nbsp;=&nbsp;1.0</code>
  * <li>Button4: <code>weightx&nbsp;=&nbsp;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> &gt; 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> &gt; 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,&nbsp;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>,&nbsp;<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 >