View Javadoc
1   /*
2    * Copyright (c) 1998, 2013, 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 significant 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 }