< prev index next >

src/java.desktop/share/classes/javax/swing/SpringLayout.java

Print this page

        

@@ -32,19 +32,19 @@
 import java.awt.LayoutManager2;
 import java.awt.Rectangle;
 import java.util.*;
 
 /**
- * A <code>SpringLayout</code> lays out the children of its associated container
+ * A {@code SpringLayout} lays out the children of its associated container
  * according to a set of constraints.
  * See <a href="http://docs.oracle.com/javase/tutorial/uiswing/layout/spring.html">How to Use SpringLayout</a>
  * in <em>The Java Tutorial</em> for examples of using
- * <code>SpringLayout</code>.
+ * {@code SpringLayout}.
  *
  * <p>
  * Each constraint,
- * represented by a <code>Spring</code> object,
+ * represented by a {@code Spring} object,
  * controls the vertical or horizontal distance
  * between two component edges.
  * The edges can belong to
  * any child of the container,
  * or to the container itself.

@@ -57,76 +57,76 @@
  * can be expressed by constraining the distance between
  * the north (top) edge of the component
  * and the north edge of its container.
  *
  * <P>
- * Every child of a <code>SpringLayout</code>-controlled container,
+ * Every child of a {@code SpringLayout}-controlled container,
  * as well as the container itself,
  * has exactly one set of constraints
  * associated with it.
  * These constraints are represented by
- * a <code>SpringLayout.Constraints</code> object.
+ * a {@code SpringLayout.Constraints} object.
  * By default,
- * <code>SpringLayout</code> creates constraints
+ * {@code SpringLayout} creates constraints
  * that make their associated component
  * have the minimum, preferred, and maximum sizes
  * returned by the component's
  * {@link java.awt.Component#getMinimumSize},
  * {@link java.awt.Component#getPreferredSize}, and
  * {@link java.awt.Component#getMaximumSize}
  * methods. The <em>x</em> and <em>y</em> positions are initially not
- * constrained, so that until you constrain them the <code>Component</code>
- * will be positioned at 0,0 relative to the <code>Insets</code> of the
- * parent <code>Container</code>.
+ * constrained, so that until you constrain them the {@code Component}
+ * will be positioned at 0,0 relative to the {@code Insets} of the
+ * parent {@code Container}.
  *
  * <p>
  * You can change
  * a component's constraints in several ways.
  * You can
  * use one of the
  * {@link #putConstraint putConstraint}
  * methods
  * to establish a spring
  * linking the edges of two components within the same container.
- * Or you can get the appropriate <code>SpringLayout.Constraints</code>
+ * Or you can get the appropriate {@code SpringLayout.Constraints}
  * object using
  * {@link #getConstraints getConstraints}
  * and then modify one or more of its springs.
  * Or you can get the spring for a particular edge of a component
  * using {@link #getConstraint getConstraint},
  * and modify it.
  * You can also associate
- * your own <code>SpringLayout.Constraints</code> object
+ * your own {@code SpringLayout.Constraints} object
  * with a component by specifying the constraints object
  * when you add the component to its container
  * (using
  * {@link Container#add(Component, Object)}).
  *
  * <p>
- * The <code>Spring</code> object representing each constraint
+ * The {@code Spring} object representing each constraint
  * has a minimum, preferred, maximum, and current value.
  * The current value of the spring
  * is somewhere between the minimum and maximum values,
  * according to the formula given in the
  * {@link Spring#sum} method description.
  * When the minimum, preferred, and maximum values are the same,
  * the current value is always equal to them;
  * this inflexible spring is called a <em>strut</em>.
  * You can create struts using the factory method
  * {@link Spring#constant(int)}.
- * The <code>Spring</code> class also provides factory methods
+ * The {@code Spring} class also provides factory methods
  * for creating other kinds of springs,
  * including springs that depend on other springs.
  *
  * <p>
- * In a <code>SpringLayout</code>, the position of each edge is dependent on
+ * In a {@code SpringLayout}, the position of each edge is dependent on
  * the position of just one other edge. If a constraint is subsequently added
  * to create a new binding for an edge, the previous binding is discarded
  * and the edge remains dependent on a single edge.
  * Springs should only be attached
  * between edges of the container and its immediate children; the behavior
- * of the <code>SpringLayout</code> when presented with constraints linking
+ * of the {@code SpringLayout} when presented with constraints linking
  * the edges of components from different containers (either internal or
  * external) is undefined.
  *
  * <h3>
  * SpringLayout vs. Other Layout Managers

@@ -134,48 +134,48 @@
  *
  * <blockquote>
  * <hr>
  * <strong>Note:</strong>
  * Unlike many layout managers,
- * <code>SpringLayout</code> doesn't automatically set the location of
+ * {@code SpringLayout} doesn't automatically set the location of
  * the components it manages.
- * If you hand-code a GUI that uses <code>SpringLayout</code>,
+ * If you hand-code a GUI that uses {@code SpringLayout},
  * remember to initialize component locations by constraining the west/east
  * and north/south locations.
  * <p>
  * Depending on the constraints you use,
  * you may also need to set the size of the container explicitly.
  * <hr>
  * </blockquote>
  *
  * <p>
- * Despite the simplicity of <code>SpringLayout</code>,
+ * Despite the simplicity of {@code SpringLayout},
  * it can emulate the behavior of most other layout managers.
  * For some features,
- * such as the line breaking provided by <code>FlowLayout</code>,
+ * such as the line breaking provided by {@code FlowLayout},
  * you'll need to
- * create a special-purpose subclass of the <code>Spring</code> class.
+ * create a special-purpose subclass of the {@code Spring} class.
  *
  * <p>
- * <code>SpringLayout</code> also provides a way to solve
+ * {@code SpringLayout} also provides a way to solve
  * many of the difficult layout
  * problems that cannot be solved by nesting combinations
- * of <code>Box</code>es. That said, <code>SpringLayout</code> honors the
- * <code>LayoutManager2</code> contract correctly and so can be nested with
+ * of {@code Box}es. That said, {@code SpringLayout} honors the
+ * {@code LayoutManager2} contract correctly and so can be nested with
  * other layout managers -- a technique that can be preferable to
  * creating the constraints implied by the other layout managers.
  * <p>
- * The asymptotic complexity of the layout operation of a <code>SpringLayout</code>
+ * The asymptotic complexity of the layout operation of a {@code SpringLayout}
  * is linear in the number of constraints (and/or components).
  * <p>
  * <strong>Warning:</strong>
  * Serialized objects of this class will not be compatible with
  * future Swing releases. The current serialization support is
  * appropriate for short term storage or RMI between applications running
  * the same version of Swing.  As of 1.4, support for long term storage
  * of all JavaBeans&trade;
- * has been added to the <code>java.beans</code> package.
+ * has been added to the {@code java.beans} package.
  * Please see {@link java.beans.XMLEncoder}.
  *
  * @see Spring
  * @see SpringLayout.Constraints
  *

@@ -251,29 +251,29 @@
     private static String[] ALL_HORIZONTAL = {WEST, WIDTH, EAST, HORIZONTAL_CENTER};
 
     private static String[] ALL_VERTICAL = {NORTH, HEIGHT, SOUTH, VERTICAL_CENTER, BASELINE};
 
     /**
-     * A <code>Constraints</code> object holds the
+     * A {@code Constraints} object holds the
      * constraints that govern the way a component's size and position
-     * change in a container controlled by a <code>SpringLayout</code>.
-     * A <code>Constraints</code> object is
-     * like a <code>Rectangle</code>, in that it
-     * has <code>x</code>, <code>y</code>,
-     * <code>width</code>, and <code>height</code> properties.
-     * In the <code>Constraints</code> object, however,
+     * change in a container controlled by a {@code SpringLayout}.
+     * A {@code Constraints} object is
+     * like a {@code Rectangle}, in that it
+     * has {@code x}, {@code y},
+     * {@code width}, and {@code height} properties.
+     * In the {@code Constraints} object, however,
      * these properties have
-     * <code>Spring</code> values instead of integers.
+     * {@code Spring} values instead of integers.
      * In addition,
-     * a <code>Constraints</code> object
+     * a {@code Constraints} object
      * can be manipulated as four edges
      * -- north, south, east, and west --
-     * using the <code>constraint</code> property.
+     * using the {@code constraint} property.
      *
      * <p>
      * The following formulas are always true
-     * for a <code>Constraints</code> object (here WEST and <code>x</code> are synonyms, as are and NORTH and <code>y</code>):
+     * for a {@code Constraints} object (here WEST and {@code x} are synonyms, as are and NORTH and {@code y}):
      *
      * <pre>
      *               EAST = WEST + WIDTH
      *              SOUTH = NORTH + HEIGHT
      *  HORIZONTAL_CENTER = WEST + WIDTH/2

@@ -290,30 +290,30 @@
      * the SpringLayout.Constraints(Component) constructor is called or when
      * a constraints object is registered with a SpringLayout object.]
      * <p>
      * <b>Note</b>: In this document,
      * operators represent methods
-     * in the <code>Spring</code> class.
+     * in the {@code Spring} class.
      * For example, "a + b" is equal to
-     * <code>Spring.sum(a, b)</code>,
+     * {@code Spring.sum(a, b)},
      * and "a - b" is equal to
-     * <code>Spring.sum(a, Spring.minus(b))</code>.
+     * {@code Spring.sum(a, Spring.minus(b))}.
      * See the
      * {@link Spring Spring API documentation}
      * for further details
      * of spring arithmetic.
      *
      * <p>
      *
-     * Because a <code>Constraints</code> object's properties --
+     * Because a {@code Constraints} object's properties --
      * representing its edges, size, and location -- can all be set
      * independently and yet are interrelated,
-     * a <code>Constraints</code> object can become <em>over-constrained</em>.
-     * For example, if the <code>WEST</code>, <code>WIDTH</code> and
-     * <code>EAST</code> edges are all set, steps must be taken to ensure that
+     * a {@code Constraints} object can become <em>over-constrained</em>.
+     * For example, if the {@code WEST}, {@code WIDTH} and
+     * {@code EAST} edges are all set, steps must be taken to ensure that
      * the first of the formulas above holds.  To do this, the
-     * <code>Constraints</code>
+     * {@code Constraints}
      * object throws away the <em>least recently set</em>
      * constraint so as to make the formulas hold.
      * @since 1.4
      */
     public static class Constraints {

@@ -332,66 +332,66 @@
 
         // Used for baseline calculations
         private Component c;
 
        /**
-        * Creates an empty <code>Constraints</code> object.
+        * Creates an empty {@code Constraints} object.
         */
        public Constraints() {
        }
 
        /**
-        * Creates a <code>Constraints</code> object with the
+        * Creates a {@code Constraints} object with the
         * specified values for its
-        * <code>x</code> and <code>y</code> properties.
-        * The <code>height</code> and <code>width</code> springs
-        * have <code>null</code> values.
+        * {@code x} and {@code y} properties.
+        * The {@code height} and {@code width} springs
+        * have {@code null} values.
         *
         * @param x  the spring controlling the component's <em>x</em> value
         * @param y  the spring controlling the component's <em>y</em> value
         */
        public Constraints(Spring x, Spring y) {
            setX(x);
            setY(y);
        }
 
        /**
-        * Creates a <code>Constraints</code> object with the
+        * Creates a {@code Constraints} object with the
         * specified values for its
-        * <code>x</code>, <code>y</code>, <code>width</code>,
-        * and <code>height</code> properties.
-        * Note: If the <code>SpringLayout</code> class
-        * encounters <code>null</code> values in the
-        * <code>Constraints</code> object of a given component,
+        * {@code x}, {@code y}, {@code width},
+        * and {@code height} properties.
+        * Note: If the {@code SpringLayout} class
+        * encounters {@code null} values in the
+        * {@code Constraints} object of a given component,
         * it replaces them with suitable defaults.
         *
-        * @param x  the spring value for the <code>x</code> property
-        * @param y  the spring value for the <code>y</code> property
-        * @param width  the spring value for the <code>width</code> property
-        * @param height  the spring value for the <code>height</code> property
+        * @param x  the spring value for the {@code x} property
+        * @param y  the spring value for the {@code y} property
+        * @param width  the spring value for the {@code width} property
+        * @param height  the spring value for the {@code height} property
         */
        public Constraints(Spring x, Spring y, Spring width, Spring height) {
            setX(x);
            setY(y);
            setWidth(width);
            setHeight(height);
        }
 
         /**
-         * Creates a <code>Constraints</code> object with
-         * suitable <code>x</code>, <code>y</code>, <code>width</code> and
-         * <code>height</code> springs for component, <code>c</code>.
-         * The <code>x</code> and <code>y</code> springs are constant
+         * Creates a {@code Constraints} object with
+         * suitable {@code x}, {@code y}, {@code width} and
+         * {@code height} springs for component, {@code c}.
+         * The {@code x} and {@code y} springs are constant
          * springs  initialised with the component's location at
-         * the time this method is called. The <code>width</code> and
-         * <code>height</code> springs are special springs, created by
-         * the <code>Spring.width()</code> and <code>Spring.height()</code>
+         * the time this method is called. The {@code width} and
+         * {@code height} springs are special springs, created by
+         * the {@code Spring.width()} and {@code Spring.height()}
          * methods, which track the size characteristics of the component
          * when they change.
          *
          * @param c  the component whose characteristics will be reflected by this Constraints object
-         * @throws NullPointerException if <code>c</code> is null.
+         * @throws NullPointerException if {@code c} is null.
          * @since 1.5
          */
         public Constraints(Component c) {
             this.c = c;
             setX(Spring.constant(c.getX()));

@@ -498,15 +498,15 @@
         private boolean defined(List<?> history, String s1, String s2) {
             return history.contains(s1) && history.contains(s2);
         }
 
        /**
-        * Sets the <code>x</code> property,
-        * which controls the <code>x</code> value
+        * Sets the {@code x} property,
+        * which controls the {@code x} value
         * of a component's location.
         *
-        * @param x the spring controlling the <code>x</code> value
+        * @param x the spring controlling the {@code x} value
         *          of a component's location
         *
         * @see #getX
         * @see SpringLayout.Constraints
         */

@@ -514,13 +514,13 @@
            this.x = x;
            pushConstraint(WEST, x, true);
        }
 
        /**
-        * Returns the value of the <code>x</code> property.
+        * Returns the value of the {@code x} property.
         *
-        * @return the spring controlling the <code>x</code> value
+        * @return the spring controlling the {@code x} value
         *         of a component's location
         *
         * @see #setX
         * @see SpringLayout.Constraints
         */

@@ -536,15 +536,15 @@
            }
            return x;
        }
 
        /**
-        * Sets the <code>y</code> property,
-        * which controls the <code>y</code> value
+        * Sets the {@code y} property,
+        * which controls the {@code y} value
         * of a component's location.
         *
-        * @param y the spring controlling the <code>y</code> value
+        * @param y the spring controlling the {@code y} value
         *          of a component's location
         *
         * @see #getY
         * @see SpringLayout.Constraints
         */

