< prev index next >

src/java.desktop/share/classes/java/awt/font/GlyphVector.java

Print this page

        

@@ -39,69 +39,69 @@
 import java.awt.Shape;
 import java.awt.font.GlyphMetrics;
 import java.awt.font.GlyphJustificationInfo;
 
 /**
- * A <code>GlyphVector</code> object is a collection of glyphs
+ * A {@code GlyphVector} object is a collection of glyphs
  * containing geometric information for the placement of each glyph
  * in a transformed coordinate space which corresponds to the
- * device on which the <code>GlyphVector</code> is ultimately
+ * device on which the {@code GlyphVector} is ultimately
  * displayed.
  * <p>
- * The <code>GlyphVector</code> does not attempt any interpretation of
+ * The {@code GlyphVector} does not attempt any interpretation of
  * the sequence of glyphs it contains.  Relationships between adjacent
  * glyphs in sequence are solely used to determine the placement of
  * the glyphs in the visual coordinate space.
  * <p>
- * Instances of <code>GlyphVector</code> are created by a {@link Font}.
+ * Instances of {@code GlyphVector} are created by a {@link Font}.
  * <p>
  * In a text processing application that can cache intermediate
  * representations of text, creation and subsequent caching of a
- * <code>GlyphVector</code> for use during rendering is the fastest
+ * {@code GlyphVector} for use during rendering is the fastest
  * method to present the visual representation of characters to a user.
  * <p>
- * A <code>GlyphVector</code> is associated with exactly one
- * <code>Font</code>, and can provide data useful only in relation to
- * this <code>Font</code>.  In addition, metrics obtained from a
- * <code>GlyphVector</code> are not generally geometrically scalable
+ * A {@code GlyphVector} is associated with exactly one
+ * {@code Font}, and can provide data useful only in relation to
+ * this {@code Font}.  In addition, metrics obtained from a
+ * {@code GlyphVector} are not generally geometrically scalable
  * since the pixelization and spacing are dependent on grid-fitting
- * algorithms within a <code>Font</code>.  To facilitate accurate
- * measurement of a <code>GlyphVector</code> and its component
+ * algorithms within a {@code Font}.  To facilitate accurate
+ * measurement of a {@code GlyphVector} and its component
  * glyphs, you must specify a scaling transform, anti-alias mode, and
- * fractional metrics mode when creating the <code>GlyphVector</code>.
+ * fractional metrics mode when creating the {@code GlyphVector}.
  * These characteristics can be derived from the destination device.
  * <p>
- * For each glyph in the <code>GlyphVector</code>, you can obtain:
+ * For each glyph in the {@code GlyphVector}, you can obtain:
  * <ul>
  * <li>the position of the glyph
  * <li>the transform associated with the glyph
  * <li>the metrics of the glyph in the context of the
- *   <code>GlyphVector</code>.  The metrics of the glyph may be
+ *   {@code GlyphVector}.  The metrics of the glyph may be
  *   different under different transforms, application specified
  *   rendering hints, and the specific instance of the glyph within
- *   the <code>GlyphVector</code>.
+ *   the {@code GlyphVector}.
  * </ul>
  * <p>
- * Altering the data used to create the <code>GlyphVector</code> does not
- * alter the state of the <code>GlyphVector</code>.
+ * Altering the data used to create the {@code GlyphVector} does not
+ * alter the state of the {@code GlyphVector}.
  * <p>
  * Methods are provided to adjust the positions of the glyphs
- * within the <code>GlyphVector</code>.  These methods are most
+ * within the {@code GlyphVector}.  These methods are most
  * appropriate for applications that are performing justification
  * operations for the presentation of the glyphs.
  * <p>
  * Methods are provided to transform individual glyphs within the
- * <code>GlyphVector</code>.  These methods are primarily useful for
+ * {@code GlyphVector}.  These methods are primarily useful for
  * special effects.
  * <p>
  * Methods are provided to return both the visual, logical, and pixel bounds
- * of the entire <code>GlyphVector</code> or of individual glyphs within
- * the <code>GlyphVector</code>.
+ * of the entire {@code GlyphVector} or of individual glyphs within
+ * the {@code GlyphVector}.
  * <p>
  * Methods are provided to return a {@link Shape} for the
- * <code>GlyphVector</code>, and for individual glyphs within the
- * <code>GlyphVector</code>.
+ * {@code GlyphVector}, and for individual glyphs within the
+ * {@code GlyphVector}.
  * @see Font
  * @see GlyphMetrics
  * @see TextLayout
  * @author Charlton Innovations, Inc.
  */

