< prev index next >

src/java.desktop/share/classes/java/awt/BorderLayout.java

Print this page

        

@@ -31,68 +31,68 @@
  * A border layout lays out a container, arranging and resizing
  * its components to fit in five regions:
  * north, south, east, west, and center.
  * Each region may contain no more than one component, and
  * is identified by a corresponding constant:
- * <code>NORTH</code>, <code>SOUTH</code>, <code>EAST</code>,
- * <code>WEST</code>, and <code>CENTER</code>.  When adding a
+ * {@code NORTH}, {@code SOUTH}, {@code EAST},
+ * {@code WEST}, and {@code CENTER}.  When adding a
  * component to a container with a border layout, use one of these
  * five constants, for example:
  * <pre>
  *    Panel p = new Panel();
  *    p.setLayout(new BorderLayout());
  *    p.add(new Button("Okay"), BorderLayout.SOUTH);
  * </pre>
- * As a convenience, <code>BorderLayout</code> interprets the
+ * As a convenience, {@code BorderLayout} interprets the
  * absence of a string specification the same as the constant
- * <code>CENTER</code>:
+ * {@code CENTER}:
  * <pre>
  *    Panel p2 = new Panel();
  *    p2.setLayout(new BorderLayout());
  *    p2.add(new TextArea());  // Same as p.add(new TextArea(), BorderLayout.CENTER);
  * </pre>
  * <p>
- * In addition, <code>BorderLayout</code> supports the relative
- * positioning constants, <code>PAGE_START</code>, <code>PAGE_END</code>,
- * <code>LINE_START</code>, and <code>LINE_END</code>.
- * In a container whose <code>ComponentOrientation</code> is set to
- * <code>ComponentOrientation.LEFT_TO_RIGHT</code>, these constants map to
- * <code>NORTH</code>, <code>SOUTH</code>, <code>WEST</code>, and
- * <code>EAST</code>, respectively.
- * <p>
- * For compatibility with previous releases, <code>BorderLayout</code>
- * also includes the relative positioning constants <code>BEFORE_FIRST_LINE</code>,
- * <code>AFTER_LAST_LINE</code>, <code>BEFORE_LINE_BEGINS</code> and
- * <code>AFTER_LINE_ENDS</code>.  These are equivalent to
- * <code>PAGE_START</code>, <code>PAGE_END</code>, <code>LINE_START</code>
- * and <code>LINE_END</code> respectively.  For
+ * In addition, {@code BorderLayout} supports the relative
+ * positioning constants, {@code PAGE_START}, {@code PAGE_END},
+ * {@code LINE_START}, and {@code LINE_END}.
+ * In a container whose {@code ComponentOrientation} is set to
+ * {@code ComponentOrientation.LEFT_TO_RIGHT}, these constants map to
+ * {@code NORTH}, {@code SOUTH}, {@code WEST}, and
+ * {@code EAST}, respectively.
+ * <p>
+ * For compatibility with previous releases, {@code BorderLayout}
+ * also includes the relative positioning constants {@code BEFORE_FIRST_LINE},
+ * {@code AFTER_LAST_LINE}, {@code BEFORE_LINE_BEGINS} and
+ * {@code AFTER_LINE_ENDS}.  These are equivalent to
+ * {@code PAGE_START}, {@code PAGE_END}, {@code LINE_START}
+ * and {@code LINE_END} respectively.  For
  * consistency with the relative positioning constants used by other
  * components, the latter constants are preferred.
  * <p>
  * Mixing both absolute and relative positioning constants can lead to
  * unpredictable results.  If
  * you use both types, the relative constants will take precedence.
- * For example, if you add components using both the <code>NORTH</code>
- * and <code>PAGE_START</code> constants in a container whose
- * orientation is <code>LEFT_TO_RIGHT</code>, only the
- * <code>PAGE_START</code> will be laid out.
+ * For example, if you add components using both the {@code NORTH}
+ * and {@code PAGE_START} constants in a container whose
+ * orientation is {@code LEFT_TO_RIGHT}, only the
+ * {@code PAGE_START} will be laid out.
  * <p>
  * NOTE: Currently (in the Java 2 platform v1.2),
- * <code>BorderLayout</code> does not support vertical
- * orientations.  The <code>isVertical</code> setting on the container's
- * <code>ComponentOrientation</code> is not respected.
+ * {@code BorderLayout} does not support vertical
+ * orientations.  The {@code isVertical} setting on the container's
+ * {@code ComponentOrientation} is not respected.
  * <p>
  * The components are laid out according to their
  * preferred sizes and the constraints of the container's size.
- * The <code>NORTH</code> and <code>SOUTH</code> components may
- * be stretched horizontally; the <code>EAST</code> and
- * <code>WEST</code> components may be stretched vertically;
- * the <code>CENTER</code> component may stretch both horizontally
+ * The {@code NORTH} and {@code SOUTH} components may
+ * be stretched horizontally; the {@code EAST} and
+ * {@code WEST} components may be stretched vertically;
+ * the {@code CENTER} component may stretch both horizontally
  * and vertically to fill any space left over.
  * <p>
  * Here is an example of five buttons in an applet laid out using