@@ -552,13 +552,13 @@
            this.y = y;
            pushConstraint(NORTH, y, false);
        }
 
        /**
-        * Returns the value of the <code>y</code> property.
+        * Returns the value of the {@code y} property.
         *
-        * @return the spring controlling the <code>y</code> value
+        * @return the spring controlling the {@code y} value
         *         of a component's location
         *
         * @see #setY
         * @see SpringLayout.Constraints
         */

@@ -582,26 +582,26 @@
            }
            return y;
        }
 
        /**
-        * Sets the <code>width</code> property,
+        * Sets the {@code width} property,
         * which controls the width of a component.
         *
         * @param width the spring controlling the width of this
-        * <code>Constraints</code> object
+        * {@code Constraints} object
         *
         * @see #getWidth
         * @see SpringLayout.Constraints
         */
        public void setWidth(Spring width) {
            this.width = width;
            pushConstraint(WIDTH, width, true);
        }
 
        /**
-        * Returns the value of the <code>width</code> property.
+        * Returns the value of the {@code width} property.
         *
         * @return the spring controlling the width of a component
         *
         * @see #setWidth
         * @see SpringLayout.Constraints

@@ -616,14 +616,14 @@
            }
            return width;
        }
 
        /**
-        * Sets the <code>height</code> property,
+        * Sets the {@code height} property,
         * which controls the height of a component.
         *
-        * @param height the spring controlling the height of this <code>Constraints</code>
+        * @param height the spring controlling the height of this {@code Constraints}
         * object
         *
         * @see #getHeight
         * @see SpringLayout.Constraints
         */

