< prev index next >

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

Print this page

        

@@ -27,27 +27,27 @@
 import java.awt.Container;
 import javax.swing.plaf.ComponentUI;
 import sun.awt.AppContext;
 
 /**
- * <code>LayoutStyle</code> provides information about how to position
+ * {@code LayoutStyle} provides information about how to position
  * components.  This class is primarily useful for visual tools and
  * layout managers.  Most developers will not need to use this class.
  * <p>
  * You typically don't set or create a
- * <code>LayoutStyle</code>.  Instead use the static method
- * <code>getInstance</code> to obtain the current instance.
+ * {@code LayoutStyle}.  Instead use the static method
+ * {@code getInstance} to obtain the current instance.
  *
  * @since 1.6
  */
 public abstract class LayoutStyle {
     /**
-     * Sets the shared instance of <code>LayoutStyle</code>.  Specifying
-     * <code>null</code> results in using the <code>LayoutStyle</code> from
-     * the current <code>LookAndFeel</code>.
+     * Sets the shared instance of {@code LayoutStyle}.  Specifying
+     * {@code null} results in using the {@code LayoutStyle} from
+     * the current {@code LookAndFeel}.
      *
-     * @param style the <code>LayoutStyle</code>, or <code>null</code>
+     * @param style the {@code LayoutStyle}, or {@code null}
      * @see #getInstance
      */
     public static void setInstance(LayoutStyle style) {
         synchronized(LayoutStyle.class) {
             if (style == null) {

@@ -58,16 +58,16 @@
             }
         }
     }
 
     /**
-     * Returns the shared instance of <code>LayoutStyle</code>.  If an instance
-     * has not been specified in <code>setInstance</code>, this will return
-     * the <code>LayoutStyle</code> from the current <code>LookAndFeel</code>.
+     * Returns the shared instance of {@code LayoutStyle}.  If an instance
+     * has not been specified in {@code setInstance}, this will return
+     * the {@code LayoutStyle} from the current {@code LookAndFeel}.
      *
      * @see LookAndFeel#getLayoutStyle
-     * @return the shared instance of <code>LayoutStyle</code>
+     * @return the shared instance of {@code LayoutStyle}
      */
     public static LayoutStyle getInstance() {
         LayoutStyle style;
         synchronized(LayoutStyle.class) {
             style = (LayoutStyle)AppContext.getAppContext().

@@ -79,112 +79,112 @@
         return style;
     }
 
 
     /**
-     * <code>ComponentPlacement</code> is an enumeration of the
+     * {@code ComponentPlacement} is an enumeration of the
      * possible ways two components can be placed relative to each
-     * other.  <code>ComponentPlacement</code> is used by the
-     * <code>LayoutStyle</code> method <code>getPreferredGap</code>.  Refer to
-     * <code>LayoutStyle</code> for more information.
+     * other.  {@code ComponentPlacement} is used by the
+     * {@code LayoutStyle} method {@code getPreferredGap}.  Refer to
+     * {@code LayoutStyle} for more information.
      *
      * @see LayoutStyle#getPreferredGap(JComponent,JComponent,
      *      ComponentPlacement,int,Container)
      * @since 1.6
      */
     public enum ComponentPlacement {
         /**
          * Enumeration value indicating the two components are
          * visually related and will be placed in the same parent.
-         * For example, a <code>JLabel</code> providing a label for a
-         * <code>JTextField</code> is typically visually associated
-         * with the <code>JTextField</code>; the constant <code>RELATED</code>
+         * For example, a {@code JLabel} providing a label for a
+         * {@code JTextField} is typically visually associated
+         * with the {@code JTextField}; the constant {@code RELATED}
          * is used for this.
          */
         RELATED,
 
         /**
          * Enumeration value indicating the two components are
          * visually unrelated and will be placed in the same parent.
          * For example, groupings of components are usually visually
-         * separated; the constant <code>UNRELATED</code> is used for this.
+         * separated; the constant {@code UNRELATED} is used for this.
          */
         UNRELATED,
 
         /**
          * Enumeration value indicating the distance to indent a component
          * is being requested.  For example, often times the children of
          * a label will be horizontally indented from the label.  To determine
          * the preferred distance for such a gap use the
-         * <code>INDENT</code> type.
+         * {@code INDENT} type.
          * <p>
          * This value is typically only useful with a direction of
-         * <code>EAST</code> or <code>WEST</code>.
+         * {@code EAST} or {@code WEST}.
          */
         INDENT;
     }
 
 
     /**
-     * Creates a new <code>LayoutStyle</code>.  You generally don't
-     * create a <code>LayoutStyle</code>.  Instead use the method
-     * <code>getInstance</code> to obtain the current
-     * <code>LayoutStyle</code>.
+     * Creates a new {@code LayoutStyle}.  You generally don't
+     * create a {@code LayoutStyle}.  Instead use the method
+     * {@code getInstance} to obtain the current
+     * {@code LayoutStyle}.
      */
     public LayoutStyle() {
     }
 
     /**
      * Returns the amount of space to use between two components.
      * The return value indicates the distance to place
-     * <code>component2</code> relative to <code>component1</code>.
+     * {@code component2} relative to {@code component1}.
      * For example, the following returns the amount of space to place
-     * between <code>component2</code> and <code>component1</code>
-     * when <code>component2</code> is placed vertically above
-     * <code>component1</code>:
+     * between {@code component2} and {@code component1}
+     * when {@code component2} is placed vertically above
+     * {@code component1}:
      * <pre>
      *   int gap = getPreferredGap(component1, component2,
      *                             ComponentPlacement.RELATED,
      *                             SwingConstants.NORTH, parent);
      * </pre>
-     * The <code>type</code> parameter indicates the relation between
+     * The {@code type} parameter indicates the relation between
      * the two components.  If the two components will be contained in
      * the same parent and are showing similar logically related
-     * items, use <code>RELATED</code>.  If the two components will be
+     * items, use {@code RELATED}.  If the two components will be
      * contained in the same parent but show logically unrelated items
-     * use <code>UNRELATED</code>.  Some look and feels may not
-     * distinguish between the <code>RELATED</code> and
-     * <code>UNRELATED</code> types.
+     * use {@code UNRELATED}.  Some look and feels may not
+     * distinguish between the {@code RELATED} and
+     * {@code UNRELATED} types.
      * <p>
      * The return value is not intended to take into account the
-     * current size and position of <code>component2</code> or
-     * <code>component1</code>.  The return value may take into
+     * current size and position of {@code component2} or
+     * {@code component1}.  The return value may take into
      * consideration various properties of the components.  For
      * example, the space may vary based on font size, or the preferred
      * size of the component.
      *
-     * @param component1 the <code>JComponent</code>
-     *               <code>component2</code> is being placed relative to
-     * @param component2 the <code>JComponent</code> being placed
-     * @param position the position <code>component2</code> is being placed
-     *        relative to <code>component1</code>; one of
-     *        <code>SwingConstants.NORTH</code>,
-     *        <code>SwingConstants.SOUTH</code>,
-     *        <code>SwingConstants.EAST</code> or
-     *        <code>SwingConstants.WEST</code>
+     * @param component1 the {@code JComponent}
+     *               {@code component2} is being placed relative to
+     * @param component2 the {@code JComponent} being placed
+     * @param position the position {@code component2} is being placed
+     *        relative to {@code component1}; one of
+     *        {@code SwingConstants.NORTH},
+     *        {@code SwingConstants.SOUTH},
+     *        {@code SwingConstants.EAST} or
+     *        {@code SwingConstants.WEST}
      * @param type how the two components are being placed
-     * @param parent the parent of <code>component2</code>; this may differ
-     *        from the actual parent and it may be <code>null</code>
+     * @param parent the parent of {@code component2}; this may differ
+     *        from the actual parent and it may be {@code null}
      * @return the amount of space to place between the two components
-     * @throws NullPointerException if <code>component1</code>,
-     *         <code>component2</code> or <code>type</code> is
-     *         <code>null</code>
-     * @throws IllegalArgumentException if <code>position</code> is not
-     *         one of <code>SwingConstants.NORTH</code>,
-     *         <code>SwingConstants.SOUTH</code>,
-     *         <code>SwingConstants.EAST</code> or
-     *         <code>SwingConstants.WEST</code>
+     * @throws NullPointerException if {@code component1},
+     *         {@code component2} or {@code type} is
+     *         {@code null}
+     * @throws IllegalArgumentException if {@code position} is not
+     *         one of {@code SwingConstants.NORTH},
+     *         {@code SwingConstants.SOUTH},
+     *         {@code SwingConstants.EAST} or
+     *         {@code SwingConstants.WEST}
      * @see LookAndFeel#getLayoutStyle
      * @since 1.6
      */
     public abstract int getPreferredGap(JComponent component1,
                                         JComponent component2,

@@ -193,25 +193,25 @@
 
     /**
      * Returns the amount of space to place between the component and specified
      * edge of its parent.
      *
-     * @param component the <code>JComponent</code> being positioned
-     * @param position the position <code>component</code> is being placed
+     * @param component the {@code JComponent} being positioned
+     * @param position the position {@code component} is being placed
      *        relative to its parent; one of
-     *        <code>SwingConstants.NORTH</code>,
-     *        <code>SwingConstants.SOUTH</code>,
-     *        <code>SwingConstants.EAST</code> or
-     *        <code>SwingConstants.WEST</code>
-     * @param parent the parent of <code>component</code>; this may differ
-     *        from the actual parent and may be <code>null</code>
+     *        {@code SwingConstants.NORTH},
+     *        {@code SwingConstants.SOUTH},
+     *        {@code SwingConstants.EAST} or
+     *        {@code SwingConstants.WEST}
+     * @param parent the parent of {@code component}; this may differ
+     *        from the actual parent and may be {@code null}
      * @return the amount of space to place between the component and specified
      *         edge
-     * @throws IllegalArgumentException if <code>position</code> is not
-     *         one of <code>SwingConstants.NORTH</code>,
-     *         <code>SwingConstants.SOUTH</code>,
-     *         <code>SwingConstants.EAST</code> or
-     *         <code>SwingConstants.WEST</code>
+     * @throws IllegalArgumentException if {@code position} is not
+     *         one of {@code SwingConstants.NORTH},
+     *         {@code SwingConstants.SOUTH},
+     *         {@code SwingConstants.EAST} or
+     *         {@code SwingConstants.WEST}
      */
     public abstract int getContainerGap(JComponent component, int position,
                                         Container parent);
 }
< prev index next >