@@ -111,23 +111,23 @@
     //
     // methods associated with creation-time state
     //
 
     /**
-     * Returns the <code>Font</code> associated with this
-     * <code>GlyphVector</code>.
-     * @return <code>Font</code> used to create this
-     * <code>GlyphVector</code>.
+     * Returns the {@code Font} associated with this
+     * {@code GlyphVector}.
+     * @return {@code Font} used to create this
+     * {@code GlyphVector}.
      * @see Font
      */
     public abstract Font getFont();
 
     /**
      * Returns the {@link FontRenderContext} associated with this
-     * <code>GlyphVector</code>.
-     * @return <code>FontRenderContext</code> used to create this
-     * <code>GlyphVector</code>.
+     * {@code GlyphVector}.
+     * @return {@code FontRenderContext} used to create this
+     * {@code GlyphVector}.
      * @see FontRenderContext
      * @see Font
      */
     public abstract FontRenderContext getFontRenderContext();
 

@@ -135,58 +135,58 @@
     // methods associated with the GlyphVector as a whole
     //
 
     /**
      * Assigns default positions to each glyph in this
-     * <code>GlyphVector</code>. This can destroy information
-     * generated during initial layout of this <code>GlyphVector</code>.
+     * {@code GlyphVector}. This can destroy information
+     * generated during initial layout of this {@code GlyphVector}.
      */
     public abstract void performDefaultLayout();
 
     /**
-     * Returns the number of glyphs in this <code>GlyphVector</code>.
-     * @return number of glyphs in this <code>GlyphVector</code>.
+     * Returns the number of glyphs in this {@code GlyphVector}.
+     * @return number of glyphs in this {@code GlyphVector}.
      */
     public abstract int getNumGlyphs();
 
     /**
      * Returns the glyphcode of the specified glyph.
      * This return value is meaningless to anything other
-     * than the <code>Font</code> object that created this
-     * <code>GlyphVector</code>.
-     * @param glyphIndex the index into this <code>GlyphVector</code>
+     * than the {@code Font} object that created this
+     * {@code GlyphVector}.
+     * @param glyphIndex the index into this {@code GlyphVector}
      * that corresponds to the glyph from which to retrieve the
      * glyphcode.
      * @return the glyphcode of the glyph at the specified
-     * <code>glyphIndex</code>.
-     * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+     * {@code glyphIndex}.
+     * @throws IndexOutOfBoundsException if {@code glyphIndex}
      * is less than 0 or greater than or equal to the
-     * number of glyphs in this <code>GlyphVector</code>
+     * number of glyphs in this {@code GlyphVector}
      */
     public abstract int getGlyphCode(int glyphIndex);
 
     /**
      * Returns an array of glyphcodes for the specified glyphs.
      * The contents of this return value are meaningless to anything other
-     * than the <code>Font</code> used to create this
-     * <code>GlyphVector</code>.  This method is used
+     * than the {@code Font} used to create this
+     * {@code GlyphVector}.  This method is used
      * for convenience and performance when processing glyphcodes.
      * If no array is passed in, a new array is created.
      * @param beginGlyphIndex the index into this
-     *   <code>GlyphVector</code> at which to start retrieving glyphcodes
+     *   {@code GlyphVector} at which to start retrieving glyphcodes
      * @param numEntries the number of glyphcodes to retrieve
      * @param codeReturn the array that receives the glyphcodes and is
      *   then returned
      * @return an array of glyphcodes for the specified glyphs.
-     * @throws IllegalArgumentException if <code>numEntries</code> is
+     * @throws IllegalArgumentException if {@code numEntries} is
      *   less than 0
-     * @throws IndexOutOfBoundsException if <code>beginGlyphIndex</code>
+     * @throws IndexOutOfBoundsException if {@code beginGlyphIndex}
      *   is less than 0
      * @throws IndexOutOfBoundsException if the sum of
-     *   <code>beginGlyphIndex</code> and <code>numEntries</code> is
+     *   {@code beginGlyphIndex} and {@code numEntries} is
      *   greater than the number of glyphs in this
-     *   <code>GlyphVector</code>
+     *   {@code GlyphVector}
      */
     public abstract int[] getGlyphCodes(int beginGlyphIndex, int numEntries,
                                         int[] codeReturn);
 
     /**

@@ -229,45 +229,45 @@
         }
         return codeReturn;
      }
 
     /**
-     * Returns the logical bounds of this <code>GlyphVector</code>.
-     * This method is used when positioning this <code>GlyphVector</code>
-     * in relation to visually adjacent <code>GlyphVector</code> objects.
+     * Returns the logical bounds of this {@code GlyphVector}.
+     * This method is used when positioning this {@code GlyphVector}
+     * in relation to visually adjacent {@code GlyphVector} objects.
      * @return a {@link Rectangle2D} that is the logical bounds of this
-     * <code>GlyphVector</code>.
+     * {@code GlyphVector}.
      */
     public abstract Rectangle2D getLogicalBounds();
 
     /**
-     * Returns the visual bounds of this <code>GlyphVector</code>
+     * Returns the visual bounds of this {@code GlyphVector}
      * The visual bounds is the bounding box of the outline of this
-     * <code>GlyphVector</code>.  Because of rasterization and
+     * {@code GlyphVector}.  Because of rasterization and
      * alignment of pixels, it is possible that this box does not
-     * enclose all pixels affected by rendering this <code>GlyphVector</code>.
-     * @return a <code>Rectangle2D</code> that is the bounding box
-     * of this <code>GlyphVector</code>.
+     * enclose all pixels affected by rendering this {@code GlyphVector}.
+     * @return a {@code Rectangle2D} that is the bounding box
+     * of this {@code GlyphVector}.
      */
     public abstract Rectangle2D getVisualBounds();
 
     /**
-     * Returns the pixel bounds of this <code>GlyphVector</code> when
+     * Returns the pixel bounds of this {@code GlyphVector} when
      * rendered in a graphics with the given
-     * <code>FontRenderContext</code> at the given location.  The
+     * {@code FontRenderContext} at the given location.  The
      * renderFRC need not be the same as the
-     * <code>FontRenderContext</code> of this
-     * <code>GlyphVector</code>, and can be null.  If it is null, the
-     * <code>FontRenderContext</code> of this <code>GlyphVector</code>
+     * {@code FontRenderContext} of this
+     * {@code GlyphVector}, and can be null.  If it is null, the
+     * {@code FontRenderContext} of this {@code GlyphVector}
      * is used.  The default implementation returns the visual bounds,
      * offset to x, y and rounded out to the next integer value (i.e. returns an
      * integer rectangle which encloses the visual bounds) and
      * ignores the FRC.  Subclassers should override this method.
-     * @param renderFRC the <code>FontRenderContext</code> of the <code>Graphics</code>.
-     * @param x the x-coordinate at which to render this <code>GlyphVector</code>.
-     * @param y the y-coordinate at which to render this <code>GlyphVector</code>.
-     * @return a <code>Rectangle</code> bounding the pixels that would be affected.
+     * @param renderFRC the {@code FontRenderContext} of the {@code Graphics}.
+     * @param x the x-coordinate at which to render this {@code GlyphVector}.
+     * @param y the y-coordinate at which to render this {@code GlyphVector}.
+     * @return a {@code Rectangle} bounding the pixels that would be affected.
      * @since 1.4
      */
     public Rectangle getPixelBounds(FontRenderContext renderFRC, float x, float y) {
                 Rectangle2D rect = getVisualBounds();
                 int l = (int)Math.floor(rect.getX() + x);

@@ -277,132 +277,132 @@
                 return new Rectangle(l, t, r - l, b - t);
         }
 
 
     /**
-     * Returns a <code>Shape</code> whose interior corresponds to the
-     * visual representation of this <code>GlyphVector</code>.
-     * @return a <code>Shape</code> that is the outline of this
-     * <code>GlyphVector</code>.
+     * Returns a {@code Shape} whose interior corresponds to the
+     * visual representation of this {@code GlyphVector}.
+     * @return a {@code Shape} that is the outline of this
+     * {@code GlyphVector}.
      */
     public abstract Shape getOutline();
 
     /**
-     * Returns a <code>Shape</code> whose interior corresponds to the
-     * visual representation of this <code>GlyphVector</code> when
+     * Returns a {@code Shape} whose interior corresponds to the
+     * visual representation of this {@code GlyphVector} when
      * rendered at x,&nbsp;y.
-     * @param x the X coordinate of this <code>GlyphVector</code>.
-     * @param y the Y coordinate of this <code>GlyphVector</code>.
-     * @return a <code>Shape</code> that is the outline of this
-     *   <code>GlyphVector</code> when rendered at the specified
+     * @param x the X coordinate of this {@code GlyphVector}.
+     * @param y the Y coordinate of this {@code GlyphVector}.
+     * @return a {@code Shape} that is the outline of this
+     *   {@code GlyphVector} when rendered at the specified
      *   coordinates.
      */
     public abstract Shape getOutline(float x, float y);
 
     /**
-     * Returns a <code>Shape</code> whose interior corresponds to the
+     * Returns a {@code Shape} whose interior corresponds to the
      * visual representation of the specified glyph
-     * within this <code>GlyphVector</code>.
+     * within this {@code GlyphVector}.
      * The outline returned by this method is positioned around the
      * origin of each individual glyph.
-     * @param glyphIndex the index into this <code>GlyphVector</code>
-     * @return a <code>Shape</code> that is the outline of the glyph
-     *   at the specified <code>glyphIndex</code> of this
-     *   <code>GlyphVector</code>.
-     * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+     * @param glyphIndex the index into this {@code GlyphVector}
+     * @return a {@code Shape} that is the outline of the glyph
+     *   at the specified {@code glyphIndex} of this
+     *   {@code GlyphVector}.
+     * @throws IndexOutOfBoundsException if {@code glyphIndex}
      *   is less than 0 or greater than or equal to the number
-     *   of glyphs in this <code>GlyphVector</code>
+     *   of glyphs in this {@code GlyphVector}
      */
     public abstract Shape getGlyphOutline(int glyphIndex);
 
     /**
-     * Returns a <code>Shape</code> whose interior corresponds to the
+     * Returns a {@code Shape} whose interior corresponds to the
      * visual representation of the specified glyph
-     * within this <code>GlyphVector</code>, offset to x,&nbsp;y.
+     * within this {@code GlyphVector}, offset to x,&nbsp;y.
      * The outline returned by this method is positioned around the
      * origin of each individual glyph.
-     * @param glyphIndex the index into this <code>GlyphVector</code>
+     * @param glyphIndex the index into this {@code GlyphVector}
      * @param x the X coordinate of the location of this {@code GlyphVector}
      * @param y the Y coordinate of the location of this {@code GlyphVector}
-     * @return a <code>Shape</code> that is the outline of the glyph
-     *   at the specified <code>glyphIndex</code> of this
-     *   <code>GlyphVector</code> when rendered at the specified
+     * @return a {@code Shape} that is the outline of the glyph
+     *   at the specified {@code glyphIndex} of this
+     *   {@code GlyphVector} when rendered at the specified
      *   coordinates.
-     * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+     * @throws IndexOutOfBoundsException if {@code glyphIndex}
      *   is less than 0 or greater than or equal to the number
-     *   of glyphs in this <code>GlyphVector</code>
+     *   of glyphs in this {@code GlyphVector}
      * @since 1.4
      */
     public Shape getGlyphOutline(int glyphIndex, float x, float y) {
         Shape s = getGlyphOutline(glyphIndex);
         AffineTransform at = AffineTransform.getTranslateInstance(x,y);
         return at.createTransformedShape(s);
         }
 
     /**
      * Returns the position of the specified glyph relative to the
-     * origin of this <code>GlyphVector</code>.
-     * If <code>glyphIndex</code> equals the number of glyphs in
-     * this <code>GlyphVector</code>, this method returns the position after
+     * origin of this {@code GlyphVector}.
+     * If {@code glyphIndex} equals the number of glyphs in
+     * this {@code GlyphVector}, this method returns the position after
      * the last glyph. This position is used to define the advance of
-     * the entire <code>GlyphVector</code>.
-     * @param glyphIndex the index into this <code>GlyphVector</code>
+     * the entire {@code GlyphVector}.
+     * @param glyphIndex the index into this {@code GlyphVector}
      * @return a {@link Point2D} object that is the position of the glyph
-     *   at the specified <code>glyphIndex</code>.
-     * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+     *   at the specified {@code glyphIndex}.
+     * @throws IndexOutOfBoundsException if {@code glyphIndex}
      *   is less than 0 or greater than the number of glyphs
-     *   in this <code>GlyphVector</code>
+     *   in this {@code GlyphVector}
      * @see #setGlyphPosition
      */
     public abstract Point2D getGlyphPosition(int glyphIndex);
 
     /**
      * Sets the position of the specified glyph within this
-     * <code>GlyphVector</code>.
-     * If <code>glyphIndex</code> equals the number of glyphs in
-     * this <code>GlyphVector</code>, this method sets the position after
+     * {@code GlyphVector}.
+     * If {@code glyphIndex} equals the number of glyphs in
+     * this {@code GlyphVector}, this method sets the position after
      * the last glyph. This position is used to define the advance of
-     * the entire <code>GlyphVector</code>.
-     * @param glyphIndex the index into this <code>GlyphVector</code>
-     * @param newPos the <code>Point2D</code> at which to position the
-     *   glyph at the specified <code>glyphIndex</code>
-     * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+     * the entire {@code GlyphVector}.
+     * @param glyphIndex the index into this {@code GlyphVector}
+     * @param newPos the {@code Point2D} at which to position the
+     *   glyph at the specified {@code glyphIndex}
+     * @throws IndexOutOfBoundsException if {@code glyphIndex}
      *   is less than 0 or greater than the number of glyphs
-     *   in this <code>GlyphVector</code>
+     *   in this {@code GlyphVector}
      * @see #getGlyphPosition
      */
     public abstract void setGlyphPosition(int glyphIndex, Point2D newPos);
 
     /**
      * Returns the transform of the specified glyph within this
-     * <code>GlyphVector</code>.  The transform is relative to the
+     * {@code GlyphVector}.  The transform is relative to the
      * glyph position.  If no special transform has been applied,
-     * <code>null</code> can be returned.  A null return indicates
+     * {@code null} can be returned.  A null return indicates
      * an identity transform.
-     * @param glyphIndex the index into this <code>GlyphVector</code>
+     * @param glyphIndex the index into this {@code GlyphVector}
      * @return an {@link AffineTransform} that is the transform of
-     *   the glyph at the specified <code>glyphIndex</code>.
-     * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+     *   the glyph at the specified {@code glyphIndex}.
+     * @throws IndexOutOfBoundsException if {@code glyphIndex}
      *   is less than 0 or greater than or equal to the number
-     *   of glyphs in this <code>GlyphVector</code>
+     *   of glyphs in this {@code GlyphVector}
      * @see #setGlyphTransform
      */
     public abstract AffineTransform getGlyphTransform(int glyphIndex);
 
     /**
      * Sets the transform of the specified glyph within this
-     * <code>GlyphVector</code>.  The transform is relative to the glyph
-     * position.  A <code>null</code> argument for <code>newTX</code>
+     * {@code GlyphVector}.  The transform is relative to the glyph
+     * position.  A {@code null} argument for {@code newTX}
      * indicates that no special transform is applied for the specified
      * glyph.
      * This method can be used to rotate, mirror, translate and scale the
      * glyph.  Adding a transform can result in significant performance changes.
-     * @param glyphIndex the index into this <code>GlyphVector</code>
-     * @param newTX the new transform of the glyph at <code>glyphIndex</code>
-     * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+     * @param glyphIndex the index into this {@code GlyphVector}
+     * @param newTX the new transform of the glyph at {@code glyphIndex}
+     * @throws IndexOutOfBoundsException if {@code glyphIndex}
      *   is less than 0 or greater than or equal to the number
-     *   of glyphs in this <code>GlyphVector</code>
+     *   of glyphs in this {@code GlyphVector}
      * @see #getGlyphTransform
      */
     public abstract void setGlyphTransform(int glyphIndex, AffineTransform newTX);
 
     /**

@@ -424,35 +424,35 @@
     public int getLayoutFlags() {
                 return 0;
         }
 
     /**
-     * A flag used with getLayoutFlags that indicates that this <code>GlyphVector</code> has
+     * A flag used with getLayoutFlags that indicates that this {@code GlyphVector} has
      * per-glyph transforms.
      * @since 1.4
      */
     public static final int FLAG_HAS_TRANSFORMS = 1;
 
     /**
-     * A flag used with getLayoutFlags that indicates that this <code>GlyphVector</code> has
+     * A flag used with getLayoutFlags that indicates that this {@code GlyphVector} has
      * position adjustments.  When this is true, the glyph positions don't match the
      * accumulated default advances of the glyphs (for example, if kerning has been done).
      * @since 1.4
      */
     public static final int FLAG_HAS_POSITION_ADJUSTMENTS = 2;
 
     /**
-     * A flag used with getLayoutFlags that indicates that this <code>GlyphVector</code> has
+     * A flag used with getLayoutFlags that indicates that this {@code GlyphVector} has
      * a right-to-left run direction.  This refers to the glyph-to-char mapping and does
      * not imply that the visual locations of the glyphs are necessarily in this order,
      * although generally they will be.
      * @since 1.4
      */
     public static final int FLAG_RUN_RTL = 4;
 
     /**
-     * A flag used with getLayoutFlags that indicates that this <code>GlyphVector</code> has
+     * A flag used with getLayoutFlags that indicates that this {@code GlyphVector} has
      * a complex glyph-to-char mapping (one that does not map glyphs to chars one-to-one in
      * strictly ascending or descending order matching the run direction).
      * @since 1.4
      */
     public static final int FLAG_COMPLEX_GLYPHS = 8;