- * the <code>BorderLayout</code> layout manager:
+ * the {@code BorderLayout} layout manager:
  * <p>
  * <img src="doc-files/BorderLayout-1.gif"
  * alt="Diagram of an applet demonstrating BorderLayout.
  *      Each section of the BorderLayout contains a Button corresponding to its position in the layout, one of:
  *      North, West, Center, East, or South."

@@ -124,11 +124,11 @@
 public class BorderLayout implements LayoutManager2,
                                      java.io.Serializable {
     /**
      * Constructs a border layout with the horizontal gaps
      * between components.
-     * The horizontal gap is specified by <code>hgap</code>.
+     * The horizontal gap is specified by {@code hgap}.
      *
      * @see #getHgap()
      * @see #setHgap(int)
      *
      * @serial

@@ -136,11 +136,11 @@
         int hgap;
 
     /**
      * Constructs a border layout with the vertical gaps
      * between components.
-     * The vertical gap is specified by <code>vgap</code>.
+     * The vertical gap is specified by {@code vgap}.
      *
      * @see #getVgap()
      * @see #setVgap(int)
      * @serial
      */

@@ -206,14 +206,14 @@
      *
      * A relative positioning constant, that can be used instead of
      * north, south, east, west or center.
      * mixing the two types of constants can lead to unpredictable results.  If
      * you use both types, the relative constants will take precedence.
-     * For example, if you add components using both the <code>NORTH</code>
-     * and <code>BEFORE_FIRST_LINE</code> constants in a container whose
-     * orientation is <code>LEFT_TO_RIGHT</code>, only the
-     * <code>BEFORE_FIRST_LINE</code> will be laid out.
+     * For example, if you add components using both the {@code NORTH}
+     * and {@code BEFORE_FIRST_LINE} constants in a container whose
+     * orientation is {@code LEFT_TO_RIGHT}, only the
+     * {@code BEFORE_FIRST_LINE} will be laid out.
      * This will be the same for lastLine, firstItem, lastItem.
      * @serial
      */
     Component firstLine;
      /**

@@ -353,12 +353,12 @@
     }
 
     /**
      * Constructs a border layout with the specified gaps
      * between components.
-     * The horizontal gap is specified by <code>hgap</code>
-     * and the vertical gap is specified by <code>vgap</code>.
+     * The horizontal gap is specified by {@code hgap}
+     * and the vertical gap is specified by {@code vgap}.
      * @param   hgap   the horizontal gap.
      * @param   vgap   the vertical gap.
      */
     public BorderLayout(int hgap, int vgap) {
         this.hgap = hgap;

@@ -406,17 +406,17 @@
     }
 
     /**
      * Adds the specified component to the layout, using the specified
      * constraint object.  For border layouts, the constraint must be
-     * one of the following constants:  <code>NORTH</code>,
-     * <code>SOUTH</code>, <code>EAST</code>,
-     * <code>WEST</code>, or <code>CENTER</code>.
+     * one of the following constants:  {@code NORTH},
+     * {@code SOUTH}, {@code EAST},
+     * {@code WEST}, or {@code CENTER}.
      * <p>
      * Most applications do not call this method directly. This method
      * is called when a component is added to a container using the
-     * <code>Container.add</code> method with the same argument types.
+     * {@code Container.add} method with the same argument types.
      * @param   comp         the component to be added.
      * @param   constraints  an object that specifies how and where
      *                       the component is added to the layout.
      * @see     java.awt.Container#add(java.awt.Component, java.lang.Object)
      * @exception   IllegalArgumentException  if the constraint object is not

@@ -432,11 +432,11 @@
         }
       }
     }
 
     /**
-     * @deprecated  replaced by <code>addLayoutComponent(Component, Object)</code>.
+     * @deprecated  replaced by {@code addLayoutComponent(Component, Object)}.
      */
     @Deprecated
     public void addLayoutComponent(String name, Component comp) {
       synchronized (comp.getTreeLock()) {
         /* Special case:  treat null the same as "Center". */

@@ -470,12 +470,12 @@
       }
     }
 
     /**
      * Removes the specified component from this border layout. This
-     * method is called when a container calls its <code>remove</code> or
-     * <code>removeAll</code> methods. Most applications do not call this
+     * method is called when a container calls its {@code remove} or
+     * {@code removeAll} methods. Most applications do not call this
      * method directly.
      * @param   comp   the component to be removed.
      * @see     java.awt.Container#remove(java.awt.Component)
      * @see     java.awt.Container#removeAll()
      */

@@ -505,16 +505,16 @@
     }
 
     /**
      * Gets the component that was added using the given constraint
      *
-     * @param   constraints  the desired constraint, one of <code>CENTER</code>,
-     *                       <code>NORTH</code>, <code>SOUTH</code>,
-     *                       <code>WEST</code>, <code>EAST</code>,
-     *                       <code>PAGE_START</code>, <code>PAGE_END</code>,
-     *                       <code>LINE_START</code>, <code>LINE_END</code>
-     * @return  the component at the given location, or <code>null</code> if
+     * @param   constraints  the desired constraint, one of {@code CENTER},
+     *                       {@code NORTH}, {@code SOUTH},
+     *                       {@code WEST}, {@code EAST},
+     *                       {@code PAGE_START}, {@code PAGE_END},
+     *                       {@code LINE_START}, {@code LINE_END}
+     * @return  the component at the given location, or {@code null} if
      *          the location is empty
      * @exception   IllegalArgumentException  if the constraint object is
      *              not one of the nine specified constants
      * @see     #addLayoutComponent(java.awt.Component, java.lang.Object)
      * @since 1.5

@@ -544,25 +544,25 @@
     }
 
 
     /**
      * Returns the component that corresponds to the given constraint location
-     * based on the target <code>Container</code>'s component orientation.
-     * Components added with the relative constraints <code>PAGE_START</code>,
-     * <code>PAGE_END</code>, <code>LINE_START</code>, and <code>LINE_END</code>
+     * based on the target {@code Container}'s component orientation.
+     * Components added with the relative constraints {@code PAGE_START},
+     * {@code PAGE_END}, {@code LINE_START}, and {@code LINE_END}
      * take precedence over components added with the explicit constraints
-     * <code>NORTH</code>, <code>SOUTH</code>, <code>WEST</code>, and <code>EAST</code>.
-     * The <code>Container</code>'s component orientation is used to determine the location of components
-     * added with <code>LINE_START</code> and <code>LINE_END</code>.
-     *
-     * @param   constraints     the desired absolute position, one of <code>CENTER</code>,
-     *                          <code>NORTH</code>, <code>SOUTH</code>,
-     *                          <code>EAST</code>, <code>WEST</code>
+     * {@code NORTH}, {@code SOUTH}, {@code WEST}, and {@code EAST}.
+     * The {@code Container}'s component orientation is used to determine the location of components
+     * added with {@code LINE_START} and {@code LINE_END}.
+     *
+     * @param   constraints     the desired absolute position, one of {@code CENTER},
+     *                          {@code NORTH}, {@code SOUTH},
+     *                          {@code EAST}, {@code WEST}
      * @param   target     the {@code Container} used to obtain
      *                     the constraint location based on the target
      *                     {@code Container}'s component orientation.
-     * @return  the component at the given location, or <code>null</code> if
+     * @return  the component at the given location, or {@code null} if
      *          the location is empty
      * @exception   IllegalArgumentException  if the constraint object is
      *              not one of the five specified constants
      * @exception   NullPointerException  if the target parameter is null
      * @see     #addLayoutComponent(java.awt.Component, java.lang.Object)

@@ -632,15 +632,15 @@
         }
         return null;
     }
 
     /**
-     * Determines the minimum size of the <code>target</code> container
+     * Determines the minimum size of the {@code target} container
      * using this layout manager.
      * <p>
      * This method is called when a container calls its
-     * <code>getMinimumSize</code> method. Most applications do not call
+     * {@code getMinimumSize} method. Most applications do not call
      * this method directly.
      * @param   target   the container in which to do the layout.
      * @return  the minimum dimensions needed to lay out the subcomponents
      *          of the specified container.
      * @see     java.awt.Container

@@ -687,16 +687,16 @@
         return dim;
       }
     }
 
     /**
-     * Determines the preferred size of the <code>target</code>
+     * Determines the preferred size of the {@code target}
      * container using this layout manager, based on the components
      * in the container.
      * <p>
      * Most applications do not call this method directly. This method
-     * is called when a container calls its <code>getPreferredSize</code>
+     * is called when a container calls its {@code getPreferredSize}
      * method.
      * @param   target   the container in which to do the layout.
      * @return  the preferred dimensions to lay out the subcomponents
      *          of the specified container.
      * @see     java.awt.Container

@@ -788,20 +788,20 @@
     /**
      * Lays out the container argument using this border layout.
      * <p>
      * This method actually reshapes the components in the specified
      * container in order to satisfy the constraints of this
-     * <code>BorderLayout</code> object. The <code>NORTH</code>
-     * and <code>SOUTH</code> components, if any, are placed at
+     * {@code BorderLayout} object. The {@code NORTH}
+     * and {@code SOUTH} components, if any, are placed at
      * the top and bottom of the container, respectively. The
-     * <code>WEST</code> and <code>EAST</code> components are
+     * {@code WEST} and {@code EAST} components are
      * then placed on the left and right, respectively. Finally,
-     * the <code>CENTER</code> object is placed in any remaining
+     * the {@code CENTER} object is placed in any remaining
      * space in the middle.
      * <p>
      * Most applications do not call this method directly. This method
-     * is called when a container calls its <code>doLayout</code> method.
+     * is called when a container calls its {@code doLayout} method.
      * @param   target   the container in which to do the layout.
      * @see     java.awt.Container
      * @see     java.awt.Container#doLayout()
      */
     public void layoutContainer(Container target) {
< prev index next >