@@ -631,11 +631,11 @@
            this.height = height;
            pushConstraint(HEIGHT, height, false);
        }
 
        /**
-        * Returns the value of the <code>height</code> property.
+        * Returns the value of the {@code height} property.
         *
         * @return the spring controlling the height of a component
         *
         * @see #setHeight
         * @see SpringLayout.Constraints

@@ -714,30 +714,30 @@
         }
 
        /**
         * Sets the spring controlling the specified edge.
         * The edge must have one of the following values:
-        * <code>SpringLayout.NORTH</code>,
-        * <code>SpringLayout.SOUTH</code>,
-        * <code>SpringLayout.EAST</code>,
-        * <code>SpringLayout.WEST</code>,
-        * <code>SpringLayout.HORIZONTAL_CENTER</code>,
-        * <code>SpringLayout.VERTICAL_CENTER</code>,
-        * <code>SpringLayout.BASELINE</code>,
-        * <code>SpringLayout.WIDTH</code> or
-        * <code>SpringLayout.HEIGHT</code>.
-        * For any other <code>String</code> value passed as the edge,
-        * no action is taken. For a <code>null</code> edge, a
-        * <code>NullPointerException</code> is thrown.
+        * {@code SpringLayout.NORTH},
+        * {@code SpringLayout.SOUTH},
+        * {@code SpringLayout.EAST},
+        * {@code SpringLayout.WEST},
+        * {@code SpringLayout.HORIZONTAL_CENTER},
+        * {@code SpringLayout.VERTICAL_CENTER},
+        * {@code SpringLayout.BASELINE},
+        * {@code SpringLayout.WIDTH} or
+        * {@code SpringLayout.HEIGHT}.
+        * For any other {@code String} value passed as the edge,
+        * no action is taken. For a {@code null} edge, a
+        * {@code NullPointerException} is thrown.
         * <p>
         * <b>Note:</b> This method can affect {@code x} and {@code y} values
         * previously set for this {@code Constraints}.
         *
         * @param edgeName the edge to be set
         * @param s the spring controlling the specified edge
         *
-        * @throws NullPointerException if <code>edgeName</code> is <code>null</code>
+        * @throws NullPointerException if {@code edgeName} is {@code null}
         *
         * @see #getConstraint
         * @see #NORTH
         * @see #SOUTH
         * @see #EAST

@@ -772,31 +772,31 @@
            }
        }
 
        /**
         * Returns the value of the specified edge, which may be
-        * a derived value, or even <code>null</code>.
+        * a derived value, or even {@code null}.
         * The edge must have one of the following values:
-        * <code>SpringLayout.NORTH</code>,
-        * <code>SpringLayout.SOUTH</code>,
-        * <code>SpringLayout.EAST</code>,
-        * <code>SpringLayout.WEST</code>,
-        * <code>SpringLayout.HORIZONTAL_CENTER</code>,
-        * <code>SpringLayout.VERTICAL_CENTER</code>,
-        * <code>SpringLayout.BASELINE</code>,
-        * <code>SpringLayout.WIDTH</code> or
-        * <code>SpringLayout.HEIGHT</code>.
-        * For any other <code>String</code> value passed as the edge,
-        * <code>null</code> will be returned. Throws
-        * <code>NullPointerException</code> for a <code>null</code> edge.
+        * {@code SpringLayout.NORTH},
+        * {@code SpringLayout.SOUTH},
+        * {@code SpringLayout.EAST},
+        * {@code SpringLayout.WEST},
+        * {@code SpringLayout.HORIZONTAL_CENTER},
+        * {@code SpringLayout.VERTICAL_CENTER},
+        * {@code SpringLayout.BASELINE},
+        * {@code SpringLayout.WIDTH} or
+        * {@code SpringLayout.HEIGHT}.
+        * For any other {@code String} value passed as the edge,
+        * {@code null} will be returned. Throws
+        * {@code NullPointerException} for a {@code null} edge.
         *
         * @param edgeName the edge whose value
         *                 is to be returned
         *
-        * @return the spring controlling the specified edge, may be <code>null</code>
+        * @return the spring controlling the specified edge, may be {@code null}
         *
-        * @throws NullPointerException if <code>edgeName</code> is <code>null</code>
+        * @throws NullPointerException if {@code edgeName} is {@code null}
         *
         * @see #setConstraint
         * @see #NORTH
         * @see #SOUTH
         * @see #EAST

@@ -876,11 +876,11 @@
            return "SpringProxy for " + edgeName + " edge of " + c.getName() + ".";
        }
     }
 
     /**
-     * Constructs a new <code>SpringLayout</code>.
+     * Constructs a new {@code SpringLayout}.
      */
     public SpringLayout() {}
 
     private void resetCyclicStatuses() {
         cyclicSprings = new HashSet<Spring>();

@@ -986,12 +986,12 @@
                          abandonCycles(pc.getHeight()).getMaximumValue(),
                          parent);
     }
 
     /**
-     * If <code>constraints</code> is an instance of
-     * <code>SpringLayout.Constraints</code>,
+     * If {@code constraints} is an instance of
+     * {@code SpringLayout.Constraints},
      * associates the constraints with the specified component.
      *
      * @param   component the component being added
      * @param   constraints the component's constraints
      *

@@ -1020,12 +1020,12 @@
     public void invalidateLayout(Container p) {}
 
     // End of LayoutManger2 methods
 
    /**
-     * Links edge <code>e1</code> of component <code>c1</code> to
-     * edge <code>e2</code> of component <code>c2</code>,
+     * Links edge {@code e1} of component {@code c1} to
+     * edge {@code e2} of component {@code c2},
      * with a fixed distance between the edges. This
      * constraint will cause the assignment
      * <pre>
      *     value(e1, c1) = value(e2, c2) + pad</pre>
      * to take place during all subsequent layout operations.

@@ -1041,23 +1041,23 @@
     public void putConstraint(String e1, Component c1, int pad, String e2, Component c2) {
         putConstraint(e1, c1, Spring.constant(pad), e2, c2);
     }
 
     /**
-     * Links edge <code>e1</code> of component <code>c1</code> to
-     * edge <code>e2</code> of component <code>c2</code>. As edge
-     * <code>(e2, c2)</code> changes value, edge <code>(e1, c1)</code> will
-     * be calculated by taking the (spring) sum of <code>(e2, c2)</code>
-     * and <code>s</code>.
+     * Links edge {@code e1} of component {@code c1} to
+     * edge {@code e2} of component {@code c2}. As edge
+     * {@code (e2, c2)} changes value, edge {@code (e1, c1)} will
+     * be calculated by taking the (spring) sum of {@code (e2, c2)}
+     * and {@code s}.
      * Each edge must have one of the following values:
-     * <code>SpringLayout.NORTH</code>,
-     * <code>SpringLayout.SOUTH</code>,
-     * <code>SpringLayout.EAST</code>,
-     * <code>SpringLayout.WEST</code>,
-     * <code>SpringLayout.VERTICAL_CENTER</code>,
-     * <code>SpringLayout.HORIZONTAL_CENTER</code> or
-     * <code>SpringLayout.BASELINE</code>.
+     * {@code SpringLayout.NORTH},
+     * {@code SpringLayout.SOUTH},
+     * {@code SpringLayout.EAST},
+     * {@code SpringLayout.WEST},
+     * {@code SpringLayout.VERTICAL_CENTER},
+     * {@code SpringLayout.HORIZONTAL_CENTER} or
+     * {@code SpringLayout.BASELINE}.
      *
      * @param   e1 the edge of the dependent
      * @param   c1 the component of the dependent
      * @param   s the spring linking dependent and anchor
      * @param   e2 the edge of the anchor

@@ -1125,12 +1125,12 @@
     }
 
     /**
      * Returns the constraints for the specified component.
      * Note that,
-     * unlike the <code>GridBagLayout</code>
-     * <code>getConstraints</code> method,
+     * unlike the {@code GridBagLayout}
+     * {@code getConstraints} method,
      * this method does not clone constraints.
      * If no constraints
      * have been associated with this component,
      * this method
      * returns a default constraints object positioned at

@@ -1171,21 +1171,21 @@
      * Proxies are intended to be used in builder environments
      * where it is useful to allow the user to define the
      * constraints for a layout in any order. Proxies do, however,
      * provide the means to create cyclic dependencies amongst
      * the constraints of a layout. Such cycles are detected
-     * internally by <code>SpringLayout</code> so that
+     * internally by {@code SpringLayout} so that
      * the layout operation always terminates.
      *
      * @param edgeName must be one of
-     * <code>SpringLayout.NORTH</code>,
-     * <code>SpringLayout.SOUTH</code>,
-     * <code>SpringLayout.EAST</code>,
-     * <code>SpringLayout.WEST</code>,
-     * <code>SpringLayout.VERTICAL_CENTER</code>,
-     * <code>SpringLayout.HORIZONTAL_CENTER</code> or
-     * <code>SpringLayout.BASELINE</code>
+     * {@code SpringLayout.NORTH},
+     * {@code SpringLayout.SOUTH},
+     * {@code SpringLayout.EAST},
+     * {@code SpringLayout.WEST},
+     * {@code SpringLayout.VERTICAL_CENTER},
+     * {@code SpringLayout.HORIZONTAL_CENTER} or
+     * {@code SpringLayout.BASELINE}
      * @param c the component whose edge spring is desired
      *
      * @return a proxy for the spring controlling the distance between the
      *         specified edge and the top or left edge of its parent
      *
< prev index next >