@@ -472,90 +472,90 @@
      * Returns an array of glyph positions for the specified glyphs.
      * This method is used for convenience and performance when
      * processing glyph positions.
      * If no array is passed in, a new array is created.
      * Even numbered array entries beginning with position zero are the X
-     * coordinates of the glyph numbered <code>beginGlyphIndex + position/2</code>.
+     * coordinates of the glyph numbered {@code beginGlyphIndex + position/2}.
      * Odd numbered array entries beginning with position one are the Y
-     * coordinates of the glyph numbered <code>beginGlyphIndex + (position-1)/2</code>.
-     * If <code>beginGlyphIndex</code> equals the number of glyphs in
-     * this <code>GlyphVector</code>, this method gets the position after
+     * coordinates of the glyph numbered {@code beginGlyphIndex + (position-1)/2}.
+     * If {@code beginGlyphIndex} equals the number of glyphs in
+     * this {@code GlyphVector}, this method gets the position after
      * the last glyph and this position is used to define the advance of
-     * the entire <code>GlyphVector</code>.
+     * the entire {@code GlyphVector}.
      * @param beginGlyphIndex the index at which to begin retrieving
      *   glyph positions
      * @param numEntries the number of glyphs to retrieve
      * @param positionReturn the array that receives the glyph positions
      *   and is then returned.
      * @return an array of glyph positions specified by
