Home » openjdk-7 » java » awt » font » [javadoc | source]

    1   /*
    2    * Copyright (c) 1998, 2006, Oracle and/or its affiliates. All rights reserved.
    3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    4    *
    5    * This code is free software; you can redistribute it and/or modify it
    6    * under the terms of the GNU General Public License version 2 only, as
    7    * published by the Free Software Foundation.  Oracle designates this
    8    * particular file as subject to the "Classpath" exception as provided
    9    * by Oracle in the LICENSE file that accompanied this code.
   10    *
   11    * This code is distributed in the hope that it will be useful, but WITHOUT
   12    * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   13    * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   14    * version 2 for more details (a copy is included in the LICENSE file that
   15    * accompanied this code).
   16    *
   17    * You should have received a copy of the GNU General Public License version
   18    * 2 along with this work; if not, write to the Free Software Foundation,
   19    * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   20    *
   21    * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   22    * or visit www.oracle.com if you need additional information or have any
   23    * questions.
   24    */
   25   
   26   /*
   27    * @author Charlton Innovations, Inc.
   28    */
   29   
   30   package java.awt.font;
   31   
   32   import java.awt.Graphics2D;
   33   import java.awt.Font;
   34   import java.awt.Polygon;        // remind - need a floating point version
   35   import java.awt.Rectangle;
   36   import java.awt.geom.Point2D;
   37   import java.awt.geom.Rectangle2D;
   38   import java.awt.geom.AffineTransform;
   39   import java.awt.Shape;
   40   import java.awt.font.GlyphMetrics;
   41   import java.awt.font.GlyphJustificationInfo;
   42   
   43   /**
   44    * A <code>GlyphVector</code> object is a collection of glyphs
   45    * containing geometric information for the placement of each glyph
   46    * in a transformed coordinate space which corresponds to the
   47    * device on which the <code>GlyphVector</code> is ultimately
   48    * displayed.
   49    * <p>
   50    * The <code>GlyphVector</code> does not attempt any interpretation of
   51    * the sequence of glyphs it contains.  Relationships between adjacent
   52    * glyphs in sequence are solely used to determine the placement of
   53    * the glyphs in the visual coordinate space.
   54    * <p>
   55    * Instances of <code>GlyphVector</code> are created by a {@link Font}.
   56    * <p>
   57    * In a text processing application that can cache intermediate
   58    * representations of text, creation and subsequent caching of a
   59    * <code>GlyphVector</code> for use during rendering is the fastest
   60    * method to present the visual representation of characters to a user.
   61    * <p>
   62    * A <code>GlyphVector</code> is associated with exactly one
   63    * <code>Font</code>, and can provide data useful only in relation to
   64    * this <code>Font</code>.  In addition, metrics obtained from a
   65    * <code>GlyphVector</code> are not generally geometrically scaleable
   66    * since the pixelization and spacing are dependent on grid-fitting
   67    * algorithms within a <code>Font</code>.  To facilitate accurate
   68    * measurement of a <code>GlyphVector</code> and its component
   69    * glyphs, you must specify a scaling transform, anti-alias mode, and
   70    * fractional metrics mode when creating the <code>GlyphVector</code>.
   71    * These characteristics can be derived from the destination device.
   72    * <p>
   73    * For each glyph in the <code>GlyphVector</code>, you can obtain:
   74    * <ul>
   75    * <li>the position of the glyph
   76    * <li>the transform associated with the glyph
   77    * <li>the metrics of the glyph in the context of the
   78    *   <code>GlyphVector</code>.  The metrics of the glyph may be
   79    *   different under different transforms, application specified
   80    *   rendering hints, and the specific instance of the glyph within
   81    *   the <code>GlyphVector</code>.
   82    * </ul>
   83    * <p>
   84    * Altering the data used to create the <code>GlyphVector</code> does not
   85    * alter the state of the <code>GlyphVector</code>.
   86    * <p>
   87    * Methods are provided to adjust the positions of the glyphs
   88    * within the <code>GlyphVector</code>.  These methods are most
   89    * appropriate for applications that are performing justification
   90    * operations for the presentation of the glyphs.
   91    * <p>
   92    * Methods are provided to transform individual glyphs within the
   93    * <code>GlyphVector</code>.  These methods are primarily useful for
   94    * special effects.
   95    * <p>
   96    * Methods are provided to return both the visual, logical, and pixel bounds
   97    * of the entire <code>GlyphVector</code> or of individual glyphs within
   98    * the <code>GlyphVector</code>.
   99    * <p>
  100    * Methods are provided to return a {@link Shape} for the
  101    * <code>GlyphVector</code>, and for individual glyphs within the
  102    * <code>GlyphVector</code>.
  103    * @see Font
  104    * @see GlyphMetrics
  105    * @see TextLayout
  106    * @author Charlton Innovations, Inc.
  107    */
  108   
  109   public abstract class GlyphVector implements Cloneable {
  110   
  111       //
  112       // methods associated with creation-time state
  113       //
  114   
  115       /**
  116        * Returns the <code>Font</code> associated with this
  117        * <code>GlyphVector</code>.
  118        * @return <code>Font</code> used to create this
  119        * <code>GlyphVector</code>.
  120        * @see Font
  121        */
  122       public abstract Font getFont();
  123   
  124       /**
  125        * Returns the {@link FontRenderContext} associated with this
  126        * <code>GlyphVector</code>.
  127        * @return <code>FontRenderContext</code> used to create this
  128        * <code>GlyphVector</code>.
  129        * @see FontRenderContext
  130        * @see Font
  131        */
  132       public abstract FontRenderContext getFontRenderContext();
  133   
  134       //
  135       // methods associated with the GlyphVector as a whole
  136       //
  137   
  138       /**
  139        * Assigns default positions to each glyph in this
  140        * <code>GlyphVector</code>. This can destroy information
  141        * generated during initial layout of this <code>GlyphVector</code>.
  142        */
  143       public abstract void performDefaultLayout();
  144   
  145       /**
  146        * Returns the number of glyphs in this <code>GlyphVector</code>.
  147        * @return number of glyphs in this <code>GlyphVector</code>.
  148        */
  149       public abstract int getNumGlyphs();
  150   
  151       /**
  152        * Returns the glyphcode of the specified glyph.
  153        * This return value is meaningless to anything other
  154        * than the <code>Font</code> object that created this
  155        * <code>GlyphVector</code>.
  156        * @param glyphIndex the index into this <code>GlyphVector</code>
  157        * that corresponds to the glyph from which to retrieve the
  158        * glyphcode.
  159        * @return the glyphcode of the glyph at the specified
  160        * <code>glyphIndex</code>.
  161        * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
  162        * is less than 0 or greater than or equal to the
  163        * number of glyphs in this <code>GlyphVector</code>
  164        */
  165       public abstract int getGlyphCode(int glyphIndex);
  166   
  167       /**
  168        * Returns an array of glyphcodes for the specified glyphs.
  169        * The contents of this return value are meaningless to anything other
  170        * than the <code>Font</code> used to create this
  171        * <code>GlyphVector</code>.  This method is used
  172        * for convenience and performance when processing glyphcodes.
  173        * If no array is passed in, a new array is created.
  174        * @param beginGlyphIndex the index into this
  175        *   <code>GlyphVector</code> at which to start retrieving glyphcodes
  176        * @param numEntries the number of glyphcodes to retrieve
  177        * @param codeReturn the array that receives the glyphcodes and is
  178        *   then returned
  179        * @return an array of glyphcodes for the specified glyphs.
  180        * @throws IllegalArgumentException if <code>numEntries</code> is
  181        *   less than 0
  182        * @throws IndexOutOfBoundsException if <code>beginGlyphIndex</code>
  183        *   is less than 0
  184        * @throws IndexOutOfBoundsException if the sum of
  185        *   <code>beginGlyphIndex</code> and <code>numEntries</code> is
  186        *   greater than the number of glyphs in this
  187        *   <code>GlyphVector</code>
  188        */
  189       public abstract int[] getGlyphCodes(int beginGlyphIndex, int numEntries,
  190                                           int[] codeReturn);
  191   
  192       /**
  193        * Returns the character index of the specified glyph.
  194        * The character index is the index of the first logical
  195        * character represented by the glyph.  The default
  196        * implementation assumes a one-to-one, left-to-right mapping
  197        * of glyphs to characters.
  198        * @param glyphIndex the index of the glyph
  199        * @return the index of the first character represented by the glyph
  200        * @since 1.4
  201        */
  202       public int getGlyphCharIndex(int glyphIndex) {
  203           return glyphIndex;
  204       }
  205   
  206       /**
  207        * Returns the character indices of the specified glyphs.
  208        * The character index is the index of the first logical
  209        * character represented by the glyph.  Indices are returned
  210        * in glyph order.  The default implementation invokes
  211        * getGlyphCharIndex for each glyph, and subclassers will probably
  212        * want to override this implementation for performance reasons.
  213        * Use this method for convenience and performance
  214        * in processing of glyphcodes. If no array is passed in,
  215        * a new array is created.
  216        * @param beginGlyphIndex the index of the first glyph
  217        * @param numEntries the number of glyph indices
  218        * @param codeReturn the array into which to return the character indices
  219        * @return an array of character indices, one per glyph.
  220        * @since 1.4
  221        */
  222       public int[] getGlyphCharIndices(int beginGlyphIndex, int numEntries,
  223                                        int[] codeReturn) {
  224           if (codeReturn == null) {
  225               codeReturn = new int[numEntries];
  226           }
  227           for (int i = 0, j = beginGlyphIndex; i < numEntries; ++i, ++j) {
  228               codeReturn[i] = getGlyphCharIndex(j);
  229           }
  230           return codeReturn;
  231        }
  232   
  233       /**
  234        * Returns the logical bounds of this <code>GlyphVector</code>.
  235        * This method is used when positioning this <code>GlyphVector</code>
  236        * in relation to visually adjacent <code>GlyphVector</code> objects.
  237        * @return a {@link Rectangle2D} that is the logical bounds of this
  238        * <code>GlyphVector</code>.
  239        */
  240       public abstract Rectangle2D getLogicalBounds();
  241   
  242       /**
  243        * Returns the visual bounds of this <code>GlyphVector</code>
  244        * The visual bounds is the bounding box of the outline of this
  245        * <code>GlyphVector</code>.  Because of rasterization and
  246        * alignment of pixels, it is possible that this box does not
  247        * enclose all pixels affected by rendering this <code>GlyphVector</code>.
  248        * @return a <code>Rectangle2D</code> that is the bounding box
  249        * of this <code>GlyphVector</code>.
  250        */
  251       public abstract Rectangle2D getVisualBounds();
  252   
  253       /**
  254        * Returns the pixel bounds of this <code>GlyphVector</code> when
  255        * rendered in a graphics with the given
  256        * <code>FontRenderContext</code> at the given location.  The
  257        * renderFRC need not be the same as the
  258        * <code>FontRenderContext</code> of this
  259        * <code>GlyphVector</code>, and can be null.  If it is null, the
  260        * <code>FontRenderContext</code> of this <code>GlyphVector</code>
  261        * is used.  The default implementation returns the visual bounds,
  262        * offset to x, y and rounded out to the next integer value (i.e. returns an
  263        * integer rectangle which encloses the visual bounds) and
  264        * ignores the FRC.  Subclassers should override this method.
  265        * @param renderFRC the <code>FontRenderContext</code> of the <code>Graphics</code>.
  266        * @param x the x-coordinate at which to render this <code>GlyphVector</code>.
  267        * @param y the y-coordinate at which to render this <code>GlyphVector</code>.
  268        * @return a <code>Rectangle</code> bounding the pixels that would be affected.
  269        * @since 1.4
  270        */
  271       public Rectangle getPixelBounds(FontRenderContext renderFRC, float x, float y) {
  272                   Rectangle2D rect = getVisualBounds();
  273                   int l = (int)Math.floor(rect.getX() + x);
  274                   int t = (int)Math.floor(rect.getY() + y);
  275                   int r = (int)Math.ceil(rect.getMaxX() + x);
  276                   int b = (int)Math.ceil(rect.getMaxY() + y);
  277                   return new Rectangle(l, t, r - l, b - t);
  278           }
  279   
  280   
  281       /**
  282        * Returns a <code>Shape</code> whose interior corresponds to the
  283        * visual representation of this <code>GlyphVector</code>.
  284        * @return a <code>Shape</code> that is the outline of this
  285        * <code>GlyphVector</code>.
  286        */
  287       public abstract Shape getOutline();
  288   
  289       /**
  290        * Returns a <code>Shape</code> whose interior corresponds to the
  291        * visual representation of this <code>GlyphVector</code> when
  292        * rendered at x,&nbsp;y.
  293        * @param x the X coordinate of this <code>GlyphVector</code>.
  294        * @param y the Y coordinate of this <code>GlyphVector</code>.
  295        * @return a <code>Shape</code> that is the outline of this
  296        *   <code>GlyphVector</code> when rendered at the specified
  297        *   coordinates.
  298        */
  299       public abstract Shape getOutline(float x, float y);
  300   
  301       /**
  302        * Returns a <code>Shape</code> whose interior corresponds to the
  303        * visual representation of the specified glyph
  304        * within this <code>GlyphVector</code>.
  305        * The outline returned by this method is positioned around the
  306        * origin of each individual glyph.
  307        * @param glyphIndex the index into this <code>GlyphVector</code>
  308        * @return a <code>Shape</code> that is the outline of the glyph
  309        *   at the specified <code>glyphIndex</code> of this
  310        *   <code>GlyphVector</code>.
  311        * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
  312        *   is less than 0 or greater than or equal to the number
  313        *   of glyphs in this <code>GlyphVector</code>
  314        */
  315       public abstract Shape getGlyphOutline(int glyphIndex);
  316   
  317       /**
  318        * Returns a <code>Shape</code> whose interior corresponds to the
  319        * visual representation of the specified glyph
  320        * within this <code>GlyphVector</code>, offset to x,&nbsp;y.
  321        * The outline returned by this method is positioned around the
  322        * origin of each individual glyph.
  323        * @param glyphIndex the index into this <code>GlyphVector</code>
  324        * @param x the X coordinate of the location of this {@code GlyphVector}
  325        * @param y the Y coordinate of the location of this {@code GlyphVector}
  326        * @return a <code>Shape</code> that is the outline of the glyph
  327        *   at the specified <code>glyphIndex</code> of this
  328        *   <code>GlyphVector</code> when rendered at the specified
  329        *   coordinates.
  330        * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
  331        *   is less than 0 or greater than or equal to the number
  332        *   of glyphs in this <code>GlyphVector</code>
  333        * @since 1.4
  334        */
  335       public Shape getGlyphOutline(int glyphIndex, float x, float y) {
  336           Shape s = getGlyphOutline(glyphIndex);
  337           AffineTransform at = AffineTransform.getTranslateInstance(x,y);
  338           return at.createTransformedShape(s);
  339           }
  340   
  341       /**
  342        * Returns the position of the specified glyph relative to the
  343        * origin of this <code>GlyphVector</code>.
  344        * If <code>glyphIndex</code> equals the number of of glyphs in
  345        * this <code>GlyphVector</code>, this method returns the position after
  346        * the last glyph. This position is used to define the advance of
  347        * the entire <code>GlyphVector</code>.
  348        * @param glyphIndex the index into this <code>GlyphVector</code>
  349        * @return a {@link Point2D} object that is the position of the glyph
  350        *   at the specified <code>glyphIndex</code>.
  351        * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
  352        *   is less than 0 or greater than the number of glyphs
  353        *   in this <code>GlyphVector</code>
  354        * @see #setGlyphPosition
  355        */
  356       public abstract Point2D getGlyphPosition(int glyphIndex);
  357   
  358       /**
  359        * Sets the position of the specified glyph within this
  360        * <code>GlyphVector</code>.
  361        * If <code>glyphIndex</code> equals the number of of glyphs in
  362        * this <code>GlyphVector</code>, this method sets the position after
  363        * the last glyph. This position is used to define the advance of
  364        * the entire <code>GlyphVector</code>.
  365        * @param glyphIndex the index into this <code>GlyphVector</code>
  366        * @param newPos the <code>Point2D</code> at which to position the
  367        *   glyph at the specified <code>glyphIndex</code>
  368        * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
  369        *   is less than 0 or greater than the number of glyphs
  370        *   in this <code>GlyphVector</code>
  371        * @see #getGlyphPosition
  372        */
  373       public abstract void setGlyphPosition(int glyphIndex, Point2D newPos);
  374   
  375       /**
  376        * Returns the transform of the specified glyph within this
  377        * <code>GlyphVector</code>.  The transform is relative to the
  378        * glyph position.  If no special transform has been applied,
  379        * <code>null</code> can be returned.  A null return indicates
  380        * an identity transform.
  381        * @param glyphIndex the index into this <code>GlyphVector</code>
  382        * @return an {@link AffineTransform} that is the transform of
  383        *   the glyph at the specified <code>glyphIndex</code>.
  384        * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
  385        *   is less than 0 or greater than or equal to the number
  386        *   of glyphs in this <code>GlyphVector</code>
  387        * @see #setGlyphTransform
  388        */
  389       public abstract AffineTransform getGlyphTransform(int glyphIndex);
  390   
  391       /**
  392        * Sets the transform of the specified glyph within this
  393        * <code>GlyphVector</code>.  The transform is relative to the glyph
  394        * position.  A <code>null</code> argument for <code>newTX</code>
  395        * indicates that no special transform is applied for the specified
  396        * glyph.
  397        * This method can be used to rotate, mirror, translate and scale the
  398        * glyph.  Adding a transform can result in signifant performance changes.
  399        * @param glyphIndex the index into this <code>GlyphVector</code>
  400        * @param newTX the new transform of the glyph at <code>glyphIndex</code>
  401        * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
  402        *   is less than 0 or greater than or equal to the number
  403        *   of glyphs in this <code>GlyphVector</code>
  404        * @see #getGlyphTransform
  405        */
  406       public abstract void setGlyphTransform(int glyphIndex, AffineTransform newTX);
  407   
  408       /**
  409        * Returns flags describing the global state of the GlyphVector.
  410        * Flags not described below are reserved.  The default
  411        * implementation returns 0 (meaning false) for the position adjustments,
  412        * transforms, rtl, and complex flags.
  413        * Subclassers should override this method, and make sure
  414        * it correctly describes the GlyphVector and corresponds
  415        * to the results of related calls.
  416        * @return an int containing the flags describing the state
  417        * @see #FLAG_HAS_POSITION_ADJUSTMENTS
  418        * @see #FLAG_HAS_TRANSFORMS
  419        * @see #FLAG_RUN_RTL
  420        * @see #FLAG_COMPLEX_GLYPHS
  421        * @see #FLAG_MASK
  422        * @since 1.4
  423        */
  424       public int getLayoutFlags() {
  425                   return 0;
  426           }
  427   
  428       /**
  429        * A flag used with getLayoutFlags that indicates that this <code>GlyphVector</code> has
  430        * per-glyph transforms.
  431        * @since 1.4
  432        */
  433       public static final int FLAG_HAS_TRANSFORMS = 1;
  434   
  435       /**
  436        * A flag used with getLayoutFlags that indicates that this <code>GlyphVector</code> has
  437        * position adjustments.  When this is true, the glyph positions don't match the
  438        * accumulated default advances of the glyphs (for example, if kerning has been done).
  439        * @since 1.4
  440        */
  441       public static final int FLAG_HAS_POSITION_ADJUSTMENTS = 2;
  442   
  443       /**
  444        * A flag used with getLayoutFlags that indicates that this <code>GlyphVector</code> has
  445        * a right-to-left run direction.  This refers to the glyph-to-char mapping and does
  446        * not imply that the visual locations of the glyphs are necessarily in this order,
  447        * although generally they will be.
  448        * @since 1.4
  449        */
  450       public static final int FLAG_RUN_RTL = 4;
  451   
  452       /**
  453        * A flag used with getLayoutFlags that indicates that this <code>GlyphVector</code> has
  454        * a complex glyph-to-char mapping (one that does not map glyphs to chars one-to-one in
  455        * strictly ascending or descending order matching the run direction).
  456        * @since 1.4
  457        */
  458       public static final int FLAG_COMPLEX_GLYPHS = 8;
  459   
  460       /**
  461        * A mask for supported flags from getLayoutFlags.  Only bits covered by the mask
  462        * should be tested.
  463        * @since 1.4
  464        */
  465       public static final int FLAG_MASK =
  466           FLAG_HAS_TRANSFORMS |
  467           FLAG_HAS_POSITION_ADJUSTMENTS |
  468           FLAG_RUN_RTL |
  469           FLAG_COMPLEX_GLYPHS;
  470   
  471       /**
  472        * Returns an array of glyph positions for the specified glyphs.
  473        * This method is used for convenience and performance when
  474        * processing glyph positions.
  475        * If no array is passed in, a new array is created.
  476        * Even numbered array entries beginning with position zero are the X
  477        * coordinates of the glyph numbered <code>beginGlyphIndex + position/2</code>.
  478        * Odd numbered array entries beginning with position one are the Y
  479        * coordinates of the glyph numbered <code>beginGlyphIndex + (position-1)/2</code>.
  480        * If <code>beginGlyphIndex</code> equals the number of of glyphs in
  481        * this <code>GlyphVector</code>, this method gets the position after
  482        * the last glyph and this position is used to define the advance of
  483        * the entire <code>GlyphVector</code>.
  484        * @param beginGlyphIndex the index at which to begin retrieving
  485        *   glyph positions
  486        * @param numEntries the number of glyphs to retrieve
  487        * @param positionReturn the array that receives the glyph positions
  488        *   and is then returned.
  489        * @return an array of glyph positions specified by
  490        *  <code>beginGlyphIndex</code> and <code>numEntries</code>.
  491        * @throws IllegalArgumentException if <code>numEntries</code> is
  492        *   less than 0
  493        * @throws IndexOutOfBoundsException if <code>beginGlyphIndex</code>
  494        *   is less than 0
  495        * @throws IndexOutOfBoundsException if the sum of
  496        *   <code>beginGlyphIndex</code> and <code>numEntries</code>
  497        *   is greater than the number of glyphs in this
  498        *   <code>GlyphVector</code> plus one
  499        */
  500       public abstract float[] getGlyphPositions(int beginGlyphIndex, int numEntries,
  501                                                 float[] positionReturn);
  502   
  503       /**
  504        * Returns the logical bounds of the specified glyph within this
  505        * <code>GlyphVector</code>.
  506        * These logical bounds have a total of four edges, with two edges
  507        * parallel to the baseline under the glyph's transform and the other two
  508        * edges are shared with adjacent glyphs if they are present.  This
  509        * method is useful for hit-testing of the specified glyph,
  510        * positioning of a caret at the leading or trailing edge of a glyph,
  511        * and for drawing a highlight region around the specified glyph.
  512        * @param glyphIndex the index into this <code>GlyphVector</code>
  513        *   that corresponds to the glyph from which to retrieve its logical
  514        *   bounds
  515        * @return  a <code>Shape</code> that is the logical bounds of the
  516        *   glyph at the specified <code>glyphIndex</code>.
  517        * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
  518        *   is less than 0 or greater than or equal to the number
  519        *   of glyphs in this <code>GlyphVector</code>
  520        * @see #getGlyphVisualBounds
  521        */
  522       public abstract Shape getGlyphLogicalBounds(int glyphIndex);
  523   
  524       /**
  525        * Returns the visual bounds of the specified glyph within the
  526        * <code>GlyphVector</code>.
  527        * The bounds returned by this method is positioned around the
  528        * origin of each individual glyph.
  529        * @param glyphIndex the index into this <code>GlyphVector</code>
  530        *   that corresponds to the glyph from which to retrieve its visual
  531        *   bounds
  532        * @return a <code>Shape</code> that is the visual bounds of the
  533        *   glyph at the specified <code>glyphIndex</code>.
  534        * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
  535        *   is less than 0 or greater than or equal to the number
  536        *   of glyphs in this <code>GlyphVector</code>
  537        * @see #getGlyphLogicalBounds
  538        */
  539       public abstract Shape getGlyphVisualBounds(int glyphIndex);
  540   
  541       /**
  542        * Returns the pixel bounds of the glyph at index when this
  543        * <code>GlyphVector</code> is rendered in a <code>Graphics</code> with the
  544        * given <code>FontRenderContext</code> at the given location. The
  545        * renderFRC need not be the same as the
  546        * <code>FontRenderContext</code> of this
  547        * <code>GlyphVector</code>, and can be null.  If it is null, the
  548        * <code>FontRenderContext</code> of this <code>GlyphVector</code>
  549        * is used.  The default implementation returns the visual bounds of the glyph,
  550        * offset to x, y and rounded out to the next integer value, and
  551        * ignores the FRC.  Subclassers should override this method.
  552        * @param index the index of the glyph.
  553        * @param renderFRC the <code>FontRenderContext</code> of the <code>Graphics</code>.
  554        * @param x the X position at which to render this <code>GlyphVector</code>.
  555        * @param y the Y position at which to render this <code>GlyphVector</code>.
  556        * @return a <code>Rectangle</code> bounding the pixels that would be affected.
  557        * @since 1.4
  558        */
  559       public Rectangle getGlyphPixelBounds(int index, FontRenderContext renderFRC, float x, float y) {
  560                   Rectangle2D rect = getGlyphVisualBounds(index).getBounds2D();
  561                   int l = (int)Math.floor(rect.getX() + x);
  562                   int t = (int)Math.floor(rect.getY() + y);
  563                   int r = (int)Math.ceil(rect.getMaxX() + x);
  564                   int b = (int)Math.ceil(rect.getMaxY() + y);
  565                   return new Rectangle(l, t, r - l, b - t);
  566           }
  567   
  568       /**
  569        * Returns the metrics of the glyph at the specified index into
  570        * this <code>GlyphVector</code>.
  571        * @param glyphIndex the index into this <code>GlyphVector</code>
  572        *   that corresponds to the glyph from which to retrieve its metrics
  573        * @return a {@link GlyphMetrics} object that represents the
  574        *   metrics of the glyph at the specified <code>glyphIndex</code>
  575        *   into this <code>GlyphVector</code>.
  576        * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
  577        *   is less than 0 or greater than or equal to the number
  578        *   of glyphs in this <code>GlyphVector</code>
  579        */
  580       public abstract GlyphMetrics getGlyphMetrics(int glyphIndex);
  581   
  582       /**
  583        * Returns the justification information for the glyph at
  584        * the specified index into this <code>GlyphVector</code>.
  585        * @param glyphIndex the index into this <code>GlyphVector</code>
  586        *   that corresponds to the glyph from which to retrieve its
  587        *   justification properties
  588        * @return a {@link GlyphJustificationInfo} object that
  589        *   represents the justification properties of the glyph at the
  590        *   specified <code>glyphIndex</code> into this
  591        *   <code>GlyphVector</code>.
  592        * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
  593        *   is less than 0 or greater than or equal to the number
  594        *   of glyphs in this <code>GlyphVector</code>
  595        */
  596       public abstract GlyphJustificationInfo getGlyphJustificationInfo(int glyphIndex);
  597   
  598       //
  599       // general utility methods
  600       //
  601   
  602       /**
  603        * Tests if the specified <code>GlyphVector</code> exactly
  604        * equals this <code>GlyphVector</code>.
  605        * @param set the specified <code>GlyphVector</code> to test
  606        * @return <code>true</code> if the specified
  607        *   <code>GlyphVector</code> equals this <code>GlyphVector</code>;
  608        *   <code>false</code> otherwise.
  609        */
  610       public abstract boolean equals(GlyphVector set);
  611   }

Home » openjdk-7 » java » awt » font » [javadoc | source]