History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/awt/font/GlyphVector.java (1 of 18352 files). Show all

Unified · Split

java/pkg/java/awt/font/GlyphVector.java+611−0
@@ -0,0 +1,611 @@
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+}