GlyphMetrics


1   /*
2    * @(#)GlyphMetrics.java    1.40 03/12/19
3    *
4    * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
5    * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6    */
7   
8   /*
9    * (C) Copyright Taligent, Inc. 1996 - 1997, All Rights Reserved
10   * (C) Copyright IBM Corp. 1996 - 1998, All Rights Reserved
11   *
12   * The original version of this source code and documentation is
13   * copyrighted and owned by Taligent, Inc., a wholly-owned subsidiary
14   * of IBM. These materials are provided under terms of a License
15   * Agreement between Taligent and Sun. This technology is protected
16   * by multiple US and International patents.
17   *
18   * This notice and attribution to Taligent may not be removed.
19   * Taligent is a registered trademark of Taligent, Inc.
20   *
21   */
22  
23  package java.awt.font;
24  
25  import java.awt.geom.Rectangle2D  ;
26  
27  /**
28   * The <code>GlyphMetrics</code> class represents infomation for a
29   * single glyph.   A glyph is the visual representation of one or more
30   * characters.  Many different glyphs can be used to represent a single
31   * character or combination of characters.  <code>GlyphMetrics</code>
32   * instances are produced by {@link java.awt.Font Font} and are applicable 
33   * to a specific glyph in a particular <code>Font</code>.
34   * <p>
35   * Glyphs are either STANDARD, LIGATURE, COMBINING, or COMPONENT.
36   * <ul>
37   * <li>STANDARD glyphs are commonly used to represent single characters.
38   * <li>LIGATURE glyphs are used to represent sequences of characters.
39   * <li>COMPONENT glyphs in a {@link GlyphVector} do not correspond to a
40   * particular character in a text model. Instead, COMPONENT glyphs are
41   * added for typographical reasons, such as Arabic justification.
42   * <li>COMBINING glyphs embellish STANDARD or LIGATURE glyphs, such
43   * as accent marks.  Carets do not appear before COMBINING glyphs.
44   * </ul>
45   * <p>
46   * Other metrics available through <code>GlyphMetrics</code> are the
47   * components of the advance, the visual bounds, and the left and right
48   * side bearings.
49   * <p>
50   * Glyphs for a rotated font, or obtained from a <code>GlyphVector</code>
51   * which has applied a rotation to the glyph, can have advances that
52   * contain both X and Y components.  Usually the advance only has one
53   * component.
54   * <p>
55   * The advance of a glyph is the distance from the glyph's origin to the
56   * origin of the next glyph along the baseline, which is either vertical
57   * or horizontal.  Note that, in a <code>GlyphVector</code>, 
58   * the distance from a glyph to its following glyph might not be the 
59   * glyph's advance, because of kerning or other positioning adjustments.  
60   * <p>
61   * The bounds is the smallest rectangle that completely contains the
62   * outline of the glyph.  The bounds rectangle is relative to the
63   * glyph's origin.  The left-side bearing is the distance from the glyph
64   * origin to the left of its bounds rectangle. If the left-side bearing is
65   * negative, part of the glyph is drawn to the left of its origin.  The
66   * right-side bearing is the distance from the right side of the bounds
67   * rectangle to the next glyph origin (the origin plus the advance).  If
68   * negative, part of the glyph is drawn to the right of the next glyph's
69   * origin.  Note that the bounds does not necessarily enclose all the pixels
70   * affected when rendering the glyph, because of rasterization and pixel
71   * adjustment effects.
72   * <p>
73   * Although instances of <code>GlyphMetrics</code> can be directly
74   * constructed, they are almost always obtained from a 
75   * <code>GlyphVector</code>.  Once constructed, <code>GlyphMetrics</code>
76   * objects are immutable.
77   * <p>
78   * <strong>Example</strong>:<p>
79   * Querying a <code>Font</code> for glyph information
80   * <blockquote><pre>
81   * Font font = ...;
82   * int glyphIndex = ...;
83   * GlyphMetrics metrics = GlyphVector.getGlyphMetrics(glyphIndex);
84   * int isStandard = metrics.isStandard();
85   * float glyphAdvance = metrics.getAdvance();
86   * </pre></blockquote>
87   * @see java.awt.Font
88   * @see GlyphVector
89   */
90  
91  public final class GlyphMetrics {
92      /** 
93       * Indicates whether the metrics are for a horizontal or vertical baseline.
94       */
95      private boolean horizontal;
96  
97      /**
98       * The x-component of the advance. 
99       */
100     private float advanceX;
101 
102     /** 
103      * The y-component of the advance. 
104      */
105     private float advanceY;
106 
107     /**
108      * The bounds of the associated glyph.
109      */
110     private Rectangle2D.Float   bounds;
111 
112     /**
113      * Additional information about the glyph encoded as a byte.
114      */
115     private byte glyphType;
116 
117     /**
118      * Indicates a glyph that represents a single standard
119      * character.
120      */
121     public static final byte STANDARD = 0;
122 
123     /**
124      * Indicates a glyph that represents multiple characters
125      * as a ligature, for example 'fi' or 'ffi'.  It is followed by
126      * filler glyphs for the remaining characters. Filler and combining
127      * glyphs can be intermixed to control positioning of accent marks
128      * on the logically preceeding ligature.
129      */
130     public static final byte LIGATURE = 1;
131 
132     /**
133      * Indicates a glyph that represents a combining character,
134      * such as an umlaut.  There is no caret position between this glyph
135      * and the preceeding glyph.
136      */
137     public static final byte COMBINING = 2;
138 
139     /**
140      * Indicates a glyph with no corresponding character in the
141      * backing store.  The glyph is associated with the character
142      * represented by the logicaly preceeding non-component glyph.  This
143      * is used for kashida justification or other visual modifications to
144      * existing glyphs.  There is no caret position between this glyph
145      * and the preceeding glyph.
146      */
147     public static final byte COMPONENT = 3;
148 
149     /**
150      * Indicates a glyph with no visual representation. It can
151      * be added to the other code values to indicate an invisible glyph.
152      */
153     public static final byte WHITESPACE = 4;
154 
155     /**
156      * Constructs a <code>GlyphMetrics</code> object.
157      * @param advance the advance width of the glyph
158      * @param bounds the black box bounds of the glyph
159      * @param glyphType the type of the glyph
160      */
161     public GlyphMetrics(float advance, Rectangle2D   bounds, byte glyphType) {
162     this.horizontal = true;
163         this.advanceX = advance;
164     this.advanceY = 0;
165         this.bounds = new Rectangle2D.Float  ();
166         this.bounds.setRect(bounds);
167         this.glyphType = glyphType;
168     }
169 
170     /**
171      * Constructs a <code>GlyphMetrics</code> object.
172      * @param horizontal if true, metrics are for a horizontal baseline, 
173      *   otherwise they are for a vertical baseline
174      * @param advanceX the X-component of the glyph's advance
175      * @param advanceY the Y-component of the glyph's advance
176      * @param bounds the visual bounds of the glyph
177      * @param glyphType the type of the glyph
178      */
179     public GlyphMetrics(boolean horizontal, float advanceX, float advanceY,
180             Rectangle2D   bounds, byte glyphType) {
181     
182     this.horizontal = horizontal;
183         this.advanceX = advanceX;
184     this.advanceY = advanceY;
185         this.bounds = new Rectangle2D.Float  ();
186         this.bounds.setRect(bounds);
187         this.glyphType = glyphType;
188     }
189 
190     /**
191      * Returns the advance of the glyph along the baseline (either 
192      * horizontal or vertical).
193      * @return the advance of the glyph
194      */
195     public float getAdvance() {
196         return horizontal ? advanceX : advanceY;
197     }
198 
199     /**
200      * Returns the x-component of the advance of the glyph.
201      * @return the x-component of the advance of the glyph
202      */
203     public float getAdvanceX() {
204         return advanceX;
205     }
206 
207     /**
208      * Returns the y-component of the advance of the glyph.
209      * @return the y-component of the advance of the glyph
210      */
211     public float getAdvanceY() {
212         return advanceY;
213     }
214 
215     /**
216      * Returns the bounds of the glyph. This is the bounding box of the glyph outline.
217      * Because of rasterization and pixel alignment effects, it does not necessarily
218      * enclose the pixels that are affected when rendering the glyph.
219      * @return a {@link Rectangle2D} that is the bounds of the glyph.
220      */
221     public Rectangle2D   getBounds2D() {
222         return new Rectangle2D.Float  (bounds.x, bounds.y, bounds.width, bounds.height);
223     }
224 
225     /**
226      * Returns the left (top) side bearing of the glyph.
227      * <p>
228      * This is the distance from 0,&nbsp;0 to the left (top) of the glyph
229      * bounds.  If the bounds of the glyph is to the left of (above) the
230      * origin, the LSB is negative.
231      * @return the left side bearing of the glyph.
232      */
233     public float getLSB() {
234         return horizontal ? bounds.x : bounds.y;
235     }
236 
237     /**
238      * Returns the right (bottom) side bearing of the glyph.
239      * <p>
240      * This is the distance from the right (bottom) of the glyph bounds to
241      * the advance. If the bounds of the glyph is to the right of (below)
242      * the advance, the RSB is negative.
243      * @return the right side bearing of the glyph.
244      */
245     public float getRSB() {
246         return horizontal ?
247         advanceX - bounds.x - bounds.width :
248         advanceY - bounds.y - bounds.height;
249     }
250 
251     /**
252      * Returns the raw glyph type code.
253      * @return the raw glyph type code.
254      */
255     public int getType() {
256         return glyphType;
257     }
258 
259     /**
260      * Returns <code>true</code> if this is a standard glyph.
261      * @return <code>true</code> if this is a standard glyph;
262      *      <code>false</code> otherwise.
263      */
264     public boolean isStandard() {
265         return (glyphType & 0x3) == STANDARD;
266     }
267 
268     /**
269      * Returns <code>true</code> if this is a ligature glyph.
270      * @return <code>true</code> if this is a ligature glyph;
271      *      <code>false</code> otherwise.
272      */
273     public boolean isLigature() {
274         return (glyphType & 0x3) == LIGATURE;
275     }
276 
277     /**
278      * Returns <code>true</code> if this is a combining glyph.
279      * @return <code>true</code> if this is a combining glyph;
280      *      <code>false</code> otherwise.
281      */
282     public boolean isCombining() {
283         return (glyphType & 0x3) == COMBINING;
284     }
285 
286     /**
287      * Returns <code>true</code> if this is a component glyph.
288      * @return <code>true</code> if this is a component glyph;
289      *      <code>false</code> otherwise.
290      */
291     public boolean isComponent() {
292         return (glyphType & 0x3) == COMPONENT;
293     }
294 
295     /**
296      * Returns <code>true</code> if this is a whitespace glyph.
297      * @return <code>true</code> if this is a whitespace glyph;
298      *      <code>false</code> otherwise.
299      */
300     public boolean isWhitespace() {
301         return (glyphType & 0x4) == WHITESPACE;
302     }
303 }
304 
305
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags