1. /*

  2.  * @(#)GlyphMetrics.java	1.32 01/11/29

  3.  *

  4.  * Copyright 2002 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.  * advance, bounds, and left and right side bearings.  

  48.  * <p>

  49.  * The advance of a glyph is the distance from the glyph's origin to the

  50.  * origin of the next glyph.  Note that, in a <code>GlyphVector</code>, 

  51.  * the distance from a glyph to its following glyph might not be the 

  52.  * glyph's advance.  

  53.  * <p>

  54.  * The bounds is the smallest rectangle that completely contains the

  55.  * visible portion of the glyph.  The bounds rectangle is relative to the

  56.  * glyph's origin.  The left-side bearing is the distance from the glyph

  57.  * origin to the left of its bounds rectangle. If the left-side bearing is

  58.  * negative, part of the glyph is drawn to the left of its origin.  The

  59.  * right-side bearing is the distance from the right side of the bounds

  60.  * rectangle to the next glyph origin (the origin plus the advance).  If

  61.  * negative, part of the glyph is drawn to the right of the next glyph's

  62.  * origin.

  63.  * <p>

  64.  * Although instances of <code>GlyphMetrics</code> can be directly

  65.  * constructed, they are almost always obtained from a 

  66.  * <code>GlyphVector</code>.  Once constructed, <code>GlyphMetrics</code>

  67.  * objects are immutable.

  68.  * <p>

  69.  * <strong>Example</strong>:<p>

  70.  * Querying a <code>Font</code> for glyph information

  71.  * <blockquote><pre>

  72.  * Font font = ...;

  73.  * int glyphIndex = ...;

  74.  * GlyphMetrics metrics = GlyphVector.getGlyphMetrics(glyphIndex);

  75.  * int isStandard = metrics.isStandard();

  76.  * float glyphAdvance = metrics.getAdvance();

  77.  * </blockquote></pre>

  78.  * @see java.awt.Font

  79.  * @see GlyphVector

  80.  */

  81. 

  82. public final class GlyphMetrics {

  83.     /**

  84.      * The advance (horizontal or vertical) of the associated glyph.

  85.      */

  86.     // please please don't change the name of this field!  Some JNI code uses it

  87.     private float advance;

  88. 

  89.     /**

  90.      * The bounds of the associated glyph.

  91.      */

  92.     // please please don't change the name of this field!  Some JNI code uses it

  93.     private Rectangle2D.Float bounds;

  94. 

  95.     /**

  96.      * Additional information about the glyph encoded as a byte.

  97.      */

  98.     // please please don't change the name of this field!  Some JNI code uses it

  99.     private byte glyphType;

  100. 

  101.     /**

  102.      * Indicates a glyph that represents a single standard

  103.      * character.

  104.      */

  105.     public static final byte STANDARD = 0;

  106. 

  107.     /**

  108.      * Indicates a glyph that represents multiple characters

  109.      * as a ligature, for example 'fi' or 'ffi'.  It is followed by

  110.      * filler glyphs for the remaining characters. Filler and combining

  111.      * glyphs can be intermixed to control positioning of accent marks

  112.      * on the logically preceeding ligature.

  113.      */

  114.     public static final byte LIGATURE = 1;

  115. 

  116.     /**

  117.      * Indicates a glyph that represents a combining character,

  118.      * such as an umlaut.  There is no caret position between this glyph

  119.      * and the preceeding glyph.

  120.      */

  121.     public static final byte COMBINING = 2;

  122. 

  123.     /**

  124.      * Indicates a glyph with no corresponding character in the

  125.      * backing store.  The glyph is associated with the character

  126.      * represented by the logicaly preceeding non-component glyph.  This

  127.      * is used for kashida justification or other visual modifications to

  128.      * existing glyphs.  There is no caret position between this glyph

  129.      * and the preceeding glyph.

  130.      */

  131.     public static final byte COMPONENT = 3;

  132. 

  133. 

  134.     /**

  135.      * Indicates a glyph with no visual representation. It can

  136.      * be added to the other code values to indicate an invisible glyph.

  137.      */

  138.     public static final byte WHITESPACE = 4;

  139. 

  140.     /**

  141.      * Constructs a <code>GlyphMetrics</code> object.

  142.      * @param advance the advance width or height of the glyph

  143.      * @param bounds the black box bounds of the glyph

  144.      * @param glyphType the type of the glyph

  145.      */

  146.     public GlyphMetrics(float advance, Rectangle2D bounds, byte glyphType) {

  147.         this.advance = advance;

  148.         this.bounds = new Rectangle2D.Float();

  149.         this.bounds.setRect(bounds);

  150.         this.glyphType = glyphType;

  151.     }

  152. 

  153.     /**

  154.      * Returns the advance width or height of the glyph.

  155.      * @return the advance of the glyph.

  156.      */

  157.     public float getAdvance() {

  158.         return advance;

  159.     }

  160. 

  161.     /**

  162.      * Returns the black box bounds of the glyph.

  163.      * @return a {@link Rectangle2D} that is the bounds of the glyph.

  164.      */

  165.     public Rectangle2D getBounds2D() {

  166.         return new Rectangle2D.Float(bounds.x, bounds.y, bounds.width, bounds.height);

  167.     }

  168. 

  169.     /**

  170.      * Returns the left (top) side bearing of the glyph.

  171.      * <p>

  172.      * This is the distance from 0, 0 to the left (top) of the glyph

  173.      * bounds.  If the bounds of the glyph is to the left of (above) the

  174.      * origin, the LSB is negative.

  175.      * @return the left side bearing of the glyph.

  176.      */

  177.     public float getLSB() {

  178.         return bounds.x;

  179.     }

  180. 

  181.     /**

  182.      * Returns the right (bottom) side bearing of the glyph.

  183.      * <p>

  184.      * This is the distance from the right (bottom) of the glyph bounds to

  185.      * the advance. If the bounds of the glyph is to the right of (below)

  186.      * the advance, the RSB is negative.

  187.      * @return the right side bearing of the glyph.

  188.      */

  189.     public float getRSB() {

  190.         return advance - bounds.x - bounds.width;

  191.     }

  192. 

  193.     /**

  194.      * Returns the raw glyph type code.

  195.      * @return the raw glyph type code.

  196.      */

  197.     public int getType() {

  198.         return glyphType;

  199.     }

  200. 

  201.     /**

  202.      * Returns <code>true</code> if this is a standard glyph.

  203.      * @return <code>true</code> if this is a standard glyph;

  204.      *		<code>false</code> otherwise.

  205.      */

  206.     public boolean isStandard() {

  207.         return (glyphType & 0x3) == STANDARD;

  208.     }

  209. 

  210.     /**

  211.      * Returns <code>true</code> if this is a ligature glyph.

  212.      * @return <code>true</code> if this is a ligature glyph;

  213.      *		<code>false</code> otherwise.

  214.      */

  215.     public boolean isLigature() {

  216.         return (glyphType & 0x3) == LIGATURE;

  217.     }

  218. 

  219.     /**

  220.      * Returns <code>true</code> if this is a combining glyph.

  221.      * @return <code>true</code> if this is a combining glyph;

  222.      *		<code>false</code> otherwise.

  223.      */

  224.     public boolean isCombining() {

  225.         return (glyphType & 0x3) == COMBINING;

  226.     }

  227. 

  228.     /**

  229.      * Returns <code>true</code> if this is a component glyph.

  230.      * @return <code>true</code> if this is a component glyph;

  231.      *		<code>false</code> otherwise.

  232.      */

  233.     public boolean isComponent() {

  234.         return (glyphType & 0x3) == COMPONENT;

  235.     }

  236. 

  237.     /**

  238.      * Returns <code>true</code> if this is a whitespace glyph.

  239.      * @return <code>true</code> if this is a whitespace glyph;

  240.      *		<code>false</code> otherwise.

  241.      */

  242.     public boolean isWhitespace() {

  243.         return (glyphType & 0x4) == WHITESPACE;

  244.     }

  245. }

  246.