-     *  <code>beginGlyphIndex</code> and <code>numEntries</code>.
-     * @throws IllegalArgumentException if <code>numEntries</code> is
+     *  {@code beginGlyphIndex} and {@code numEntries}.
+     * @throws IllegalArgumentException if {@code numEntries} is
      *   less than 0
-     * @throws IndexOutOfBoundsException if <code>beginGlyphIndex</code>
+     * @throws IndexOutOfBoundsException if {@code beginGlyphIndex}
      *   is less than 0
      * @throws IndexOutOfBoundsException if the sum of
-     *   <code>beginGlyphIndex</code> and <code>numEntries</code>
+     *   {@code beginGlyphIndex} and {@code numEntries}
      *   is greater than the number of glyphs in this
-     *   <code>GlyphVector</code> plus one
+     *   {@code GlyphVector} plus one
      */
     public abstract float[] getGlyphPositions(int beginGlyphIndex, int numEntries,
                                               float[] positionReturn);
 
     /**
      * Returns the logical bounds of the specified glyph within this
-     * <code>GlyphVector</code>.
+     * {@code GlyphVector}.
      * These logical bounds have a total of four edges, with two edges
      * parallel to the baseline under the glyph's transform and the other two
      * edges are shared with adjacent glyphs if they are present.  This
      * method is useful for hit-testing of the specified glyph,
      * positioning of a caret at the leading or trailing edge of a glyph,
      * and for drawing a highlight region around the specified glyph.
-     * @param glyphIndex the index into this <code>GlyphVector</code>
+     * @param glyphIndex the index into this {@code GlyphVector}
      *   that corresponds to the glyph from which to retrieve its logical
      *   bounds
-     * @return  a <code>Shape</code> that is the logical bounds of the
-     *   glyph at the specified <code>glyphIndex</code>.
-     * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+     * @return  a {@code Shape} that is the logical bounds of the
+     *   glyph at the specified {@code glyphIndex}.
+     * @throws IndexOutOfBoundsException if {@code glyphIndex}
      *   is less than 0 or greater than or equal to the number
-     *   of glyphs in this <code>GlyphVector</code>
+     *   of glyphs in this {@code GlyphVector}
      * @see #getGlyphVisualBounds
      */
     public abstract Shape getGlyphLogicalBounds(int glyphIndex);
 
     /**
      * Returns the visual bounds of the specified glyph within the
-     * <code>GlyphVector</code>.
+     * {@code GlyphVector}.
      * The bounds returned by this method is positioned around the
      * origin of each individual glyph.
-     * @param glyphIndex the index into this <code>GlyphVector</code>
+     * @param glyphIndex the index into this {@code GlyphVector}
      *   that corresponds to the glyph from which to retrieve its visual
      *   bounds
-     * @return a <code>Shape</code> that is the visual bounds of the
-     *   glyph at the specified <code>glyphIndex</code>.
-     * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+     * @return a {@code Shape} that is the visual bounds of the
+     *   glyph at the specified {@code glyphIndex}.
+     * @throws IndexOutOfBoundsException if {@code glyphIndex}
      *   is less than 0 or greater than or equal to the number
-     *   of glyphs in this <code>GlyphVector</code>
+     *   of glyphs in this {@code GlyphVector}
      * @see #getGlyphLogicalBounds
      */
     public abstract Shape getGlyphVisualBounds(int glyphIndex);
 
     /**
      * Returns the pixel bounds of the glyph at index when this
-     * <code>GlyphVector</code> is rendered in a <code>Graphics</code> with the
-     * given <code>FontRenderContext</code> at the given location. The
+     * {@code GlyphVector} is rendered in a {@code Graphics} with the
+     * given {@code FontRenderContext} at the given location. The
      * renderFRC need not be the same as the
-     * <code>FontRenderContext</code> of this
-     * <code>GlyphVector</code>, and can be null.  If it is null, the
-     * <code>FontRenderContext</code> of this <code>GlyphVector</code>
+     * {@code FontRenderContext} of this
+     * {@code GlyphVector}, and can be null.  If it is null, the
+     * {@code FontRenderContext} of this {@code GlyphVector}
      * is used.  The default implementation returns the visual bounds of the glyph,
      * offset to x, y and rounded out to the next integer value, and
      * ignores the FRC.  Subclassers should override this method.
      * @param index the index of the glyph.
-     * @param renderFRC the <code>FontRenderContext</code> of the <code>Graphics</code>.
-     * @param x the X position at which to render this <code>GlyphVector</code>.
-     * @param y the Y position at which to render this <code>GlyphVector</code>.
-     * @return a <code>Rectangle</code> bounding the pixels that would be affected.
+     * @param renderFRC the {@code FontRenderContext} of the {@code Graphics}.
+     * @param x the X position at which to render this {@code GlyphVector}.
+     * @param y the Y position at which to render this {@code GlyphVector}.
+     * @return a {@code Rectangle} bounding the pixels that would be affected.
      * @since 1.4
      */
     public Rectangle getGlyphPixelBounds(int index, FontRenderContext renderFRC, float x, float y) {
                 Rectangle2D rect = getGlyphVisualBounds(index).getBounds2D();
                 int l = (int)Math.floor(rect.getX() + x);

@@ -565,47 +565,47 @@
                 return new Rectangle(l, t, r - l, b - t);
         }
 
     /**
      * Returns the metrics of the glyph at the specified index into
-     * this <code>GlyphVector</code>.
-     * @param glyphIndex the index into this <code>GlyphVector</code>
+     * this {@code GlyphVector}.
+     * @param glyphIndex the index into this {@code GlyphVector}
      *   that corresponds to the glyph from which to retrieve its metrics
      * @return a {@link GlyphMetrics} object that represents the
-     *   metrics of the glyph at the specified <code>glyphIndex</code>
-     *   into this <code>GlyphVector</code>.
-     * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+     *   metrics of the glyph at the specified {@code glyphIndex}
+     *   into this {@code GlyphVector}.
+     * @throws IndexOutOfBoundsException if {@code glyphIndex}
      *   is less than 0 or greater than or equal to the number
-     *   of glyphs in this <code>GlyphVector</code>
+     *   of glyphs in this {@code GlyphVector}
      */
     public abstract GlyphMetrics getGlyphMetrics(int glyphIndex);
 
     /**
      * Returns the justification information for the glyph at
-     * the specified index into this <code>GlyphVector</code>.
-     * @param glyphIndex the index into this <code>GlyphVector</code>
+     * the specified index into this {@code GlyphVector}.
+     * @param glyphIndex the index into this {@code GlyphVector}
      *   that corresponds to the glyph from which to retrieve its
      *   justification properties
      * @return a {@link GlyphJustificationInfo} object that
      *   represents the justification properties of the glyph at the
-     *   specified <code>glyphIndex</code> into this
-     *   <code>GlyphVector</code>.
-     * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+     *   specified {@code glyphIndex} into this
+     *   {@code GlyphVector}.
+     * @throws IndexOutOfBoundsException if {@code glyphIndex}
      *   is less than 0 or greater than or equal to the number
-     *   of glyphs in this <code>GlyphVector</code>
+     *   of glyphs in this {@code GlyphVector}
      */
     public abstract GlyphJustificationInfo getGlyphJustificationInfo(int glyphIndex);
 
     //
     // general utility methods
     //
 
     /**
-     * Tests if the specified <code>GlyphVector</code> exactly
-     * equals this <code>GlyphVector</code>.
-     * @param set the specified <code>GlyphVector</code> to test
-     * @return <code>true</code> if the specified
-     *   <code>GlyphVector</code> equals this <code>GlyphVector</code>;
-     *   <code>false</code> otherwise.
+     * Tests if the specified {@code GlyphVector} exactly
+     * equals this {@code GlyphVector}.
+     * @param set the specified {@code GlyphVector} to test
+     * @return {@code true} if the specified
+     *   {@code GlyphVector} equals this {@code GlyphVector};
+     *   {@code false} otherwise.
      */
     public abstract boolean equals(GlyphVector set);
 }
< prev index next >